?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[wrt350n-kernel.git] / net / mac80211 / ieee80211_sta.c
blobd717d0dbf10d8689d3ec9c9861014813bcf30143
1 /*
2 * BSS client mode implementation
3 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
4 * Copyright 2004, Instant802 Networks, Inc.
5 * Copyright 2005, Devicescape Software, Inc.
6 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
7 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14 /* TODO:
15 * order BSS list by RSSI(?) ("quality of AP")
16 * scan result table filtering (by capability (privacy, IBSS/BSS, WPA/RSN IE,
17 * SSID)
18 */
19 #include <linux/delay.h>
20 #include <linux/if_ether.h>
21 #include <linux/skbuff.h>
22 #include <linux/netdevice.h>
23 #include <linux/if_arp.h>
24 #include <linux/wireless.h>
25 #include <linux/random.h>
26 #include <linux/etherdevice.h>
27 #include <net/iw_handler.h>
28 #include <asm/types.h>
29
30 #include <net/mac80211.h>
31 #include "ieee80211_i.h"
32 #include "ieee80211_rate.h"
33 #include "ieee80211_led.h"
34
35 #define IEEE80211_AUTH_TIMEOUT (HZ / 5)
36 #define IEEE80211_AUTH_MAX_TRIES 3
37 #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
38 #define IEEE80211_ASSOC_MAX_TRIES 3
39 #define IEEE80211_MONITORING_INTERVAL (2 * HZ)
40 #define IEEE80211_PROBE_INTERVAL (60 * HZ)
41 #define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ)
42 #define IEEE80211_SCAN_INTERVAL (2 * HZ)
43 #define IEEE80211_SCAN_INTERVAL_SLOW (15 * HZ)
44 #define IEEE80211_IBSS_JOIN_TIMEOUT (20 * HZ)
45
46 #define IEEE80211_PROBE_DELAY (HZ / 33)
47 #define IEEE80211_CHANNEL_TIME (HZ / 33)
48 #define IEEE80211_PASSIVE_CHANNEL_TIME (HZ / 5)
49 #define IEEE80211_SCAN_RESULT_EXPIRE (10 * HZ)
50 #define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
51 #define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
52
53 #define IEEE80211_IBSS_MAX_STA_ENTRIES 128
54
55
56 #define IEEE80211_FC(type, stype) cpu_to_le16(type | stype)
57
58 #define ERP_INFO_USE_PROTECTION BIT(1)
59
60 /* mgmt header + 1 byte action code */
61 #define IEEE80211_MIN_ACTION_SIZE (24 + 1)
62
63 #define IEEE80211_ADDBA_PARAM_POLICY_MASK 0x0002
64 #define IEEE80211_ADDBA_PARAM_TID_MASK 0x003C
65 #define IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK 0xFFA0
66 #define IEEE80211_DELBA_PARAM_TID_MASK 0xF000
67 #define IEEE80211_DELBA_PARAM_INITIATOR_MASK 0x0800
68
69 /* next values represent the buffer size for A-MPDU frame.
70 * According to IEEE802.11n spec size varies from 8K to 64K (in powers of 2) */
71 #define IEEE80211_MIN_AMPDU_BUF 0x8
72 #define IEEE80211_MAX_AMPDU_BUF 0x40
73
74 static void ieee80211_send_probe_req(struct net_device *dev, u8 *dst,
75 u8 *ssid, size_t ssid_len);
76 static struct ieee80211_sta_bss *
77 ieee80211_rx_bss_get(struct net_device *dev, u8 *bssid, int channel,
78 u8 *ssid, u8 ssid_len);
79 static void ieee80211_rx_bss_put(struct net_device *dev,
80 struct ieee80211_sta_bss *bss);
81 static int ieee80211_sta_find_ibss(struct net_device *dev,
82 struct ieee80211_if_sta *ifsta);
83 static int ieee80211_sta_wep_configured(struct net_device *dev);
84 static int ieee80211_sta_start_scan(struct net_device *dev,
85 u8 *ssid, size_t ssid_len);
86 static int ieee80211_sta_config_auth(struct net_device *dev,
87 struct ieee80211_if_sta *ifsta);
88
89
90 /* Parsed Information Elements */
91 struct ieee802_11_elems {
92 /* pointers to IEs */
93 u8 *ssid;
94 u8 *supp_rates;
95 u8 *fh_params;
96 u8 *ds_params;
97 u8 *cf_params;
98 u8 *tim;
99 u8 *ibss_params;
100 u8 *challenge;
101 u8 *wpa;
102 u8 *rsn;
103 u8 *erp_info;
104 u8 *ext_supp_rates;
105 u8 *wmm_info;
106 u8 *wmm_param;
107 u8 *ht_cap_elem;
108 u8 *ht_info_elem;
109 /* length of them, respectively */
110 u8 ssid_len;
111 u8 supp_rates_len;
112 u8 fh_params_len;
113 u8 ds_params_len;
114 u8 cf_params_len;
115 u8 tim_len;
116 u8 ibss_params_len;
117 u8 challenge_len;
118 u8 wpa_len;
119 u8 rsn_len;
120 u8 erp_info_len;
121 u8 ext_supp_rates_len;
122 u8 wmm_info_len;
123 u8 wmm_param_len;
124 u8 ht_cap_elem_len;
125 u8 ht_info_elem_len;
126 };
127
128 static void ieee802_11_parse_elems(u8 *start, size_t len,
129 struct ieee802_11_elems *elems)
130 {
131 size_t left = len;
132 u8 *pos = start;
133
134 memset(elems, 0, sizeof(*elems));
135
136 while (left >= 2) {
137 u8 id, elen;
138
139 id = *pos++;
140 elen = *pos++;
141 left -= 2;
142
143 if (elen > left)
144 return;
145
146 switch (id) {
147 case WLAN_EID_SSID:
148 elems->ssid = pos;
149 elems->ssid_len = elen;
150 break;
151 case WLAN_EID_SUPP_RATES:
152 elems->supp_rates = pos;
153 elems->supp_rates_len = elen;
154 break;
155 case WLAN_EID_FH_PARAMS:
156 elems->fh_params = pos;
157 elems->fh_params_len = elen;
158 break;
159 case WLAN_EID_DS_PARAMS:
160 elems->ds_params = pos;
161 elems->ds_params_len = elen;
162 break;
163 case WLAN_EID_CF_PARAMS:
164 elems->cf_params = pos;
165 elems->cf_params_len = elen;
166 break;
167 case WLAN_EID_TIM:
168 elems->tim = pos;
169 elems->tim_len = elen;
170 break;
171 case WLAN_EID_IBSS_PARAMS:
172 elems->ibss_params = pos;
173 elems->ibss_params_len = elen;
174 break;
175 case WLAN_EID_CHALLENGE:
176 elems->challenge = pos;
177 elems->challenge_len = elen;
178 break;
179 case WLAN_EID_WPA:
180 if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
181 pos[2] == 0xf2) {
182 /* Microsoft OUI (00:50:F2) */
183 if (pos[3] == 1) {
184 /* OUI Type 1 - WPA IE */
185 elems->wpa = pos;
186 elems->wpa_len = elen;
187 } else if (elen >= 5 && pos[3] == 2) {
188 if (pos[4] == 0) {
189 elems->wmm_info = pos;
190 elems->wmm_info_len = elen;
191 } else if (pos[4] == 1) {
192 elems->wmm_param = pos;
193 elems->wmm_param_len = elen;
194 }
195 }
196 }
197 break;
198 case WLAN_EID_RSN:
199 elems->rsn = pos;
200 elems->rsn_len = elen;
201 break;
202 case WLAN_EID_ERP_INFO:
203 elems->erp_info = pos;
204 elems->erp_info_len = elen;
205 break;
206 case WLAN_EID_EXT_SUPP_RATES:
207 elems->ext_supp_rates = pos;
208 elems->ext_supp_rates_len = elen;
209 break;
210 case WLAN_EID_HT_CAPABILITY:
211 elems->ht_cap_elem = pos;
212 elems->ht_cap_elem_len = elen;
213 break;
214 case WLAN_EID_HT_EXTRA_INFO:
215 elems->ht_info_elem = pos;
216 elems->ht_info_elem_len = elen;
217 break;
218 default:
219 break;
220 }
221
222 left -= elen;
223 pos += elen;
224 }
225 }
226
227
228 static int ecw2cw(int ecw)
229 {
230 int cw = 1;
231 while (ecw > 0) {
232 cw <<= 1;
233 ecw--;
234 }
235 return cw - 1;
236 }
237
238 static void ieee80211_sta_wmm_params(struct net_device *dev,
239 struct ieee80211_if_sta *ifsta,
240 u8 *wmm_param, size_t wmm_param_len)
241 {
242 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
243 struct ieee80211_tx_queue_params params;
244 size_t left;
245 int count;
246 u8 *pos;
247
248 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
249 return;
250 count = wmm_param[6] & 0x0f;
251 if (count == ifsta->wmm_last_param_set)
252 return;
253 ifsta->wmm_last_param_set = count;
254
255 pos = wmm_param + 8;
256 left = wmm_param_len - 8;
257
258 memset(&params, 0, sizeof(params));
259
260 if (!local->ops->conf_tx)
261 return;
262
263 local->wmm_acm = 0;
264 for (; left >= 4; left -= 4, pos += 4) {
265 int aci = (pos[0] >> 5) & 0x03;
266 int acm = (pos[0] >> 4) & 0x01;
267 int queue;
268
269 switch (aci) {
270 case 1:
271 queue = IEEE80211_TX_QUEUE_DATA3;
272 if (acm) {
273 local->wmm_acm |= BIT(0) | BIT(3);
274 }
275 break;
276 case 2:
277 queue = IEEE80211_TX_QUEUE_DATA1;
278 if (acm) {
279 local->wmm_acm |= BIT(4) | BIT(5);
280 }
281 break;
282 case 3:
283 queue = IEEE80211_TX_QUEUE_DATA0;
284 if (acm) {
285 local->wmm_acm |= BIT(6) | BIT(7);
286 }
287 break;
288 case 0:
289 default:
290 queue = IEEE80211_TX_QUEUE_DATA2;
291 if (acm) {
292 local->wmm_acm |= BIT(1) | BIT(2);
293 }
294 break;
295 }
296
297 params.aifs = pos[0] & 0x0f;
298 params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
299 params.cw_min = ecw2cw(pos[1] & 0x0f);
300 /* TXOP is in units of 32 usec; burst_time in 0.1 ms */
301 params.burst_time = (pos[2] | (pos[3] << 8)) * 32 / 100;
302 printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d "
303 "cWmin=%d cWmax=%d burst=%d\n",
304 dev->name, queue, aci, acm, params.aifs, params.cw_min,
305 params.cw_max, params.burst_time);
306 /* TODO: handle ACM (block TX, fallback to next lowest allowed
307 * AC for now) */
308 if (local->ops->conf_tx(local_to_hw(local), queue, &params)) {
309 printk(KERN_DEBUG "%s: failed to set TX queue "
310 "parameters for queue %d\n", dev->name, queue);
311 }
312 }
313 }
314
315
316 static u32 ieee80211_handle_erp_ie(struct ieee80211_sub_if_data *sdata,
317 u8 erp_value)
318 {
319 struct ieee80211_bss_conf *bss_conf = &sdata->bss_conf;
320 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
321 bool use_protection = (erp_value & WLAN_ERP_USE_PROTECTION) != 0;
322 bool preamble_mode = (erp_value & WLAN_ERP_BARKER_PREAMBLE) != 0;
323 DECLARE_MAC_BUF(mac);
324 u32 changed = 0;
325
326 if (use_protection != bss_conf->use_cts_prot) {
327 if (net_ratelimit()) {
328 printk(KERN_DEBUG "%s: CTS protection %s (BSSID="
329 "%s)\n",
330 sdata->dev->name,
331 use_protection ? "enabled" : "disabled",
332 print_mac(mac, ifsta->bssid));
333 }
334 bss_conf->use_cts_prot = use_protection;
335 changed |= BSS_CHANGED_ERP_CTS_PROT;
336 }
337
338 if (preamble_mode != bss_conf->use_short_preamble) {
339 if (net_ratelimit()) {
340 printk(KERN_DEBUG "%s: switched to %s barker preamble"
341 " (BSSID=%s)\n",
342 sdata->dev->name,
343 (preamble_mode == WLAN_ERP_PREAMBLE_SHORT) ?
344 "short" : "long",
345 print_mac(mac, ifsta->bssid));
346 }
347 bss_conf->use_short_preamble = preamble_mode;
348 changed |= BSS_CHANGED_ERP_PREAMBLE;
349 }
350
351 return changed;
352 }
353
354 int ieee80211_ht_cap_ie_to_ht_info(struct ieee80211_ht_cap *ht_cap_ie,
355 struct ieee80211_ht_info *ht_info)
356 {
357
358 if (ht_info == NULL)
359 return -EINVAL;
360
361 memset(ht_info, 0, sizeof(*ht_info));
362
363 if (ht_cap_ie) {
364 u8 ampdu_info = ht_cap_ie->ampdu_params_info;
365
366 ht_info->ht_supported = 1;
367 ht_info->cap = le16_to_cpu(ht_cap_ie->cap_info);
368 ht_info->ampdu_factor =
369 ampdu_info & IEEE80211_HT_CAP_AMPDU_FACTOR;
370 ht_info->ampdu_density =
371 (ampdu_info & IEEE80211_HT_CAP_AMPDU_DENSITY) >> 2;
372 memcpy(ht_info->supp_mcs_set, ht_cap_ie->supp_mcs_set, 16);
373 } else
374 ht_info->ht_supported = 0;
375
376 return 0;
377 }
378
379 int ieee80211_ht_addt_info_ie_to_ht_bss_info(
380 struct ieee80211_ht_addt_info *ht_add_info_ie,
381 struct ieee80211_ht_bss_info *bss_info)
382 {
383 if (bss_info == NULL)
384 return -EINVAL;
385
386 memset(bss_info, 0, sizeof(*bss_info));
387
388 if (ht_add_info_ie) {
389 u16 op_mode;
390 op_mode = le16_to_cpu(ht_add_info_ie->operation_mode);
391
392 bss_info->primary_channel = ht_add_info_ie->control_chan;
393 bss_info->bss_cap = ht_add_info_ie->ht_param;
394 bss_info->bss_op_mode = (u8)(op_mode & 0xff);
395 }
396
397 return 0;
398 }
399
400 static void ieee80211_sta_send_associnfo(struct net_device *dev,
401 struct ieee80211_if_sta *ifsta)
402 {
403 char *buf;
404 size_t len;
405 int i;
406 union iwreq_data wrqu;
407
408 if (!ifsta->assocreq_ies && !ifsta->assocresp_ies)
409 return;
410
411 buf = kmalloc(50 + 2 * (ifsta->assocreq_ies_len +
412 ifsta->assocresp_ies_len), GFP_KERNEL);
413 if (!buf)
414 return;
415
416 len = sprintf(buf, "ASSOCINFO(");
417 if (ifsta->assocreq_ies) {
418 len += sprintf(buf + len, "ReqIEs=");
419 for (i = 0; i < ifsta->assocreq_ies_len; i++) {
420 len += sprintf(buf + len, "%02x",
421 ifsta->assocreq_ies[i]);
422 }
423 }
424 if (ifsta->assocresp_ies) {
425 if (ifsta->assocreq_ies)
426 len += sprintf(buf + len, " ");
427 len += sprintf(buf + len, "RespIEs=");
428 for (i = 0; i < ifsta->assocresp_ies_len; i++) {
429 len += sprintf(buf + len, "%02x",
430 ifsta->assocresp_ies[i]);
431 }
432 }
433 len += sprintf(buf + len, ")");
434
435 if (len > IW_CUSTOM_MAX) {
436 len = sprintf(buf, "ASSOCRESPIE=");
437 for (i = 0; i < ifsta->assocresp_ies_len; i++) {
438 len += sprintf(buf + len, "%02x",
439 ifsta->assocresp_ies[i]);
440 }
441 }
442
443 memset(&wrqu, 0, sizeof(wrqu));
444 wrqu.data.length = len;
445 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
446
447 kfree(buf);
448 }
449
450
451 static void ieee80211_set_associated(struct net_device *dev,
452 struct ieee80211_if_sta *ifsta,
453 bool assoc)
454 {
455 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
456 struct ieee80211_local *local = sdata->local;
457 union iwreq_data wrqu;
458 u32 changed = BSS_CHANGED_ASSOC;
459
460 if (assoc) {
461 struct ieee80211_sta_bss *bss;
462
463 ifsta->flags |= IEEE80211_STA_ASSOCIATED;
464
465 if (sdata->vif.type != IEEE80211_IF_TYPE_STA)
466 return;
467
468 bss = ieee80211_rx_bss_get(dev, ifsta->bssid,
469 local->hw.conf.channel,
470 ifsta->ssid, ifsta->ssid_len);
471 if (bss) {
472 if (bss->has_erp_value)
473 changed |= ieee80211_handle_erp_ie(
474 sdata, bss->erp_value);
475 ieee80211_rx_bss_put(dev, bss);
476 }
477
478 netif_carrier_on(dev);
479 ifsta->flags |= IEEE80211_STA_PREV_BSSID_SET;
480 memcpy(ifsta->prev_bssid, sdata->u.sta.bssid, ETH_ALEN);
481 memcpy(wrqu.ap_addr.sa_data, sdata->u.sta.bssid, ETH_ALEN);
482 ieee80211_sta_send_associnfo(dev, ifsta);
483 } else {
484 ifsta->flags &= ~IEEE80211_STA_ASSOCIATED;
485
486 netif_carrier_off(dev);
487 ieee80211_reset_erp_info(dev);
488 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
489 }
490 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
491 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
492 ifsta->last_probe = jiffies;
493 ieee80211_led_assoc(local, assoc);
494
495 ieee80211_bss_info_change_notify(sdata, changed);
496 }
497
498 static void ieee80211_set_disassoc(struct net_device *dev,
499 struct ieee80211_if_sta *ifsta, int deauth)
500 {
501 if (deauth)
502 ifsta->auth_tries = 0;
503 ifsta->assoc_tries = 0;
504 ieee80211_set_associated(dev, ifsta, 0);
505 }
506
507 static void ieee80211_sta_tx(struct net_device *dev, struct sk_buff *skb,
508 int encrypt)
509 {
510 struct ieee80211_sub_if_data *sdata;
511 struct ieee80211_tx_packet_data *pkt_data;
512
513 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
514 skb->dev = sdata->local->mdev;
515 skb_set_mac_header(skb, 0);
516 skb_set_network_header(skb, 0);
517 skb_set_transport_header(skb, 0);
518
519 pkt_data = (struct ieee80211_tx_packet_data *) skb->cb;
520 memset(pkt_data, 0, sizeof(struct ieee80211_tx_packet_data));
521 pkt_data->ifindex = sdata->dev->ifindex;
522 if (!encrypt)
523 pkt_data->flags |= IEEE80211_TXPD_DO_NOT_ENCRYPT;
524
525 dev_queue_xmit(skb);
526 }
527
528
529 static void ieee80211_send_auth(struct net_device *dev,
530 struct ieee80211_if_sta *ifsta,
531 int transaction, u8 *extra, size_t extra_len,
532 int encrypt)
533 {
534 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
535 struct sk_buff *skb;
536 struct ieee80211_mgmt *mgmt;
537
538 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
539 sizeof(*mgmt) + 6 + extra_len);
540 if (!skb) {
541 printk(KERN_DEBUG "%s: failed to allocate buffer for auth "
542 "frame\n", dev->name);
543 return;
544 }
545 skb_reserve(skb, local->hw.extra_tx_headroom);
546
547 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
548 memset(mgmt, 0, 24 + 6);
549 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
550 IEEE80211_STYPE_AUTH);
551 if (encrypt)
552 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
553 memcpy(mgmt->da, ifsta->bssid, ETH_ALEN);
554 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
555 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
556 mgmt->u.auth.auth_alg = cpu_to_le16(ifsta->auth_alg);
557 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
558 ifsta->auth_transaction = transaction + 1;
559 mgmt->u.auth.status_code = cpu_to_le16(0);
560 if (extra)
561 memcpy(skb_put(skb, extra_len), extra, extra_len);
562
563 ieee80211_sta_tx(dev, skb, encrypt);
564 }
565
566
567 static void ieee80211_authenticate(struct net_device *dev,
568 struct ieee80211_if_sta *ifsta)
569 {
570 DECLARE_MAC_BUF(mac);
571
572 ifsta->auth_tries++;
573 if (ifsta->auth_tries > IEEE80211_AUTH_MAX_TRIES) {
574 printk(KERN_DEBUG "%s: authentication with AP %s"
575 " timed out\n",
576 dev->name, print_mac(mac, ifsta->bssid));
577 ifsta->state = IEEE80211_DISABLED;
578 return;
579 }
580
581 ifsta->state = IEEE80211_AUTHENTICATE;
582 printk(KERN_DEBUG "%s: authenticate with AP %s\n",
583 dev->name, print_mac(mac, ifsta->bssid));
584
585 ieee80211_send_auth(dev, ifsta, 1, NULL, 0, 0);
586
587 mod_timer(&ifsta->timer, jiffies + IEEE80211_AUTH_TIMEOUT);
588 }
589
590
591 static void ieee80211_send_assoc(struct net_device *dev,
592 struct ieee80211_if_sta *ifsta)
593 {
594 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
595 struct ieee80211_hw_mode *mode;
596 struct sk_buff *skb;
597 struct ieee80211_mgmt *mgmt;
598 u8 *pos, *ies;
599 int i, len;
600 u16 capab;
601 struct ieee80211_sta_bss *bss;
602 int wmm = 0;
603
604 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
605 sizeof(*mgmt) + 200 + ifsta->extra_ie_len +
606 ifsta->ssid_len);
607 if (!skb) {
608 printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "
609 "frame\n", dev->name);
610 return;
611 }
612 skb_reserve(skb, local->hw.extra_tx_headroom);
613
614 mode = local->oper_hw_mode;
615 capab = ifsta->capab;
616 if (mode->mode == MODE_IEEE80211G) {
617 capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME |
618 WLAN_CAPABILITY_SHORT_PREAMBLE;
619 }
620 bss = ieee80211_rx_bss_get(dev, ifsta->bssid, local->hw.conf.channel,
621 ifsta->ssid, ifsta->ssid_len);
622 if (bss) {
623 if (bss->capability & WLAN_CAPABILITY_PRIVACY)
624 capab |= WLAN_CAPABILITY_PRIVACY;
625 if (bss->wmm_ie) {
626 wmm = 1;
627 }
628 ieee80211_rx_bss_put(dev, bss);
629 }
630
631 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
632 memset(mgmt, 0, 24);
633 memcpy(mgmt->da, ifsta->bssid, ETH_ALEN);
634 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
635 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
636
637 if (ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) {
638 skb_put(skb, 10);
639 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
640 IEEE80211_STYPE_REASSOC_REQ);
641 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
642 mgmt->u.reassoc_req.listen_interval = cpu_to_le16(1);
643 memcpy(mgmt->u.reassoc_req.current_ap, ifsta->prev_bssid,
644 ETH_ALEN);
645 } else {
646 skb_put(skb, 4);
647 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
648 IEEE80211_STYPE_ASSOC_REQ);
649 mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
650 mgmt->u.assoc_req.listen_interval = cpu_to_le16(1);
651 }
652
653 /* SSID */
654 ies = pos = skb_put(skb, 2 + ifsta->ssid_len);
655 *pos++ = WLAN_EID_SSID;
656 *pos++ = ifsta->ssid_len;
657 memcpy(pos, ifsta->ssid, ifsta->ssid_len);
658
659 len = mode->num_rates;
660 if (len > 8)
661 len = 8;
662 pos = skb_put(skb, len + 2);
663 *pos++ = WLAN_EID_SUPP_RATES;
664 *pos++ = len;
665 for (i = 0; i < len; i++) {
666 int rate = mode->rates[i].rate;
667 *pos++ = (u8) (rate / 5);
668 }
669
670 if (mode->num_rates > len) {
671 pos = skb_put(skb, mode->num_rates - len + 2);
672 *pos++ = WLAN_EID_EXT_SUPP_RATES;
673 *pos++ = mode->num_rates - len;
674 for (i = len; i < mode->num_rates; i++) {
675 int rate = mode->rates[i].rate;
676 *pos++ = (u8) (rate / 5);
677 }
678 }
679
680 if (ifsta->extra_ie) {
681 pos = skb_put(skb, ifsta->extra_ie_len);
682 memcpy(pos, ifsta->extra_ie, ifsta->extra_ie_len);
683 }
684
685 if (wmm && (ifsta->flags & IEEE80211_STA_WMM_ENABLED)) {
686 pos = skb_put(skb, 9);
687 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
688 *pos++ = 7; /* len */
689 *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
690 *pos++ = 0x50;
691 *pos++ = 0xf2;
692 *pos++ = 2; /* WME */
693 *pos++ = 0; /* WME info */
694 *pos++ = 1; /* WME ver */
695 *pos++ = 0;
696 }
697 /* wmm support is a must to HT */
698 if (wmm && mode->ht_info.ht_supported) {
699 __le16 tmp = cpu_to_le16(mode->ht_info.cap);
700 pos = skb_put(skb, sizeof(struct ieee80211_ht_cap)+2);
701 *pos++ = WLAN_EID_HT_CAPABILITY;
702 *pos++ = sizeof(struct ieee80211_ht_cap);
703 memset(pos, 0, sizeof(struct ieee80211_ht_cap));
704 memcpy(pos, &tmp, sizeof(u16));
705 pos += sizeof(u16);
706 *pos++ = (mode->ht_info.ampdu_factor |
707 (mode->ht_info.ampdu_density << 2));
708 memcpy(pos, mode->ht_info.supp_mcs_set, 16);
709 }
710
711 kfree(ifsta->assocreq_ies);
712 ifsta->assocreq_ies_len = (skb->data + skb->len) - ies;
713 ifsta->assocreq_ies = kmalloc(ifsta->assocreq_ies_len, GFP_KERNEL);
714 if (ifsta->assocreq_ies)
715 memcpy(ifsta->assocreq_ies, ies, ifsta->assocreq_ies_len);
716
717 ieee80211_sta_tx(dev, skb, 0);
718 }
719
720
721 static void ieee80211_send_deauth(struct net_device *dev,
722 struct ieee80211_if_sta *ifsta, u16 reason)
723 {
724 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
725 struct sk_buff *skb;
726 struct ieee80211_mgmt *mgmt;
727
728 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));
729 if (!skb) {
730 printk(KERN_DEBUG "%s: failed to allocate buffer for deauth "
731 "frame\n", dev->name);
732 return;
733 }
734 skb_reserve(skb, local->hw.extra_tx_headroom);
735
736 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
737 memset(mgmt, 0, 24);
738 memcpy(mgmt->da, ifsta->bssid, ETH_ALEN);
739 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
740 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
741 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
742 IEEE80211_STYPE_DEAUTH);
743 skb_put(skb, 2);
744 mgmt->u.deauth.reason_code = cpu_to_le16(reason);
745
746 ieee80211_sta_tx(dev, skb, 0);
747 }
748
749
750 static void ieee80211_send_disassoc(struct net_device *dev,
751 struct ieee80211_if_sta *ifsta, u16 reason)
752 {
753 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
754 struct sk_buff *skb;
755 struct ieee80211_mgmt *mgmt;
756
757 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));
758 if (!skb) {
759 printk(KERN_DEBUG "%s: failed to allocate buffer for disassoc "
760 "frame\n", dev->name);
761 return;
762 }
763 skb_reserve(skb, local->hw.extra_tx_headroom);
764
765 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
766 memset(mgmt, 0, 24);
767 memcpy(mgmt->da, ifsta->bssid, ETH_ALEN);
768 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
769 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
770 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
771 IEEE80211_STYPE_DISASSOC);
772 skb_put(skb, 2);
773 mgmt->u.disassoc.reason_code = cpu_to_le16(reason);
774
775 ieee80211_sta_tx(dev, skb, 0);
776 }
777
778
779 static int ieee80211_privacy_mismatch(struct net_device *dev,
780 struct ieee80211_if_sta *ifsta)
781 {
782 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
783 struct ieee80211_sta_bss *bss;
784 int bss_privacy;
785 int wep_privacy;
786 int privacy_invoked;
787
788 if (!ifsta || (ifsta->flags & IEEE80211_STA_MIXED_CELL))
789 return 0;
790
791 bss = ieee80211_rx_bss_get(dev, ifsta->bssid, local->hw.conf.channel,
792 ifsta->ssid, ifsta->ssid_len);
793 if (!bss)
794 return 0;
795
796 bss_privacy = !!(bss->capability & WLAN_CAPABILITY_PRIVACY);
797 wep_privacy = !!ieee80211_sta_wep_configured(dev);
798 privacy_invoked = !!(ifsta->flags & IEEE80211_STA_PRIVACY_INVOKED);
799
800 ieee80211_rx_bss_put(dev, bss);
801
802 if ((bss_privacy == wep_privacy) || (bss_privacy == privacy_invoked))
803 return 0;
804
805 return 1;
806 }
807
808
809 static void ieee80211_associate(struct net_device *dev,
810 struct ieee80211_if_sta *ifsta)
811 {
812 DECLARE_MAC_BUF(mac);
813
814 ifsta->assoc_tries++;
815 if (ifsta->assoc_tries > IEEE80211_ASSOC_MAX_TRIES) {
816 printk(KERN_DEBUG "%s: association with AP %s"
817 " timed out\n",
818 dev->name, print_mac(mac, ifsta->bssid));
819 ifsta->state = IEEE80211_DISABLED;
820 return;
821 }
822
823 ifsta->state = IEEE80211_ASSOCIATE;
824 printk(KERN_DEBUG "%s: associate with AP %s\n",
825 dev->name, print_mac(mac, ifsta->bssid));
826 if (ieee80211_privacy_mismatch(dev, ifsta)) {
827 printk(KERN_DEBUG "%s: mismatch in privacy configuration and "
828 "mixed-cell disabled - abort association\n", dev->name);
829 ifsta->state = IEEE80211_DISABLED;
830 return;
831 }
832
833 ieee80211_send_assoc(dev, ifsta);
834
835 mod_timer(&ifsta->timer, jiffies + IEEE80211_ASSOC_TIMEOUT);
836 }
837
838
839 static void ieee80211_associated(struct net_device *dev,
840 struct ieee80211_if_sta *ifsta)
841 {
842 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
843 struct sta_info *sta;
844 int disassoc;
845 DECLARE_MAC_BUF(mac);
846
847 /* TODO: start monitoring current AP signal quality and number of
848 * missed beacons. Scan other channels every now and then and search
849 * for better APs. */
850 /* TODO: remove expired BSSes */
851
852 ifsta->state = IEEE80211_ASSOCIATED;
853
854 sta = sta_info_get(local, ifsta->bssid);
855 if (!sta) {
856 printk(KERN_DEBUG "%s: No STA entry for own AP %s\n",
857 dev->name, print_mac(mac, ifsta->bssid));
858 disassoc = 1;
859 } else {
860 disassoc = 0;
861 if (time_after(jiffies,
862 sta->last_rx + IEEE80211_MONITORING_INTERVAL)) {
863 if (ifsta->flags & IEEE80211_STA_PROBEREQ_POLL) {
864 printk(KERN_DEBUG "%s: No ProbeResp from "
865 "current AP %s - assume out of "
866 "range\n",
867 dev->name, print_mac(mac, ifsta->bssid));
868 disassoc = 1;
869 sta_info_free(sta);
870 } else
871 ieee80211_send_probe_req(dev, ifsta->bssid,
872 local->scan_ssid,
873 local->scan_ssid_len);
874 ifsta->flags ^= IEEE80211_STA_PROBEREQ_POLL;
875 } else {
876 ifsta->flags &= ~IEEE80211_STA_PROBEREQ_POLL;
877 if (time_after(jiffies, ifsta->last_probe +
878 IEEE80211_PROBE_INTERVAL)) {
879 ifsta->last_probe = jiffies;
880 ieee80211_send_probe_req(dev, ifsta->bssid,
881 ifsta->ssid,
882 ifsta->ssid_len);
883 }
884 }
885 sta_info_put(sta);
886 }
887 if (disassoc) {
888 ifsta->state = IEEE80211_DISABLED;
889 ieee80211_set_associated(dev, ifsta, 0);
890 } else {
891 mod_timer(&ifsta->timer, jiffies +
892 IEEE80211_MONITORING_INTERVAL);
893 }
894 }
895
896
897 static void ieee80211_send_probe_req(struct net_device *dev, u8 *dst,
898 u8 *ssid, size_t ssid_len)
899 {
900 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
901 struct ieee80211_hw_mode *mode;
902 struct sk_buff *skb;
903 struct ieee80211_mgmt *mgmt;
904 u8 *pos, *supp_rates, *esupp_rates = NULL;
905 int i;
906
907 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 200);
908 if (!skb) {
909 printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
910 "request\n", dev->name);
911 return;
912 }
913 skb_reserve(skb, local->hw.extra_tx_headroom);
914
915 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
916 memset(mgmt, 0, 24);
917 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
918 IEEE80211_STYPE_PROBE_REQ);
919 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
920 if (dst) {
921 memcpy(mgmt->da, dst, ETH_ALEN);
922 memcpy(mgmt->bssid, dst, ETH_ALEN);
923 } else {
924 memset(mgmt->da, 0xff, ETH_ALEN);
925 memset(mgmt->bssid, 0xff, ETH_ALEN);
926 }
927 pos = skb_put(skb, 2 + ssid_len);
928 *pos++ = WLAN_EID_SSID;
929 *pos++ = ssid_len;
930 memcpy(pos, ssid, ssid_len);
931
932 supp_rates = skb_put(skb, 2);
933 supp_rates[0] = WLAN_EID_SUPP_RATES;
934 supp_rates[1] = 0;
935 mode = local->oper_hw_mode;
936 for (i = 0; i < mode->num_rates; i++) {
937 struct ieee80211_rate *rate = &mode->rates[i];
938 if (!(rate->flags & IEEE80211_RATE_SUPPORTED))
939 continue;
940 if (esupp_rates) {
941 pos = skb_put(skb, 1);
942 esupp_rates[1]++;
943 } else if (supp_rates[1] == 8) {
944 esupp_rates = skb_put(skb, 3);
945 esupp_rates[0] = WLAN_EID_EXT_SUPP_RATES;
946 esupp_rates[1] = 1;
947 pos = &esupp_rates[2];
948 } else {
949 pos = skb_put(skb, 1);
950 supp_rates[1]++;
951 }
952 *pos = rate->rate / 5;
953 }
954
955 ieee80211_sta_tx(dev, skb, 0);
956 }
957
958
959 static int ieee80211_sta_wep_configured(struct net_device *dev)
960 {
961 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
962 if (!sdata || !sdata->default_key ||
963 sdata->default_key->conf.alg != ALG_WEP)
964 return 0;
965 return 1;
966 }
967
968
969 static void ieee80211_auth_completed(struct net_device *dev,
970 struct ieee80211_if_sta *ifsta)
971 {
972 printk(KERN_DEBUG "%s: authenticated\n", dev->name);
973 ifsta->flags |= IEEE80211_STA_AUTHENTICATED;
974 ieee80211_associate(dev, ifsta);
975 }
976
977
978 static void ieee80211_auth_challenge(struct net_device *dev,
979 struct ieee80211_if_sta *ifsta,
980 struct ieee80211_mgmt *mgmt,
981 size_t len)
982 {
983 u8 *pos;
984 struct ieee802_11_elems elems;
985
986 printk(KERN_DEBUG "%s: replying to auth challenge\n", dev->name);
987 pos = mgmt->u.auth.variable;
988 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
989 if (!elems.challenge) {
990 printk(KERN_DEBUG "%s: no challenge IE in shared key auth "
991 "frame\n", dev->name);
992 return;
993 }
994 ieee80211_send_auth(dev, ifsta, 3, elems.challenge - 2,
995 elems.challenge_len + 2, 1);
996 }
997
998 static void ieee80211_send_addba_resp(struct net_device *dev, u8 *da, u16 tid,
999 u8 dialog_token, u16 status, u16 policy,
1000 u16 buf_size, u16 timeout)
1001 {
1002 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1003 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
1004 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1005 struct sk_buff *skb;
1006 struct ieee80211_mgmt *mgmt;
1007 u16 capab;
1008
1009 skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom + 1 +
1010 sizeof(mgmt->u.action.u.addba_resp));
1011 if (!skb) {
1012 printk(KERN_DEBUG "%s: failed to allocate buffer "
1013 "for addba resp frame\n", dev->name);
1014 return;
1015 }
1016
1017 skb_reserve(skb, local->hw.extra_tx_headroom);
1018 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
1019 memset(mgmt, 0, 24);
1020 memcpy(mgmt->da, da, ETH_ALEN);
1021 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
1022 if (sdata->vif.type == IEEE80211_IF_TYPE_AP)
1023 memcpy(mgmt->bssid, dev->dev_addr, ETH_ALEN);
1024 else
1025 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
1026 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
1027 IEEE80211_STYPE_ACTION);
1028
1029 skb_put(skb, 1 + sizeof(mgmt->u.action.u.addba_resp));
1030 mgmt->u.action.category = WLAN_CATEGORY_BACK;
1031 mgmt->u.action.u.addba_resp.action_code = WLAN_ACTION_ADDBA_RESP;
1032 mgmt->u.action.u.addba_resp.dialog_token = dialog_token;
1033
1034 capab = (u16)(policy << 1); /* bit 1 aggregation policy */
1035 capab |= (u16)(tid << 2); /* bit 5:2 TID number */
1036 capab |= (u16)(buf_size << 6); /* bit 15:6 max size of aggregation */
1037
1038 mgmt->u.action.u.addba_resp.capab = cpu_to_le16(capab);
1039 mgmt->u.action.u.addba_resp.timeout = cpu_to_le16(timeout);
1040 mgmt->u.action.u.addba_resp.status = cpu_to_le16(status);
1041
1042 ieee80211_sta_tx(dev, skb, 0);
1043
1044 return;
1045 }
1046
1047 static void ieee80211_sta_process_addba_request(struct net_device *dev,
1048 struct ieee80211_mgmt *mgmt,
1049 size_t len)
1050 {
1051 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1052 struct ieee80211_hw *hw = &local->hw;
1053 struct ieee80211_conf *conf = &hw->conf;
1054 struct sta_info *sta;
1055 struct tid_ampdu_rx *tid_agg_rx;
1056 u16 capab, tid, timeout, ba_policy, buf_size, start_seq_num, status;
1057 u8 dialog_token;
1058 int ret = -EOPNOTSUPP;
1059 DECLARE_MAC_BUF(mac);
1060
1061 sta = sta_info_get(local, mgmt->sa);
1062 if (!sta)
1063 return;
1064
1065 /* extract session parameters from addba request frame */
1066 dialog_token = mgmt->u.action.u.addba_req.dialog_token;
1067 timeout = le16_to_cpu(mgmt->u.action.u.addba_req.timeout);
1068 start_seq_num =
1069 le16_to_cpu(mgmt->u.action.u.addba_req.start_seq_num) >> 4;
1070
1071 capab = le16_to_cpu(mgmt->u.action.u.addba_req.capab);
1072 ba_policy = (capab & IEEE80211_ADDBA_PARAM_POLICY_MASK) >> 1;
1073 tid = (capab & IEEE80211_ADDBA_PARAM_TID_MASK) >> 2;
1074 buf_size = (capab & IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK) >> 6;
1075
1076 status = WLAN_STATUS_REQUEST_DECLINED;
1077
1078 /* sanity check for incoming parameters:
1079 * check if configuration can support the BA policy
1080 * and if buffer size does not exceeds max value */
1081 if (((ba_policy != 1)
1082 && (!(conf->ht_conf.cap & IEEE80211_HT_CAP_DELAY_BA)))
1083 || (buf_size > IEEE80211_MAX_AMPDU_BUF)) {
1084 status = WLAN_STATUS_INVALID_QOS_PARAM;
1085 #ifdef CONFIG_MAC80211_HT_DEBUG
1086 if (net_ratelimit())
1087 printk(KERN_DEBUG "Block Ack Req with bad params from "
1088 "%s on tid %u. policy %d, buffer size %d\n",
1089 print_mac(mac, mgmt->sa), tid, ba_policy,
1090 buf_size);
1091 #endif /* CONFIG_MAC80211_HT_DEBUG */
1092 goto end_no_lock;
1093 }
1094 /* determine default buffer size */
1095 if (buf_size == 0) {
1096 struct ieee80211_hw_mode *mode = conf->mode;
1097 buf_size = IEEE80211_MIN_AMPDU_BUF;
1098 buf_size = buf_size << mode->ht_info.ampdu_factor;
1099 }
1100
1101 tid_agg_rx = &sta->ampdu_mlme.tid_rx[tid];
1102
1103 /* examine state machine */
1104 spin_lock_bh(&sta->ampdu_mlme.ampdu_rx);
1105
1106 if (tid_agg_rx->state != HT_AGG_STATE_IDLE) {
1107 #ifdef CONFIG_MAC80211_HT_DEBUG
1108 if (net_ratelimit())
1109 printk(KERN_DEBUG "unexpected Block Ack Req from "
1110 "%s on tid %u\n",
1111 print_mac(mac, mgmt->sa), tid);
1112 #endif /* CONFIG_MAC80211_HT_DEBUG */
1113 goto end;
1114 }
1115
1116 /* prepare reordering buffer */
1117 tid_agg_rx->reorder_buf =
1118 kmalloc(buf_size * sizeof(struct sk_buf *), GFP_ATOMIC);
1119 <<<<<<< HEAD:net/mac80211/ieee80211_sta.c
1120 if ((!tid_agg_rx->reorder_buf) && net_ratelimit()) {
1121 printk(KERN_ERR "can not allocate reordering buffer "
1122 "to tid %d\n", tid);
1123 =======
1124 if (!tid_agg_rx->reorder_buf) {
1125 if (net_ratelimit())
1126 printk(KERN_ERR "can not allocate reordering buffer "
1127 "to tid %d\n", tid);
1128 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:net/mac80211/ieee80211_sta.c
1129 goto end;
1130 }
1131 memset(tid_agg_rx->reorder_buf, 0,
1132 buf_size * sizeof(struct sk_buf *));
1133
1134 if (local->ops->ampdu_action)
1135 ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_RX_START,
1136 sta->addr, tid, start_seq_num);
1137 #ifdef CONFIG_MAC80211_HT_DEBUG
1138 printk(KERN_DEBUG "Rx A-MPDU on tid %d result %d", tid, ret);
1139 #endif /* CONFIG_MAC80211_HT_DEBUG */
1140
1141 if (ret) {
1142 kfree(tid_agg_rx->reorder_buf);
1143 goto end;
1144 }
1145
1146 /* change state and send addba resp */
1147 tid_agg_rx->state = HT_AGG_STATE_OPERATIONAL;
1148 tid_agg_rx->dialog_token = dialog_token;
1149 tid_agg_rx->ssn = start_seq_num;
1150 tid_agg_rx->head_seq_num = start_seq_num;
1151 tid_agg_rx->buf_size = buf_size;
1152 tid_agg_rx->timeout = timeout;
1153 tid_agg_rx->stored_mpdu_num = 0;
1154 status = WLAN_STATUS_SUCCESS;
1155 end:
1156 spin_unlock_bh(&sta->ampdu_mlme.ampdu_rx);
1157
1158 end_no_lock:
1159 ieee80211_send_addba_resp(sta->dev, sta->addr, tid, dialog_token,
1160 status, 1, buf_size, timeout);
1161 sta_info_put(sta);
1162 }
1163
1164 static void ieee80211_send_delba(struct net_device *dev, const u8 *da, u16 tid,
1165 u16 initiator, u16 reason_code)
1166 {
1167 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1168 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1169 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
1170 struct sk_buff *skb;
1171 struct ieee80211_mgmt *mgmt;
1172 u16 params;
1173
1174 skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom + 1 +
1175 sizeof(mgmt->u.action.u.delba));
1176
1177 if (!skb) {
1178 printk(KERN_ERR "%s: failed to allocate buffer "
1179 "for delba frame\n", dev->name);
1180 return;
1181 }
1182
1183 skb_reserve(skb, local->hw.extra_tx_headroom);
1184 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
1185 memset(mgmt, 0, 24);
1186 memcpy(mgmt->da, da, ETH_ALEN);
1187 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
1188 if (sdata->vif.type == IEEE80211_IF_TYPE_AP)
1189 memcpy(mgmt->bssid, dev->dev_addr, ETH_ALEN);
1190 else
1191 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
1192 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
1193 IEEE80211_STYPE_ACTION);
1194
1195 skb_put(skb, 1 + sizeof(mgmt->u.action.u.delba));
1196
1197 mgmt->u.action.category = WLAN_CATEGORY_BACK;
1198 mgmt->u.action.u.delba.action_code = WLAN_ACTION_DELBA;
1199 params = (u16)(initiator << 11); /* bit 11 initiator */
1200 params |= (u16)(tid << 12); /* bit 15:12 TID number */
1201
1202 mgmt->u.action.u.delba.params = cpu_to_le16(params);
1203 mgmt->u.action.u.delba.reason_code = cpu_to_le16(reason_code);
1204
1205 ieee80211_sta_tx(dev, skb, 0);
1206 }
1207
1208 void ieee80211_sta_stop_rx_ba_session(struct net_device *dev, u8 *ra, u16 tid,
1209 u16 initiator, u16 reason)
1210 {
1211 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1212 struct ieee80211_hw *hw = &local->hw;
1213 struct sta_info *sta;
1214 int ret, i;
1215
1216 sta = sta_info_get(local, ra);
1217 if (!sta)
1218 return;
1219
1220 /* check if TID is in operational state */
1221 spin_lock_bh(&sta->ampdu_mlme.ampdu_rx);
1222 if (sta->ampdu_mlme.tid_rx[tid].state
1223 != HT_AGG_STATE_OPERATIONAL) {
1224 spin_unlock_bh(&sta->ampdu_mlme.ampdu_rx);
1225 sta_info_put(sta);
1226 return;
1227 }
1228 sta->ampdu_mlme.tid_rx[tid].state =
1229 HT_AGG_STATE_REQ_STOP_BA_MSK |
1230 (initiator << HT_AGG_STATE_INITIATOR_SHIFT);
1231 spin_unlock_bh(&sta->ampdu_mlme.ampdu_rx);
1232
1233 /* stop HW Rx aggregation. ampdu_action existence
1234 * already verified in session init so we add the BUG_ON */
1235 BUG_ON(!local->ops->ampdu_action);
1236
1237 ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_RX_STOP,
1238 ra, tid, EINVAL);
1239 if (ret)
1240 printk(KERN_DEBUG "HW problem - can not stop rx "
1241 "aggergation for tid %d\n", tid);
1242
1243 /* shutdown timer has not expired */
1244 if (initiator != WLAN_BACK_TIMER)
1245 del_timer_sync(&sta->ampdu_mlme.tid_rx[tid].
1246 session_timer);
1247
1248 /* check if this is a self generated aggregation halt */
1249 if (initiator == WLAN_BACK_RECIPIENT || initiator == WLAN_BACK_TIMER)
1250 ieee80211_send_delba(dev, ra, tid, 0, reason);
1251
1252 /* free the reordering buffer */
1253 for (i = 0; i < sta->ampdu_mlme.tid_rx[tid].buf_size; i++) {
1254 if (sta->ampdu_mlme.tid_rx[tid].reorder_buf[i]) {
1255 /* release the reordered frames */
1256 dev_kfree_skb(sta->ampdu_mlme.tid_rx[tid].reorder_buf[i]);
1257 sta->ampdu_mlme.tid_rx[tid].stored_mpdu_num--;
1258 sta->ampdu_mlme.tid_rx[tid].reorder_buf[i] = NULL;
1259 }
1260 }
1261 kfree(sta->ampdu_mlme.tid_rx[tid].reorder_buf);
1262
1263 sta->ampdu_mlme.tid_rx[tid].state = HT_AGG_STATE_IDLE;
1264 sta_info_put(sta);
1265 }
1266
1267 static void ieee80211_sta_process_delba(struct net_device *dev,
1268 struct ieee80211_mgmt *mgmt, size_t len)
1269 {
1270 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1271 struct sta_info *sta;
1272 u16 tid, params;
1273 u16 initiator;
1274 DECLARE_MAC_BUF(mac);
1275
1276 sta = sta_info_get(local, mgmt->sa);
1277 if (!sta)
1278 return;
1279
1280 params = le16_to_cpu(mgmt->u.action.u.delba.params);
1281 tid = (params & IEEE80211_DELBA_PARAM_TID_MASK) >> 12;
1282 initiator = (params & IEEE80211_DELBA_PARAM_INITIATOR_MASK) >> 11;
1283
1284 #ifdef CONFIG_MAC80211_HT_DEBUG
1285 if (net_ratelimit())
1286 printk(KERN_DEBUG "delba from %s on tid %d reason code %d\n",
1287 print_mac(mac, mgmt->sa), tid,
1288 mgmt->u.action.u.delba.reason_code);
1289 #endif /* CONFIG_MAC80211_HT_DEBUG */
1290
1291 if (initiator == WLAN_BACK_INITIATOR)
1292 ieee80211_sta_stop_rx_ba_session(dev, sta->addr, tid,
1293 WLAN_BACK_INITIATOR, 0);
1294 sta_info_put(sta);
1295 }
1296
1297 /*
1298 * After receiving Block Ack Request (BAR) we activated a
1299 * timer after each frame arrives from the originator.
1300 * if this timer expires ieee80211_sta_stop_rx_ba_session will be executed.
1301 */
1302 void sta_rx_agg_session_timer_expired(unsigned long data)
1303 {
1304 /* not an elegant detour, but there is no choice as the timer passes
1305 * only one argument, and verious sta_info are needed here, so init
1306 * flow in sta_info_add gives the TID as data, while the timer_to_id
1307 * array gives the sta through container_of */
1308 u8 *ptid = (u8 *)data;
1309 u8 *timer_to_id = ptid - *ptid;
1310 struct sta_info *sta = container_of(timer_to_id, struct sta_info,
1311 timer_to_tid[0]);
1312
1313 printk(KERN_DEBUG "rx session timer expired on tid %d\n", (u16)*ptid);
1314 ieee80211_sta_stop_rx_ba_session(sta->dev, sta->addr, (u16)*ptid,
1315 WLAN_BACK_TIMER,
1316 WLAN_REASON_QSTA_TIMEOUT);
1317 }
1318
1319
1320 static void ieee80211_rx_mgmt_auth(struct net_device *dev,
1321 struct ieee80211_if_sta *ifsta,
1322 struct ieee80211_mgmt *mgmt,
1323 size_t len)
1324 {
1325 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1326 u16 auth_alg, auth_transaction, status_code;
1327 DECLARE_MAC_BUF(mac);
1328
1329 if (ifsta->state != IEEE80211_AUTHENTICATE &&
1330 sdata->vif.type != IEEE80211_IF_TYPE_IBSS) {
1331 printk(KERN_DEBUG "%s: authentication frame received from "
1332 "%s, but not in authenticate state - ignored\n",
1333 dev->name, print_mac(mac, mgmt->sa));
1334 return;
1335 }
1336
1337 if (len < 24 + 6) {
1338 printk(KERN_DEBUG "%s: too short (%zd) authentication frame "
1339 "received from %s - ignored\n",
1340 dev->name, len, print_mac(mac, mgmt->sa));
1341 return;
1342 }
1343
1344 if (sdata->vif.type != IEEE80211_IF_TYPE_IBSS &&
1345 memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN) != 0) {
1346 printk(KERN_DEBUG "%s: authentication frame received from "
1347 "unknown AP (SA=%s BSSID=%s) - "
1348 "ignored\n", dev->name, print_mac(mac, mgmt->sa),
1349 print_mac(mac, mgmt->bssid));
1350 return;
1351 }
1352
1353 if (sdata->vif.type != IEEE80211_IF_TYPE_IBSS &&
1354 memcmp(ifsta->bssid, mgmt->bssid, ETH_ALEN) != 0) {
1355 printk(KERN_DEBUG "%s: authentication frame received from "
1356 "unknown BSSID (SA=%s BSSID=%s) - "
1357 "ignored\n", dev->name, print_mac(mac, mgmt->sa),
1358 print_mac(mac, mgmt->bssid));
1359 return;
1360 }
1361
1362 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
1363 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
1364 status_code = le16_to_cpu(mgmt->u.auth.status_code);
1365
1366 printk(KERN_DEBUG "%s: RX authentication from %s (alg=%d "
1367 "transaction=%d status=%d)\n",
1368 dev->name, print_mac(mac, mgmt->sa), auth_alg,
1369 auth_transaction, status_code);
1370
1371 if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
1372 /* IEEE 802.11 standard does not require authentication in IBSS
1373 * networks and most implementations do not seem to use it.
1374 * However, try to reply to authentication attempts if someone
1375 * has actually implemented this.
1376 * TODO: Could implement shared key authentication. */
1377 if (auth_alg != WLAN_AUTH_OPEN || auth_transaction != 1) {
1378 printk(KERN_DEBUG "%s: unexpected IBSS authentication "
1379 "frame (alg=%d transaction=%d)\n",
1380 dev->name, auth_alg, auth_transaction);
1381 return;
1382 }
1383 ieee80211_send_auth(dev, ifsta, 2, NULL, 0, 0);
1384 }
1385
1386 if (auth_alg != ifsta->auth_alg ||
1387 auth_transaction != ifsta->auth_transaction) {
1388 printk(KERN_DEBUG "%s: unexpected authentication frame "
1389 "(alg=%d transaction=%d)\n",
1390 dev->name, auth_alg, auth_transaction);
1391 return;
1392 }
1393
1394 if (status_code != WLAN_STATUS_SUCCESS) {
1395 printk(KERN_DEBUG "%s: AP denied authentication (auth_alg=%d "
1396 "code=%d)\n", dev->name, ifsta->auth_alg, status_code);
1397 if (status_code == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG) {
1398 u8 algs[3];
1399 const int num_algs = ARRAY_SIZE(algs);
1400 int i, pos;
1401 algs[0] = algs[1] = algs[2] = 0xff;
1402 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_OPEN)
1403 algs[0] = WLAN_AUTH_OPEN;
1404 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY)
1405 algs[1] = WLAN_AUTH_SHARED_KEY;
1406 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_LEAP)
1407 algs[2] = WLAN_AUTH_LEAP;
1408 if (ifsta->auth_alg == WLAN_AUTH_OPEN)
1409 pos = 0;
1410 else if (ifsta->auth_alg == WLAN_AUTH_SHARED_KEY)
1411 pos = 1;
1412 else
1413 pos = 2;
1414 for (i = 0; i < num_algs; i++) {
1415 pos++;
1416 if (pos >= num_algs)
1417 pos = 0;
1418 if (algs[pos] == ifsta->auth_alg ||
1419 algs[pos] == 0xff)
1420 continue;
1421 if (algs[pos] == WLAN_AUTH_SHARED_KEY &&
1422 !ieee80211_sta_wep_configured(dev))
1423 continue;
1424 ifsta->auth_alg = algs[pos];
1425 printk(KERN_DEBUG "%s: set auth_alg=%d for "
1426 "next try\n",
1427 dev->name, ifsta->auth_alg);
1428 break;
1429 }
1430 }
1431 return;
1432 }
1433
1434 switch (ifsta->auth_alg) {
1435 case WLAN_AUTH_OPEN:
1436 case WLAN_AUTH_LEAP:
1437 ieee80211_auth_completed(dev, ifsta);
1438 break;
1439 case WLAN_AUTH_SHARED_KEY:
1440 if (ifsta->auth_transaction == 4)
1441 ieee80211_auth_completed(dev, ifsta);
1442 else
1443 ieee80211_auth_challenge(dev, ifsta, mgmt, len);
1444 break;
1445 }
1446 }
1447
1448
1449 static void ieee80211_rx_mgmt_deauth(struct net_device *dev,
1450 struct ieee80211_if_sta *ifsta,
1451 struct ieee80211_mgmt *mgmt,
1452 size_t len)
1453 {
1454 u16 reason_code;
1455 DECLARE_MAC_BUF(mac);
1456
1457 if (len < 24 + 2) {
1458 printk(KERN_DEBUG "%s: too short (%zd) deauthentication frame "
1459 "received from %s - ignored\n",
1460 dev->name, len, print_mac(mac, mgmt->sa));
1461 return;
1462 }
1463
1464 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN) != 0) {
1465 printk(KERN_DEBUG "%s: deauthentication frame received from "
1466 "unknown AP (SA=%s BSSID=%s) - "
1467 "ignored\n", dev->name, print_mac(mac, mgmt->sa),
1468 print_mac(mac, mgmt->bssid));
1469 return;
1470 }
1471
1472 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
1473
1474 printk(KERN_DEBUG "%s: RX deauthentication from %s"
1475 " (reason=%d)\n",
1476 dev->name, print_mac(mac, mgmt->sa), reason_code);
1477
1478 if (ifsta->flags & IEEE80211_STA_AUTHENTICATED) {
1479 printk(KERN_DEBUG "%s: deauthenticated\n", dev->name);
1480 }
1481
1482 if (ifsta->state == IEEE80211_AUTHENTICATE ||
1483 ifsta->state == IEEE80211_ASSOCIATE ||
1484 ifsta->state == IEEE80211_ASSOCIATED) {
1485 ifsta->state = IEEE80211_AUTHENTICATE;
1486 mod_timer(&ifsta->timer, jiffies +
1487 IEEE80211_RETRY_AUTH_INTERVAL);
1488 }
1489
1490 ieee80211_set_disassoc(dev, ifsta, 1);
1491 ifsta->flags &= ~IEEE80211_STA_AUTHENTICATED;
1492 }
1493
1494
1495 static void ieee80211_rx_mgmt_disassoc(struct net_device *dev,
1496 struct ieee80211_if_sta *ifsta,
1497 struct ieee80211_mgmt *mgmt,
1498 size_t len)
1499 {
1500 u16 reason_code;
1501 DECLARE_MAC_BUF(mac);
1502
1503 if (len < 24 + 2) {
1504 printk(KERN_DEBUG "%s: too short (%zd) disassociation frame "
1505 "received from %s - ignored\n",
1506 dev->name, len, print_mac(mac, mgmt->sa));
1507 return;
1508 }
1509
1510 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN) != 0) {
1511 printk(KERN_DEBUG "%s: disassociation frame received from "
1512 "unknown AP (SA=%s BSSID=%s) - "
1513 "ignored\n", dev->name, print_mac(mac, mgmt->sa),
1514 print_mac(mac, mgmt->bssid));
1515 return;
1516 }
1517
1518 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
1519
1520 printk(KERN_DEBUG "%s: RX disassociation from %s"
1521 " (reason=%d)\n",
1522 dev->name, print_mac(mac, mgmt->sa), reason_code);
1523
1524 if (ifsta->flags & IEEE80211_STA_ASSOCIATED)
1525 printk(KERN_DEBUG "%s: disassociated\n", dev->name);
1526
1527 if (ifsta->state == IEEE80211_ASSOCIATED) {
1528 ifsta->state = IEEE80211_ASSOCIATE;
1529 mod_timer(&ifsta->timer, jiffies +
1530 IEEE80211_RETRY_AUTH_INTERVAL);
1531 }
1532
1533 ieee80211_set_disassoc(dev, ifsta, 0);
1534 }
1535
1536
1537 static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1538 struct ieee80211_if_sta *ifsta,
1539 struct ieee80211_mgmt *mgmt,
1540 size_t len,
1541 int reassoc)
1542 {
1543 struct ieee80211_local *local = sdata->local;
1544 struct net_device *dev = sdata->dev;
1545 struct ieee80211_hw_mode *mode;
1546 struct sta_info *sta;
1547 u32 rates;
1548 u16 capab_info, status_code, aid;
1549 struct ieee802_11_elems elems;
1550 struct ieee80211_bss_conf *bss_conf = &sdata->bss_conf;
1551 u8 *pos;
1552 int i, j;
1553 DECLARE_MAC_BUF(mac);
1554
1555 /* AssocResp and ReassocResp have identical structure, so process both
1556 * of them in this function. */
1557
1558 if (ifsta->state != IEEE80211_ASSOCIATE) {
1559 printk(KERN_DEBUG "%s: association frame received from "
1560 "%s, but not in associate state - ignored\n",
1561 dev->name, print_mac(mac, mgmt->sa));
1562 return;
1563 }
1564
1565 if (len < 24 + 6) {
1566 printk(KERN_DEBUG "%s: too short (%zd) association frame "
1567 "received from %s - ignored\n",
1568 dev->name, len, print_mac(mac, mgmt->sa));
1569 return;
1570 }
1571
1572 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN) != 0) {
1573 printk(KERN_DEBUG "%s: association frame received from "
1574 "unknown AP (SA=%s BSSID=%s) - "
1575 "ignored\n", dev->name, print_mac(mac, mgmt->sa),
1576 print_mac(mac, mgmt->bssid));
1577 return;
1578 }
1579
1580 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
1581 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
1582 aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
1583
1584 printk(KERN_DEBUG "%s: RX %sssocResp from %s (capab=0x%x "
1585 "status=%d aid=%d)\n",
1586 dev->name, reassoc ? "Rea" : "A", print_mac(mac, mgmt->sa),
1587 capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
1588
1589 if (status_code != WLAN_STATUS_SUCCESS) {
1590 printk(KERN_DEBUG "%s: AP denied association (code=%d)\n",
1591 dev->name, status_code);
1592 /* if this was a reassociation, ensure we try a "full"
1593 * association next time. This works around some broken APs
1594 * which do not correctly reject reassociation requests. */
1595 ifsta->flags &= ~IEEE80211_STA_PREV_BSSID_SET;
1596 return;
1597 }
1598
1599 if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
1600 printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not "
1601 "set\n", dev->name, aid);
1602 aid &= ~(BIT(15) | BIT(14));
1603
1604 pos = mgmt->u.assoc_resp.variable;
1605 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
1606
1607 if (!elems.supp_rates) {
1608 printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",
1609 dev->name);
1610 return;
1611 }
1612
1613 printk(KERN_DEBUG "%s: associated\n", dev->name);
1614 ifsta->aid = aid;
1615 ifsta->ap_capab = capab_info;
1616
1617 kfree(ifsta->assocresp_ies);
1618 ifsta->assocresp_ies_len = len - (pos - (u8 *) mgmt);
1619 ifsta->assocresp_ies = kmalloc(ifsta->assocresp_ies_len, GFP_KERNEL);
1620 if (ifsta->assocresp_ies)
1621 memcpy(ifsta->assocresp_ies, pos, ifsta->assocresp_ies_len);
1622
1623 /* set AID, ieee80211_set_associated() will tell the driver */
1624 bss_conf->aid = aid;
1625 ieee80211_set_associated(dev, ifsta, 1);
1626
1627 /* Add STA entry for the AP */
1628 sta = sta_info_get(local, ifsta->bssid);
1629 if (!sta) {
1630 struct ieee80211_sta_bss *bss;
1631 sta = sta_info_add(local, dev, ifsta->bssid, GFP_KERNEL);
1632 if (!sta) {
1633 printk(KERN_DEBUG "%s: failed to add STA entry for the"
1634 " AP\n", dev->name);
1635 return;
1636 }
1637 bss = ieee80211_rx_bss_get(dev, ifsta->bssid,
1638 local->hw.conf.channel,
1639 ifsta->ssid, ifsta->ssid_len);
1640 if (bss) {
1641 sta->last_rssi = bss->rssi;
1642 sta->last_signal = bss->signal;
1643 sta->last_noise = bss->noise;
1644 ieee80211_rx_bss_put(dev, bss);
1645 }
1646 }
1647
1648 sta->dev = dev;
1649 sta->flags |= WLAN_STA_AUTH | WLAN_STA_ASSOC | WLAN_STA_ASSOC_AP;
1650
1651 rates = 0;
1652 mode = local->oper_hw_mode;
1653 for (i = 0; i < elems.supp_rates_len; i++) {
1654 int rate = (elems.supp_rates[i] & 0x7f) * 5;
1655 for (j = 0; j < mode->num_rates; j++)
1656 if (mode->rates[j].rate == rate)
1657 rates |= BIT(j);
1658 }
1659 for (i = 0; i < elems.ext_supp_rates_len; i++) {
1660 int rate = (elems.ext_supp_rates[i] & 0x7f) * 5;
1661 for (j = 0; j < mode->num_rates; j++)
1662 if (mode->rates[j].rate == rate)
1663 rates |= BIT(j);
1664 }
1665 sta->supp_rates = rates;
1666
1667 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&
1668 local->ops->conf_ht) {
1669 struct ieee80211_ht_bss_info bss_info;
1670
1671 ieee80211_ht_cap_ie_to_ht_info(
1672 (struct ieee80211_ht_cap *)
1673 elems.ht_cap_elem, &sta->ht_info);
1674 ieee80211_ht_addt_info_ie_to_ht_bss_info(
1675 (struct ieee80211_ht_addt_info *)
1676 elems.ht_info_elem, &bss_info);
1677 ieee80211_hw_config_ht(local, 1, &sta->ht_info, &bss_info);
1678 }
1679
1680 rate_control_rate_init(sta, local);
1681
1682 if (elems.wmm_param && (ifsta->flags & IEEE80211_STA_WMM_ENABLED)) {
1683 sta->flags |= WLAN_STA_WME;
1684 ieee80211_sta_wmm_params(dev, ifsta, elems.wmm_param,
1685 elems.wmm_param_len);
1686 }
1687
1688
1689 sta_info_put(sta);
1690
1691 ieee80211_associated(dev, ifsta);
1692 }
1693
1694
1695 /* Caller must hold local->sta_bss_lock */
1696 static void __ieee80211_rx_bss_hash_add(struct net_device *dev,
1697 struct ieee80211_sta_bss *bss)
1698 {
1699 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1700 bss->hnext = local->sta_bss_hash[STA_HASH(bss->bssid)];
1701 local->sta_bss_hash[STA_HASH(bss->bssid)] = bss;
1702 }
1703
1704
1705 /* Caller must hold local->sta_bss_lock */
1706 static void __ieee80211_rx_bss_hash_del(struct net_device *dev,
1707 struct ieee80211_sta_bss *bss)
1708 {
1709 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1710 struct ieee80211_sta_bss *b, *prev = NULL;
1711 b = local->sta_bss_hash[STA_HASH(bss->bssid)];
1712 while (b) {
1713 if (b == bss) {
1714 if (!prev)
1715 local->sta_bss_hash[STA_HASH(bss->bssid)] =
1716 bss->hnext;
1717 else
1718 prev->hnext = bss->hnext;
1719 break;
1720 }
1721 prev = b;
1722 b = b->hnext;
1723 }
1724 }
1725
1726
1727 static struct ieee80211_sta_bss *
1728 ieee80211_rx_bss_add(struct net_device *dev, u8 *bssid, int channel,
1729 u8 *ssid, u8 ssid_len)
1730 {
1731 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1732 struct ieee80211_sta_bss *bss;
1733
1734 bss = kzalloc(sizeof(*bss), GFP_ATOMIC);
1735 if (!bss)
1736 return NULL;
1737 atomic_inc(&bss->users);
1738 atomic_inc(&bss->users);
1739 memcpy(bss->bssid, bssid, ETH_ALEN);
1740 bss->channel = channel;
1741 if (ssid && ssid_len <= IEEE80211_MAX_SSID_LEN) {
1742 memcpy(bss->ssid, ssid, ssid_len);
1743 bss->ssid_len = ssid_len;
1744 }
1745
1746 spin_lock_bh(&local->sta_bss_lock);
1747 /* TODO: order by RSSI? */
1748 list_add_tail(&bss->list, &local->sta_bss_list);
1749 __ieee80211_rx_bss_hash_add(dev, bss);
1750 spin_unlock_bh(&local->sta_bss_lock);
1751 return bss;
1752 }
1753
1754
1755 static struct ieee80211_sta_bss *
1756 ieee80211_rx_bss_get(struct net_device *dev, u8 *bssid, int channel,
1757 u8 *ssid, u8 ssid_len)
1758 {
1759 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1760 struct ieee80211_sta_bss *bss;
1761
1762 spin_lock_bh(&local->sta_bss_lock);
1763 bss = local->sta_bss_hash[STA_HASH(bssid)];
1764 while (bss) {
1765 if (!memcmp(bss->bssid, bssid, ETH_ALEN) &&
1766 bss->channel == channel &&
1767 bss->ssid_len == ssid_len &&
1768 (ssid_len == 0 || !memcmp(bss->ssid, ssid, ssid_len))) {
1769 atomic_inc(&bss->users);
1770 break;
1771 }
1772 bss = bss->hnext;
1773 }
1774 spin_unlock_bh(&local->sta_bss_lock);
1775 return bss;
1776 }
1777
1778
1779 static void ieee80211_rx_bss_free(struct ieee80211_sta_bss *bss)
1780 {
1781 kfree(bss->wpa_ie);
1782 kfree(bss->rsn_ie);
1783 kfree(bss->wmm_ie);
1784 kfree(bss->ht_ie);
1785 kfree(bss);
1786 }
1787
1788
1789 static void ieee80211_rx_bss_put(struct net_device *dev,
1790 struct ieee80211_sta_bss *bss)
1791 {
1792 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1793 if (!atomic_dec_and_test(&bss->users))
1794 return;
1795
1796 spin_lock_bh(&local->sta_bss_lock);
1797 __ieee80211_rx_bss_hash_del(dev, bss);
1798 list_del(&bss->list);
1799 spin_unlock_bh(&local->sta_bss_lock);
1800 ieee80211_rx_bss_free(bss);
1801 }
1802
1803
1804 void ieee80211_rx_bss_list_init(struct net_device *dev)
1805 {
1806 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1807 spin_lock_init(&local->sta_bss_lock);
1808 INIT_LIST_HEAD(&local->sta_bss_list);
1809 }
1810
1811
1812 void ieee80211_rx_bss_list_deinit(struct net_device *dev)
1813 {
1814 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1815 struct ieee80211_sta_bss *bss, *tmp;
1816
1817 list_for_each_entry_safe(bss, tmp, &local->sta_bss_list, list)
1818 ieee80211_rx_bss_put(dev, bss);
1819 }
1820
1821
1822 static void ieee80211_rx_bss_info(struct net_device *dev,
1823 struct ieee80211_mgmt *mgmt,
1824 size_t len,
1825 struct ieee80211_rx_status *rx_status,
1826 int beacon)
1827 {
1828 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1829 struct ieee802_11_elems elems;
1830 size_t baselen;
1831 int channel, clen;
1832 struct ieee80211_sta_bss *bss;
1833 struct sta_info *sta;
1834 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1835 u64 timestamp;
1836 DECLARE_MAC_BUF(mac);
1837 DECLARE_MAC_BUF(mac2);
1838
1839 if (!beacon && memcmp(mgmt->da, dev->dev_addr, ETH_ALEN))
1840 return; /* ignore ProbeResp to foreign address */
1841
1842 #if 0
1843 printk(KERN_DEBUG "%s: RX %s from %s to %s\n",
1844 dev->name, beacon ? "Beacon" : "Probe Response",
1845 print_mac(mac, mgmt->sa), print_mac(mac2, mgmt->da));
1846 #endif
1847
1848 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
1849 if (baselen > len)
1850 return;
1851
1852 timestamp = le64_to_cpu(mgmt->u.beacon.timestamp);
1853
1854 if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS && beacon &&
1855 memcmp(mgmt->bssid, sdata->u.sta.bssid, ETH_ALEN) == 0) {
1856 #ifdef CONFIG_MAC80211_IBSS_DEBUG
1857 static unsigned long last_tsf_debug = 0;
1858 u64 tsf;
1859 if (local->ops->get_tsf)
1860 tsf = local->ops->get_tsf(local_to_hw(local));
1861 else
1862 tsf = -1LLU;
1863 if (time_after(jiffies, last_tsf_debug + 5 * HZ)) {
1864 printk(KERN_DEBUG "RX beacon SA=%s BSSID="
1865 "%s TSF=0x%llx BCN=0x%llx diff=%lld "
1866 "@%lu\n",
1867 print_mac(mac, mgmt->sa), print_mac(mac2, mgmt->bssid),
1868 (unsigned long long)tsf,
1869 (unsigned long long)timestamp,
1870 (unsigned long long)(tsf - timestamp),
1871 jiffies);
1872 last_tsf_debug = jiffies;
1873 }
1874 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
1875 }
1876
1877 ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen, &elems);
1878
1879 if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS && elems.supp_rates &&
1880 memcmp(mgmt->bssid, sdata->u.sta.bssid, ETH_ALEN) == 0 &&
1881 (sta = sta_info_get(local, mgmt->sa))) {
1882 struct ieee80211_hw_mode *mode;
1883 struct ieee80211_rate *rates;
1884 size_t num_rates;
1885 u32 supp_rates, prev_rates;
1886 int i, j;
1887
1888 mode = local->sta_sw_scanning ?
1889 local->scan_hw_mode : local->oper_hw_mode;
1890
1891 if (local->sta_hw_scanning) {
1892 /* search for the correct mode matches the beacon */
1893 list_for_each_entry(mode, &local->modes_list, list)
1894 if (mode->mode == rx_status->phymode)
1895 break;
1896
1897 if (mode == NULL)
1898 mode = local->oper_hw_mode;
1899 }
1900 rates = mode->rates;
1901 num_rates = mode->num_rates;
1902
1903 supp_rates = 0;
1904 for (i = 0; i < elems.supp_rates_len +
1905 elems.ext_supp_rates_len; i++) {
1906 u8 rate = 0;
1907 int own_rate;
1908 if (i < elems.supp_rates_len)
1909 rate = elems.supp_rates[i];
1910 else if (elems.ext_supp_rates)
1911 rate = elems.ext_supp_rates
1912 [i - elems.supp_rates_len];
1913 own_rate = 5 * (rate & 0x7f);
1914 for (j = 0; j < num_rates; j++)
1915 if (rates[j].rate == own_rate)
1916 supp_rates |= BIT(j);
1917 }
1918
1919 prev_rates = sta->supp_rates;
1920 sta->supp_rates &= supp_rates;
1921 if (sta->supp_rates == 0) {
1922 /* No matching rates - this should not really happen.
1923 * Make sure that at least one rate is marked
1924 * supported to avoid issues with TX rate ctrl. */
1925 sta->supp_rates = sdata->u.sta.supp_rates_bits;
1926 }
1927 if (sta->supp_rates != prev_rates) {
1928 printk(KERN_DEBUG "%s: updated supp_rates set for "
1929 "%s based on beacon info (0x%x & 0x%x -> "
1930 "0x%x)\n",
1931 dev->name, print_mac(mac, sta->addr), prev_rates,
1932 supp_rates, sta->supp_rates);
1933 }
1934 sta_info_put(sta);
1935 }
1936
1937 if (!elems.ssid)
1938 return;
1939
1940 if (elems.ds_params && elems.ds_params_len == 1)
1941 channel = elems.ds_params[0];
1942 else
1943 channel = rx_status->channel;
1944
1945 bss = ieee80211_rx_bss_get(dev, mgmt->bssid, channel,
1946 elems.ssid, elems.ssid_len);
1947 if (!bss) {
1948 bss = ieee80211_rx_bss_add(dev, mgmt->bssid, channel,
1949 elems.ssid, elems.ssid_len);
1950 if (!bss)
1951 return;
1952 } else {
1953 #if 0
1954 /* TODO: order by RSSI? */
1955 spin_lock_bh(&local->sta_bss_lock);
1956 list_move_tail(&bss->list, &local->sta_bss_list);
1957 spin_unlock_bh(&local->sta_bss_lock);
1958 #endif
1959 }
1960
1961 if (bss->probe_resp && beacon) {
1962 /* Do not allow beacon to override data from Probe Response. */
1963 ieee80211_rx_bss_put(dev, bss);
1964 return;
1965 }
1966
1967 /* save the ERP value so that it is available at association time */
1968 if (elems.erp_info && elems.erp_info_len >= 1) {
1969 bss->erp_value = elems.erp_info[0];
1970 bss->has_erp_value = 1;
1971 }
1972
1973 bss->beacon_int = le16_to_cpu(mgmt->u.beacon.beacon_int);
1974 bss->capability = le16_to_cpu(mgmt->u.beacon.capab_info);
1975
1976 bss->supp_rates_len = 0;
1977 if (elems.supp_rates) {
1978 clen = IEEE80211_MAX_SUPP_RATES - bss->supp_rates_len;
1979 if (clen > elems.supp_rates_len)
1980 clen = elems.supp_rates_len;
1981 memcpy(&bss->supp_rates[bss->supp_rates_len], elems.supp_rates,
1982 clen);
1983 bss->supp_rates_len += clen;
1984 }
1985 if (elems.ext_supp_rates) {
1986 clen = IEEE80211_MAX_SUPP_RATES - bss->supp_rates_len;
1987 if (clen > elems.ext_supp_rates_len)
1988 clen = elems.ext_supp_rates_len;
1989 memcpy(&bss->supp_rates[bss->supp_rates_len],
1990 elems.ext_supp_rates, clen);
1991 bss->supp_rates_len += clen;
1992 }
1993
1994 if (elems.wpa &&
1995 (!bss->wpa_ie || bss->wpa_ie_len != elems.wpa_len ||
1996 memcmp(bss->wpa_ie, elems.wpa, elems.wpa_len))) {
1997 kfree(bss->wpa_ie);
1998 bss->wpa_ie = kmalloc(elems.wpa_len + 2, GFP_ATOMIC);
1999 if (bss->wpa_ie) {
2000 memcpy(bss->wpa_ie, elems.wpa - 2, elems.wpa_len + 2);
2001 bss->wpa_ie_len = elems.wpa_len + 2;
2002 } else
2003 bss->wpa_ie_len = 0;
2004 } else if (!elems.wpa && bss->wpa_ie) {
2005 kfree(bss->wpa_ie);
2006 bss->wpa_ie = NULL;
2007 bss->wpa_ie_len = 0;
2008 }
2009
2010 if (elems.rsn &&
2011 (!bss->rsn_ie || bss->rsn_ie_len != elems.rsn_len ||
2012 memcmp(bss->rsn_ie, elems.rsn, elems.rsn_len))) {
2013 kfree(bss->rsn_ie);
2014 bss->rsn_ie = kmalloc(elems.rsn_len + 2, GFP_ATOMIC);
2015 if (bss->rsn_ie) {
2016 memcpy(bss->rsn_ie, elems.rsn - 2, elems.rsn_len + 2);
2017 bss->rsn_ie_len = elems.rsn_len + 2;
2018 } else
2019 bss->rsn_ie_len = 0;
2020 } else if (!elems.rsn && bss->rsn_ie) {
2021 kfree(bss->rsn_ie);
2022 bss->rsn_ie = NULL;
2023 bss->rsn_ie_len = 0;
2024 }
2025
2026 if (elems.wmm_param &&
2027 (!bss->wmm_ie || bss->wmm_ie_len != elems.wmm_param_len ||
2028 memcmp(bss->wmm_ie, elems.wmm_param, elems.wmm_param_len))) {
2029 kfree(bss->wmm_ie);
2030 bss->wmm_ie = kmalloc(elems.wmm_param_len + 2, GFP_ATOMIC);
2031 if (bss->wmm_ie) {
2032 memcpy(bss->wmm_ie, elems.wmm_param - 2,
2033 elems.wmm_param_len + 2);
2034 bss->wmm_ie_len = elems.wmm_param_len + 2;
2035 } else
2036 bss->wmm_ie_len = 0;
2037 } else if (!elems.wmm_param && bss->wmm_ie) {
2038 kfree(bss->wmm_ie);
2039 bss->wmm_ie = NULL;
2040 bss->wmm_ie_len = 0;
2041 }
2042 if (elems.ht_cap_elem &&
2043 (!bss->ht_ie || bss->ht_ie_len != elems.ht_cap_elem_len ||
2044 memcmp(bss->ht_ie, elems.ht_cap_elem, elems.ht_cap_elem_len))) {
2045 kfree(bss->ht_ie);
2046 bss->ht_ie = kmalloc(elems.ht_cap_elem_len + 2, GFP_ATOMIC);
2047 if (bss->ht_ie) {
2048 memcpy(bss->ht_ie, elems.ht_cap_elem - 2,
2049 elems.ht_cap_elem_len + 2);
2050 bss->ht_ie_len = elems.ht_cap_elem_len + 2;
2051 } else
2052 bss->ht_ie_len = 0;
2053 } else if (!elems.ht_cap_elem && bss->ht_ie) {
2054 kfree(bss->ht_ie);
2055 bss->ht_ie = NULL;
2056 bss->ht_ie_len = 0;
2057 }
2058
2059 bss->hw_mode = rx_status->phymode;
2060 bss->freq = rx_status->freq;
2061 if (channel != rx_status->channel &&
2062 (bss->hw_mode == MODE_IEEE80211G ||
2063 bss->hw_mode == MODE_IEEE80211B) &&
2064 channel >= 1 && channel <= 14) {
2065 static const int freq_list[] = {
2066 2412, 2417, 2422, 2427, 2432, 2437, 2442,
2067 2447, 2452, 2457, 2462, 2467, 2472, 2484
2068 };
2069 /* IEEE 802.11g/b mode can receive packets from neighboring
2070 * channels, so map the channel into frequency. */
2071 bss->freq = freq_list[channel - 1];
2072 }
2073 bss->timestamp = timestamp;
2074 bss->last_update = jiffies;
2075 bss->rssi = rx_status->ssi;
2076 bss->signal = rx_status->signal;
2077 bss->noise = rx_status->noise;
2078 if (!beacon)
2079 bss->probe_resp++;
2080 ieee80211_rx_bss_put(dev, bss);
2081 }
2082
2083
2084 static void ieee80211_rx_mgmt_probe_resp(struct net_device *dev,
2085 struct ieee80211_mgmt *mgmt,
2086 size_t len,
2087 struct ieee80211_rx_status *rx_status)
2088 {
2089 ieee80211_rx_bss_info(dev, mgmt, len, rx_status, 0);
2090 }
2091
2092
2093 static void ieee80211_rx_mgmt_beacon(struct net_device *dev,
2094 struct ieee80211_mgmt *mgmt,
2095 size_t len,
2096 struct ieee80211_rx_status *rx_status)
2097 {
2098 struct ieee80211_sub_if_data *sdata;
2099 struct ieee80211_if_sta *ifsta;
2100 size_t baselen;
2101 struct ieee802_11_elems elems;
2102 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2103 struct ieee80211_conf *conf = &local->hw.conf;
2104 u32 changed = 0;
2105
2106 ieee80211_rx_bss_info(dev, mgmt, len, rx_status, 1);
2107
2108 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2109 if (sdata->vif.type != IEEE80211_IF_TYPE_STA)
2110 return;
2111 ifsta = &sdata->u.sta;
2112
2113 if (!(ifsta->flags & IEEE80211_STA_ASSOCIATED) ||
2114 memcmp(ifsta->bssid, mgmt->bssid, ETH_ALEN) != 0)
2115 return;
2116
2117 /* Process beacon from the current BSS */
2118 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
2119 if (baselen > len)
2120 return;
2121
2122 ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen, &elems);
2123
2124 if (elems.erp_info && elems.erp_info_len >= 1)
2125 changed |= ieee80211_handle_erp_ie(sdata, elems.erp_info[0]);
2126
2127 if (elems.ht_cap_elem && elems.ht_info_elem &&
2128 elems.wmm_param && local->ops->conf_ht &&
2129 conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) {
2130 struct ieee80211_ht_bss_info bss_info;
2131
2132 ieee80211_ht_addt_info_ie_to_ht_bss_info(
2133 (struct ieee80211_ht_addt_info *)
2134 elems.ht_info_elem, &bss_info);
2135 /* check if AP changed bss inforamation */
2136 if ((conf->ht_bss_conf.primary_channel !=
2137 bss_info.primary_channel) ||
2138 (conf->ht_bss_conf.bss_cap != bss_info.bss_cap) ||
2139 (conf->ht_bss_conf.bss_op_mode != bss_info.bss_op_mode))
2140 ieee80211_hw_config_ht(local, 1, &conf->ht_conf,
2141 &bss_info);
2142 }
2143
2144 if (elems.wmm_param && (ifsta->flags & IEEE80211_STA_WMM_ENABLED)) {
2145 ieee80211_sta_wmm_params(dev, ifsta, elems.wmm_param,
2146 elems.wmm_param_len);
2147 }
2148
2149 ieee80211_bss_info_change_notify(sdata, changed);
2150 }
2151
2152
2153 static void ieee80211_rx_mgmt_probe_req(struct net_device *dev,
2154 struct ieee80211_if_sta *ifsta,
2155 struct ieee80211_mgmt *mgmt,
2156 size_t len,
2157 struct ieee80211_rx_status *rx_status)
2158 {
2159 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2160 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2161 int tx_last_beacon;
2162 struct sk_buff *skb;
2163 struct ieee80211_mgmt *resp;
2164 u8 *pos, *end;
2165 DECLARE_MAC_BUF(mac);
2166 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2167 DECLARE_MAC_BUF(mac2);
2168 DECLARE_MAC_BUF(mac3);
2169 #endif
2170
2171 if (sdata->vif.type != IEEE80211_IF_TYPE_IBSS ||
2172 ifsta->state != IEEE80211_IBSS_JOINED ||
2173 len < 24 + 2 || !ifsta->probe_resp)
2174 return;
2175
2176 if (local->ops->tx_last_beacon)
2177 tx_last_beacon = local->ops->tx_last_beacon(local_to_hw(local));
2178 else
2179 tx_last_beacon = 1;
2180
2181 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2182 printk(KERN_DEBUG "%s: RX ProbeReq SA=%s DA=%s BSSID="
2183 "%s (tx_last_beacon=%d)\n",
2184 dev->name, print_mac(mac, mgmt->sa), print_mac(mac2, mgmt->da),
2185 print_mac(mac3, mgmt->bssid), tx_last_beacon);
2186 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
2187
2188 if (!tx_last_beacon)
2189 return;
2190
2191 if (memcmp(mgmt->bssid, ifsta->bssid, ETH_ALEN) != 0 &&
2192 memcmp(mgmt->bssid, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) != 0)
2193 return;
2194
2195 end = ((u8 *) mgmt) + len;
2196 pos = mgmt->u.probe_req.variable;
2197 if (pos[0] != WLAN_EID_SSID ||
2198 pos + 2 + pos[1] > end) {
2199 if (net_ratelimit()) {
2200 printk(KERN_DEBUG "%s: Invalid SSID IE in ProbeReq "
2201 "from %s\n",
2202 dev->name, print_mac(mac, mgmt->sa));
2203 }
2204 return;
2205 }
2206 if (pos[1] != 0 &&
2207 (pos[1] != ifsta->ssid_len ||
2208 memcmp(pos + 2, ifsta->ssid, ifsta->ssid_len) != 0)) {
2209 /* Ignore ProbeReq for foreign SSID */
2210 return;
2211 }
2212
2213 /* Reply with ProbeResp */
2214 skb = skb_copy(ifsta->probe_resp, GFP_KERNEL);
2215 if (!skb)
2216 return;
2217
2218 resp = (struct ieee80211_mgmt *) skb->data;
2219 memcpy(resp->da, mgmt->sa, ETH_ALEN);
2220 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2221 printk(KERN_DEBUG "%s: Sending ProbeResp to %s\n",
2222 dev->name, print_mac(mac, resp->da));
2223 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
2224 ieee80211_sta_tx(dev, skb, 0);
2225 }
2226
2227 static void ieee80211_rx_mgmt_action(struct net_device *dev,
2228 struct ieee80211_if_sta *ifsta,
2229 struct ieee80211_mgmt *mgmt,
2230 size_t len)
2231 {
2232 if (len < IEEE80211_MIN_ACTION_SIZE)
2233 return;
2234
2235 switch (mgmt->u.action.category) {
2236 case WLAN_CATEGORY_BACK:
2237 switch (mgmt->u.action.u.addba_req.action_code) {
2238 case WLAN_ACTION_ADDBA_REQ:
2239 if (len < (IEEE80211_MIN_ACTION_SIZE +
2240 sizeof(mgmt->u.action.u.addba_req)))
2241 break;
2242 ieee80211_sta_process_addba_request(dev, mgmt, len);
2243 break;
2244 case WLAN_ACTION_DELBA:
2245 if (len < (IEEE80211_MIN_ACTION_SIZE +
2246 sizeof(mgmt->u.action.u.delba)))
2247 break;
2248 ieee80211_sta_process_delba(dev, mgmt, len);
2249 break;
2250 default:
2251 if (net_ratelimit())
2252 printk(KERN_DEBUG "%s: Rx unknown A-MPDU action\n",
2253 dev->name);
2254 break;
2255 }
2256 break;
2257 default:
2258 break;
2259 }
2260 }
2261
2262 void ieee80211_sta_rx_mgmt(struct net_device *dev, struct sk_buff *skb,
2263 struct ieee80211_rx_status *rx_status)
2264 {
2265 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2266 struct ieee80211_sub_if_data *sdata;
2267 struct ieee80211_if_sta *ifsta;
2268 struct ieee80211_mgmt *mgmt;
2269 u16 fc;
2270
2271 if (skb->len < 24)
2272 goto fail;
2273
2274 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2275 ifsta = &sdata->u.sta;
2276
2277 mgmt = (struct ieee80211_mgmt *) skb->data;
2278 fc = le16_to_cpu(mgmt->frame_control);
2279
2280 switch (fc & IEEE80211_FCTL_STYPE) {
2281 case IEEE80211_STYPE_PROBE_REQ:
2282 case IEEE80211_STYPE_PROBE_RESP:
2283 case IEEE80211_STYPE_BEACON:
2284 memcpy(skb->cb, rx_status, sizeof(*rx_status));
2285 case IEEE80211_STYPE_AUTH:
2286 case IEEE80211_STYPE_ASSOC_RESP:
2287 case IEEE80211_STYPE_REASSOC_RESP:
2288 case IEEE80211_STYPE_DEAUTH:
2289 case IEEE80211_STYPE_DISASSOC:
2290 case IEEE80211_STYPE_ACTION:
2291 skb_queue_tail(&ifsta->skb_queue, skb);
2292 queue_work(local->hw.workqueue, &ifsta->work);
2293 return;
2294 default:
2295 printk(KERN_DEBUG "%s: received unknown management frame - "
2296 "stype=%d\n", dev->name,
2297 (fc & IEEE80211_FCTL_STYPE) >> 4);
2298 break;
2299 }
2300
2301 fail:
2302 kfree_skb(skb);
2303 }
2304
2305
2306 static void ieee80211_sta_rx_queued_mgmt(struct net_device *dev,
2307 struct sk_buff *skb)
2308 {
2309 struct ieee80211_rx_status *rx_status;
2310 struct ieee80211_sub_if_data *sdata;
2311 struct ieee80211_if_sta *ifsta;
2312 struct ieee80211_mgmt *mgmt;
2313 u16 fc;
2314
2315 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2316 ifsta = &sdata->u.sta;
2317
2318 rx_status = (struct ieee80211_rx_status *) skb->cb;
2319 mgmt = (struct ieee80211_mgmt *) skb->data;
2320 fc = le16_to_cpu(mgmt->frame_control);
2321
2322 switch (fc & IEEE80211_FCTL_STYPE) {
2323 case IEEE80211_STYPE_PROBE_REQ:
2324 ieee80211_rx_mgmt_probe_req(dev, ifsta, mgmt, skb->len,
2325 rx_status);
2326 break;
2327 case IEEE80211_STYPE_PROBE_RESP:
2328 ieee80211_rx_mgmt_probe_resp(dev, mgmt, skb->len, rx_status);
2329 break;
2330 case IEEE80211_STYPE_BEACON:
2331 ieee80211_rx_mgmt_beacon(dev, mgmt, skb->len, rx_status);
2332 break;
2333 case IEEE80211_STYPE_AUTH:
2334 ieee80211_rx_mgmt_auth(dev, ifsta, mgmt, skb->len);
2335 break;
2336 case IEEE80211_STYPE_ASSOC_RESP:
2337 ieee80211_rx_mgmt_assoc_resp(sdata, ifsta, mgmt, skb->len, 0);
2338 break;
2339 case IEEE80211_STYPE_REASSOC_RESP:
2340 ieee80211_rx_mgmt_assoc_resp(sdata, ifsta, mgmt, skb->len, 1);
2341 break;
2342 case IEEE80211_STYPE_DEAUTH:
2343 ieee80211_rx_mgmt_deauth(dev, ifsta, mgmt, skb->len);
2344 break;
2345 case IEEE80211_STYPE_DISASSOC:
2346 ieee80211_rx_mgmt_disassoc(dev, ifsta, mgmt, skb->len);
2347 break;
2348 case IEEE80211_STYPE_ACTION:
2349 ieee80211_rx_mgmt_action(dev, ifsta, mgmt, skb->len);
2350 break;
2351 }
2352
2353 kfree_skb(skb);
2354 }
2355
2356
2357 ieee80211_txrx_result
2358 ieee80211_sta_rx_scan(struct net_device *dev, struct sk_buff *skb,
2359 struct ieee80211_rx_status *rx_status)
2360 {
2361 struct ieee80211_mgmt *mgmt;
2362 u16 fc;
2363
2364 if (skb->len < 2)
2365 return TXRX_DROP;
2366
2367 mgmt = (struct ieee80211_mgmt *) skb->data;
2368 fc = le16_to_cpu(mgmt->frame_control);
2369
2370 if ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL)
2371 return TXRX_CONTINUE;
2372
2373 if (skb->len < 24)
2374 return TXRX_DROP;
2375
2376 if ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) {
2377 if ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PROBE_RESP) {
2378 ieee80211_rx_mgmt_probe_resp(dev, mgmt,
2379 skb->len, rx_status);
2380 dev_kfree_skb(skb);
2381 return TXRX_QUEUED;
2382 } else if ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_BEACON) {
2383 ieee80211_rx_mgmt_beacon(dev, mgmt, skb->len,
2384 rx_status);
2385 dev_kfree_skb(skb);
2386 return TXRX_QUEUED;
2387 }
2388 }
2389 return TXRX_CONTINUE;
2390 }
2391
2392
2393 static int ieee80211_sta_active_ibss(struct net_device *dev)
2394 {
2395 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2396 int active = 0;
2397 struct sta_info *sta;
2398
2399 read_lock_bh(&local->sta_lock);
2400 list_for_each_entry(sta, &local->sta_list, list) {
2401 if (sta->dev == dev &&
2402 time_after(sta->last_rx + IEEE80211_IBSS_MERGE_INTERVAL,
2403 jiffies)) {
2404 active++;
2405 break;
2406 }
2407 }
2408 read_unlock_bh(&local->sta_lock);
2409
2410 return active;
2411 }
2412
2413
2414 static void ieee80211_sta_expire(struct net_device *dev)
2415 {
2416 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2417 struct sta_info *sta, *tmp;
2418 LIST_HEAD(tmp_list);
2419 DECLARE_MAC_BUF(mac);
2420
2421 write_lock_bh(&local->sta_lock);
2422 list_for_each_entry_safe(sta, tmp, &local->sta_list, list)
2423 if (time_after(jiffies, sta->last_rx +
2424 IEEE80211_IBSS_INACTIVITY_LIMIT)) {
2425 printk(KERN_DEBUG "%s: expiring inactive STA %s\n",
2426 dev->name, print_mac(mac, sta->addr));
2427 __sta_info_get(sta);
2428 sta_info_remove(sta);
2429 list_add(&sta->list, &tmp_list);
2430 }
2431 write_unlock_bh(&local->sta_lock);
2432
2433 list_for_each_entry_safe(sta, tmp, &tmp_list, list) {
2434 sta_info_free(sta);
2435 sta_info_put(sta);
2436 }
2437 }
2438
2439
2440 static void ieee80211_sta_merge_ibss(struct net_device *dev,
2441 struct ieee80211_if_sta *ifsta)
2442 {
2443 mod_timer(&ifsta->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
2444
2445 ieee80211_sta_expire(dev);
2446 if (ieee80211_sta_active_ibss(dev))
2447 return;
2448
2449 printk(KERN_DEBUG "%s: No active IBSS STAs - trying to scan for other "
2450 "IBSS networks with same SSID (merge)\n", dev->name);
2451 ieee80211_sta_req_scan(dev, ifsta->ssid, ifsta->ssid_len);
2452 }
2453
2454
2455 void ieee80211_sta_timer(unsigned long data)
2456 {
2457 struct ieee80211_sub_if_data *sdata =
2458 (struct ieee80211_sub_if_data *) data;
2459 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
2460 struct ieee80211_local *local = wdev_priv(&sdata->wdev);
2461
2462 set_bit(IEEE80211_STA_REQ_RUN, &ifsta->request);
2463 queue_work(local->hw.workqueue, &ifsta->work);
2464 }
2465
2466
2467 void ieee80211_sta_work(struct work_struct *work)
2468 {
2469 struct ieee80211_sub_if_data *sdata =
2470 container_of(work, struct ieee80211_sub_if_data, u.sta.work);
2471 struct net_device *dev = sdata->dev;
2472 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2473 struct ieee80211_if_sta *ifsta;
2474 struct sk_buff *skb;
2475
2476 if (!netif_running(dev))
2477 return;
2478
2479 if (local->sta_sw_scanning || local->sta_hw_scanning)
2480 return;
2481
2482 if (sdata->vif.type != IEEE80211_IF_TYPE_STA &&
2483 sdata->vif.type != IEEE80211_IF_TYPE_IBSS) {
2484 printk(KERN_DEBUG "%s: ieee80211_sta_work: non-STA interface "
2485 "(type=%d)\n", dev->name, sdata->vif.type);
2486 return;
2487 }
2488 ifsta = &sdata->u.sta;
2489
2490 while ((skb = skb_dequeue(&ifsta->skb_queue)))
2491 ieee80211_sta_rx_queued_mgmt(dev, skb);
2492
2493 if (ifsta->state != IEEE80211_AUTHENTICATE &&
2494 ifsta->state != IEEE80211_ASSOCIATE &&
2495 test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifsta->request)) {
2496 if (ifsta->scan_ssid_len)
2497 ieee80211_sta_start_scan(dev, ifsta->scan_ssid, ifsta->scan_ssid_len);
2498 else
2499 ieee80211_sta_start_scan(dev, NULL, 0);
2500 return;
2501 }
2502
2503 if (test_and_clear_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request)) {
2504 if (ieee80211_sta_config_auth(dev, ifsta))
2505 return;
2506 clear_bit(IEEE80211_STA_REQ_RUN, &ifsta->request);
2507 } else if (!test_and_clear_bit(IEEE80211_STA_REQ_RUN, &ifsta->request))
2508 return;
2509
2510 switch (ifsta->state) {
2511 case IEEE80211_DISABLED:
2512 break;
2513 case IEEE80211_AUTHENTICATE:
2514 ieee80211_authenticate(dev, ifsta);
2515 break;
2516 case IEEE80211_ASSOCIATE:
2517 ieee80211_associate(dev, ifsta);
2518 break;
2519 case IEEE80211_ASSOCIATED:
2520 ieee80211_associated(dev, ifsta);
2521 break;
2522 case IEEE80211_IBSS_SEARCH:
2523 ieee80211_sta_find_ibss(dev, ifsta);
2524 break;
2525 case IEEE80211_IBSS_JOINED:
2526 ieee80211_sta_merge_ibss(dev, ifsta);
2527 break;
2528 default:
2529 printk(KERN_DEBUG "ieee80211_sta_work: Unknown state %d\n",
2530 ifsta->state);
2531 break;
2532 }
2533
2534 if (ieee80211_privacy_mismatch(dev, ifsta)) {
2535 printk(KERN_DEBUG "%s: privacy configuration mismatch and "
2536 "mixed-cell disabled - disassociate\n", dev->name);
2537
2538 ieee80211_send_disassoc(dev, ifsta, WLAN_REASON_UNSPECIFIED);
2539 ieee80211_set_disassoc(dev, ifsta, 0);
2540 }
2541 }
2542
2543
2544 static void ieee80211_sta_reset_auth(struct net_device *dev,
2545 struct ieee80211_if_sta *ifsta)
2546 {
2547 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2548
2549 if (local->ops->reset_tsf) {
2550 /* Reset own TSF to allow time synchronization work. */
2551 local->ops->reset_tsf(local_to_hw(local));
2552 }
2553
2554 ifsta->wmm_last_param_set = -1; /* allow any WMM update */
2555
2556
2557 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_OPEN)
2558 ifsta->auth_alg = WLAN_AUTH_OPEN;
2559 else if (ifsta->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY)
2560 ifsta->auth_alg = WLAN_AUTH_SHARED_KEY;
2561 else if (ifsta->auth_algs & IEEE80211_AUTH_ALG_LEAP)
2562 ifsta->auth_alg = WLAN_AUTH_LEAP;
2563 else
2564 ifsta->auth_alg = WLAN_AUTH_OPEN;
2565 printk(KERN_DEBUG "%s: Initial auth_alg=%d\n", dev->name,
2566 ifsta->auth_alg);
2567 ifsta->auth_transaction = -1;
2568 ifsta->flags &= ~IEEE80211_STA_ASSOCIATED;
2569 ifsta->auth_tries = ifsta->assoc_tries = 0;
2570 netif_carrier_off(dev);
2571 }
2572
2573
2574 void ieee80211_sta_req_auth(struct net_device *dev,
2575 struct ieee80211_if_sta *ifsta)
2576 {
2577 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2578 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2579
2580 if (sdata->vif.type != IEEE80211_IF_TYPE_STA)
2581 return;
2582
2583 if ((ifsta->flags & (IEEE80211_STA_BSSID_SET |
2584 IEEE80211_STA_AUTO_BSSID_SEL)) &&
2585 (ifsta->flags & (IEEE80211_STA_SSID_SET |
2586 IEEE80211_STA_AUTO_SSID_SEL))) {
2587 set_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request);
2588 queue_work(local->hw.workqueue, &ifsta->work);
2589 }
2590 }
2591
2592 static int ieee80211_sta_match_ssid(struct ieee80211_if_sta *ifsta,
2593 const char *ssid, int ssid_len)
2594 {
2595 int tmp, hidden_ssid;
2596
2597 if (ssid_len == ifsta->ssid_len &&
2598 !memcmp(ifsta->ssid, ssid, ssid_len))
2599 return 1;
2600
2601 if (ifsta->flags & IEEE80211_STA_AUTO_BSSID_SEL)
2602 return 0;
2603
2604 hidden_ssid = 1;
2605 tmp = ssid_len;
2606 while (tmp--) {
2607 if (ssid[tmp] != '\0') {
2608 hidden_ssid = 0;
2609 break;
2610 }
2611 }
2612
2613 if (hidden_ssid && ifsta->ssid_len == ssid_len)
2614 return 1;
2615
2616 if (ssid_len == 1 && ssid[0] == ' ')
2617 return 1;
2618
2619 return 0;
2620 }
2621
2622 static int ieee80211_sta_config_auth(struct net_device *dev,
2623 struct ieee80211_if_sta *ifsta)
2624 {
2625 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2626 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2627 struct ieee80211_sta_bss *bss, *selected = NULL;
2628 int top_rssi = 0, freq;
2629
2630 if (!(ifsta->flags & (IEEE80211_STA_AUTO_SSID_SEL |
2631 IEEE80211_STA_AUTO_BSSID_SEL | IEEE80211_STA_AUTO_CHANNEL_SEL))) {
2632 ifsta->state = IEEE80211_AUTHENTICATE;
2633 ieee80211_sta_reset_auth(dev, ifsta);
2634 return 0;
2635 }
2636
2637 spin_lock_bh(&local->sta_bss_lock);
2638 freq = local->oper_channel->freq;
2639 list_for_each_entry(bss, &local->sta_bss_list, list) {
2640 if (!(bss->capability & WLAN_CAPABILITY_ESS))
2641 continue;
2642
2643 if (!!(bss->capability & WLAN_CAPABILITY_PRIVACY) ^
2644 !!sdata->default_key)
2645 continue;
2646
2647 if (!(ifsta->flags & IEEE80211_STA_AUTO_CHANNEL_SEL) &&
2648 bss->freq != freq)
2649 continue;
2650
2651 if (!(ifsta->flags & IEEE80211_STA_AUTO_BSSID_SEL) &&
2652 memcmp(bss->bssid, ifsta->bssid, ETH_ALEN))
2653 continue;
2654
2655 if (!(ifsta->flags & IEEE80211_STA_AUTO_SSID_SEL) &&
2656 !ieee80211_sta_match_ssid(ifsta, bss->ssid, bss->ssid_len))
2657 continue;
2658
2659 if (!selected || top_rssi < bss->rssi) {
2660 selected = bss;
2661 top_rssi = bss->rssi;
2662 }
2663 }
2664 if (selected)
2665 atomic_inc(&selected->users);
2666 spin_unlock_bh(&local->sta_bss_lock);
2667
2668 if (selected) {
2669 ieee80211_set_channel(local, -1, selected->freq);
2670 if (!(ifsta->flags & IEEE80211_STA_SSID_SET))
2671 ieee80211_sta_set_ssid(dev, selected->ssid,
2672 selected->ssid_len);
2673 ieee80211_sta_set_bssid(dev, selected->bssid);
2674 ieee80211_rx_bss_put(dev, selected);
2675 ifsta->state = IEEE80211_AUTHENTICATE;
2676 ieee80211_sta_reset_auth(dev, ifsta);
2677 return 0;
2678 } else {
2679 if (ifsta->state != IEEE80211_AUTHENTICATE) {
2680 if (ifsta->flags & IEEE80211_STA_AUTO_SSID_SEL)
2681 ieee80211_sta_start_scan(dev, NULL, 0);
2682 else
2683 ieee80211_sta_start_scan(dev, ifsta->ssid,
2684 ifsta->ssid_len);
2685 ifsta->state = IEEE80211_AUTHENTICATE;
2686 set_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request);
2687 } else
2688 ifsta->state = IEEE80211_DISABLED;
2689 }
2690 return -1;
2691 }
2692
2693 static int ieee80211_sta_join_ibss(struct net_device *dev,
2694 struct ieee80211_if_sta *ifsta,
2695 struct ieee80211_sta_bss *bss)
2696 {
2697 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2698 int res, rates, i, j;
2699 struct sk_buff *skb;
2700 struct ieee80211_mgmt *mgmt;
2701 struct ieee80211_tx_control control;
2702 struct ieee80211_hw_mode *mode;
2703 struct rate_selection ratesel;
2704 u8 *pos;
2705 struct ieee80211_sub_if_data *sdata;
2706
2707 /* Remove possible STA entries from other IBSS networks. */
2708 sta_info_flush(local, NULL);
2709
2710 if (local->ops->reset_tsf) {
2711 /* Reset own TSF to allow time synchronization work. */
2712 local->ops->reset_tsf(local_to_hw(local));
2713 }
2714 memcpy(ifsta->bssid, bss->bssid, ETH_ALEN);
2715 res = ieee80211_if_config(dev);
2716 if (res)
2717 return res;
2718
2719 local->hw.conf.beacon_int = bss->beacon_int >= 10 ? bss->beacon_int : 10;
2720
2721 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2722 sdata->drop_unencrypted = bss->capability &
2723 WLAN_CAPABILITY_PRIVACY ? 1 : 0;
2724
2725 res = ieee80211_set_channel(local, -1, bss->freq);
2726
2727 if (!(local->oper_channel->flag & IEEE80211_CHAN_W_IBSS)) {
2728 printk(KERN_DEBUG "%s: IBSS not allowed on channel %d "
2729 "(%d MHz)\n", dev->name, local->hw.conf.channel,
2730 local->hw.conf.freq);
2731 return -1;
2732 }
2733
2734 /* Set beacon template based on scan results */
2735 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
2736 do {
2737 if (!skb)
2738 break;
2739
2740 skb_reserve(skb, local->hw.extra_tx_headroom);
2741
2742 mgmt = (struct ieee80211_mgmt *)
2743 skb_put(skb, 24 + sizeof(mgmt->u.beacon));
2744 memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon));
2745 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
2746 IEEE80211_STYPE_BEACON);
2747 memset(mgmt->da, 0xff, ETH_ALEN);
2748 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
2749 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
2750 mgmt->u.beacon.beacon_int =
2751 cpu_to_le16(local->hw.conf.beacon_int);
2752 mgmt->u.beacon.capab_info = cpu_to_le16(bss->capability);
2753
2754 pos = skb_put(skb, 2 + ifsta->ssid_len);
2755 *pos++ = WLAN_EID_SSID;
2756 *pos++ = ifsta->ssid_len;
2757 memcpy(pos, ifsta->ssid, ifsta->ssid_len);
2758
2759 rates = bss->supp_rates_len;
2760 if (rates > 8)
2761 rates = 8;
2762 pos = skb_put(skb, 2 + rates);
2763 *pos++ = WLAN_EID_SUPP_RATES;
2764 *pos++ = rates;
2765 memcpy(pos, bss->supp_rates, rates);
2766
2767 pos = skb_put(skb, 2 + 1);
2768 *pos++ = WLAN_EID_DS_PARAMS;
2769 *pos++ = 1;
2770 *pos++ = bss->channel;
2771
2772 pos = skb_put(skb, 2 + 2);
2773 *pos++ = WLAN_EID_IBSS_PARAMS;
2774 *pos++ = 2;
2775 /* FIX: set ATIM window based on scan results */
2776 *pos++ = 0;
2777 *pos++ = 0;
2778
2779 if (bss->supp_rates_len > 8) {
2780 rates = bss->supp_rates_len - 8;
2781 pos = skb_put(skb, 2 + rates);
2782 *pos++ = WLAN_EID_EXT_SUPP_RATES;
2783 *pos++ = rates;
2784 memcpy(pos, &bss->supp_rates[8], rates);
2785 }
2786
2787 memset(&control, 0, sizeof(control));
2788 rate_control_get_rate(dev, local->oper_hw_mode, skb, &ratesel);
2789 if (!ratesel.rate) {
2790 printk(KERN_DEBUG "%s: Failed to determine TX rate "
2791 "for IBSS beacon\n", dev->name);
2792 break;
2793 }
2794 control.vif = &sdata->vif;
2795 control.tx_rate =
2796 (sdata->bss_conf.use_short_preamble &&
2797 (ratesel.rate->flags & IEEE80211_RATE_PREAMBLE2)) ?
2798 ratesel.rate->val2 : ratesel.rate->val;
2799 control.antenna_sel_tx = local->hw.conf.antenna_sel_tx;
2800 control.power_level = local->hw.conf.power_level;
2801 control.flags |= IEEE80211_TXCTL_NO_ACK;
2802 control.retry_limit = 1;
2803
2804 ifsta->probe_resp = skb_copy(skb, GFP_ATOMIC);
2805 if (ifsta->probe_resp) {
2806 mgmt = (struct ieee80211_mgmt *)
2807 ifsta->probe_resp->data;
2808 mgmt->frame_control =
2809 IEEE80211_FC(IEEE80211_FTYPE_MGMT,
2810 IEEE80211_STYPE_PROBE_RESP);
2811 } else {
2812 printk(KERN_DEBUG "%s: Could not allocate ProbeResp "
2813 "template for IBSS\n", dev->name);
2814 }
2815
2816 if (local->ops->beacon_update &&
2817 local->ops->beacon_update(local_to_hw(local),
2818 skb, &control) == 0) {
2819 printk(KERN_DEBUG "%s: Configured IBSS beacon "
2820 "template based on scan results\n", dev->name);
2821 skb = NULL;
2822 }
2823
2824 rates = 0;
2825 mode = local->oper_hw_mode;
2826 for (i = 0; i < bss->supp_rates_len; i++) {
2827 int bitrate = (bss->supp_rates[i] & 0x7f) * 5;
2828 for (j = 0; j < mode->num_rates; j++)
2829 if (mode->rates[j].rate == bitrate)
2830 rates |= BIT(j);
2831 }
2832 ifsta->supp_rates_bits = rates;
2833 } while (0);
2834
2835 if (skb) {
2836 printk(KERN_DEBUG "%s: Failed to configure IBSS beacon "
2837 "template\n", dev->name);
2838 dev_kfree_skb(skb);
2839 }
2840
2841 ifsta->state = IEEE80211_IBSS_JOINED;
2842 mod_timer(&ifsta->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
2843
2844 ieee80211_rx_bss_put(dev, bss);
2845
2846 return res;
2847 }
2848
2849
2850 static int ieee80211_sta_create_ibss(struct net_device *dev,
2851 struct ieee80211_if_sta *ifsta)
2852 {
2853 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2854 struct ieee80211_sta_bss *bss;
2855 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2856 struct ieee80211_hw_mode *mode;
2857 u8 bssid[ETH_ALEN], *pos;
2858 int i;
2859 DECLARE_MAC_BUF(mac);
2860
2861 #if 0
2862 /* Easier testing, use fixed BSSID. */
2863 memset(bssid, 0xfe, ETH_ALEN);
2864 #else
2865 /* Generate random, not broadcast, locally administered BSSID. Mix in
2866 * own MAC address to make sure that devices that do not have proper
2867 * random number generator get different BSSID. */
2868 get_random_bytes(bssid, ETH_ALEN);
2869 for (i = 0; i < ETH_ALEN; i++)
2870 bssid[i] ^= dev->dev_addr[i];
2871 bssid[0] &= ~0x01;
2872 bssid[0] |= 0x02;
2873 #endif
2874
2875 printk(KERN_DEBUG "%s: Creating new IBSS network, BSSID %s\n",
2876 dev->name, print_mac(mac, bssid));
2877
2878 bss = ieee80211_rx_bss_add(dev, bssid, local->hw.conf.channel,
2879 sdata->u.sta.ssid, sdata->u.sta.ssid_len);
2880 if (!bss)
2881 return -ENOMEM;
2882
2883 mode = local->oper_hw_mode;
2884
2885 if (local->hw.conf.beacon_int == 0)
2886 local->hw.conf.beacon_int = 100;
2887 bss->beacon_int = local->hw.conf.beacon_int;
2888 bss->hw_mode = local->hw.conf.phymode;
2889 bss->freq = local->hw.conf.freq;
2890 bss->last_update = jiffies;
2891 bss->capability = WLAN_CAPABILITY_IBSS;
2892 if (sdata->default_key) {
2893 bss->capability |= WLAN_CAPABILITY_PRIVACY;
2894 } else
2895 sdata->drop_unencrypted = 0;
2896 bss->supp_rates_len = mode->num_rates;
2897 pos = bss->supp_rates;
2898 for (i = 0; i < mode->num_rates; i++) {
2899 int rate = mode->rates[i].rate;
2900 *pos++ = (u8) (rate / 5);
2901 }
2902
2903 return ieee80211_sta_join_ibss(dev, ifsta, bss);
2904 }
2905
2906
2907 static int ieee80211_sta_find_ibss(struct net_device *dev,
2908 struct ieee80211_if_sta *ifsta)
2909 {
2910 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2911 struct ieee80211_sta_bss *bss;
2912 int found = 0;
2913 u8 bssid[ETH_ALEN];
2914 int active_ibss;
2915 DECLARE_MAC_BUF(mac);
2916 DECLARE_MAC_BUF(mac2);
2917
2918 if (ifsta->ssid_len == 0)
2919 return -EINVAL;
2920
2921 active_ibss = ieee80211_sta_active_ibss(dev);
2922 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2923 printk(KERN_DEBUG "%s: sta_find_ibss (active_ibss=%d)\n",
2924 dev->name, active_ibss);
2925 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
2926 spin_lock_bh(&local->sta_bss_lock);
2927 list_for_each_entry(bss, &local->sta_bss_list, list) {
2928 if (ifsta->ssid_len != bss->ssid_len ||
2929 memcmp(ifsta->ssid, bss->ssid, bss->ssid_len) != 0
2930 || !(bss->capability & WLAN_CAPABILITY_IBSS))
2931 continue;
2932 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2933 printk(KERN_DEBUG " bssid=%s found\n",
2934 print_mac(mac, bss->bssid));
2935 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
2936 memcpy(bssid, bss->bssid, ETH_ALEN);
2937 found = 1;
2938 if (active_ibss || memcmp(bssid, ifsta->bssid, ETH_ALEN) != 0)
2939 break;
2940 }
2941 spin_unlock_bh(&local->sta_bss_lock);
2942
2943 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2944 printk(KERN_DEBUG " sta_find_ibss: selected %s current "
2945 "%s\n", print_mac(mac, bssid), print_mac(mac2, ifsta->bssid));
2946 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
2947 if (found && memcmp(ifsta->bssid, bssid, ETH_ALEN) != 0 &&
2948 (bss = ieee80211_rx_bss_get(dev, bssid, local->hw.conf.channel,
2949 ifsta->ssid, ifsta->ssid_len))) {
2950 printk(KERN_DEBUG "%s: Selected IBSS BSSID %s"
2951 " based on configured SSID\n",
2952 dev->name, print_mac(mac, bssid));
2953 return ieee80211_sta_join_ibss(dev, ifsta, bss);
2954 }
2955 #ifdef CONFIG_MAC80211_IBSS_DEBUG
2956 printk(KERN_DEBUG " did not try to join ibss\n");
2957 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
2958
2959 /* Selected IBSS not found in current scan results - try to scan */
2960 if (ifsta->state == IEEE80211_IBSS_JOINED &&
2961 !ieee80211_sta_active_ibss(dev)) {
2962 mod_timer(&ifsta->timer, jiffies +
2963 IEEE80211_IBSS_MERGE_INTERVAL);
2964 } else if (time_after(jiffies, local->last_scan_completed +
2965 IEEE80211_SCAN_INTERVAL)) {
2966 printk(KERN_DEBUG "%s: Trigger new scan to find an IBSS to "
2967 "join\n", dev->name);
2968 return ieee80211_sta_req_scan(dev, ifsta->ssid,
2969 ifsta->ssid_len);
2970 } else if (ifsta->state != IEEE80211_IBSS_JOINED) {
2971 int interval = IEEE80211_SCAN_INTERVAL;
2972
2973 if (time_after(jiffies, ifsta->ibss_join_req +
2974 IEEE80211_IBSS_JOIN_TIMEOUT)) {
2975 if ((ifsta->flags & IEEE80211_STA_CREATE_IBSS) &&
2976 local->oper_channel->flag & IEEE80211_CHAN_W_IBSS)
2977 return ieee80211_sta_create_ibss(dev, ifsta);
2978 if (ifsta->flags & IEEE80211_STA_CREATE_IBSS) {
2979 printk(KERN_DEBUG "%s: IBSS not allowed on the"
2980 " configured channel %d (%d MHz)\n",
2981 dev->name, local->hw.conf.channel,
2982 local->hw.conf.freq);
2983 }
2984
2985 /* No IBSS found - decrease scan interval and continue
2986 * scanning. */
2987 interval = IEEE80211_SCAN_INTERVAL_SLOW;
2988 }
2989
2990 ifsta->state = IEEE80211_IBSS_SEARCH;
2991 mod_timer(&ifsta->timer, jiffies + interval);
2992 return 0;
2993 }
2994
2995 return 0;
2996 }
2997
2998
2999 int ieee80211_sta_set_ssid(struct net_device *dev, char *ssid, size_t len)
3000 {
3001 struct ieee80211_sub_if_data *sdata;
3002 struct ieee80211_if_sta *ifsta;
3003 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
3004
3005 if (len > IEEE80211_MAX_SSID_LEN)
3006 return -EINVAL;
3007
3008 /* TODO: This should always be done for IBSS, even if IEEE80211_QOS is
3009 * not defined. */
3010 if (local->ops->conf_tx) {
3011 struct ieee80211_tx_queue_params qparam;
3012 int i;
3013
3014 memset(&qparam, 0, sizeof(qparam));
3015 /* TODO: are these ok defaults for all hw_modes? */
3016 qparam.aifs = 2;
3017 qparam.cw_min =
3018 local->hw.conf.phymode == MODE_IEEE80211B ? 31 : 15;
3019 qparam.cw_max = 1023;
3020 qparam.burst_time = 0;
3021 for (i = IEEE80211_TX_QUEUE_DATA0; i < NUM_TX_DATA_QUEUES; i++)
3022 {
3023 local->ops->conf_tx(local_to_hw(local),
3024 i + IEEE80211_TX_QUEUE_DATA0,
3025 &qparam);
3026 }
3027 /* IBSS uses different parameters for Beacon sending */
3028 qparam.cw_min++;
3029 qparam.cw_min *= 2;
3030 qparam.cw_min--;
3031 local->ops->conf_tx(local_to_hw(local),
3032 IEEE80211_TX_QUEUE_BEACON, &qparam);
3033 }
3034
3035 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3036 ifsta = &sdata->u.sta;
3037
3038 if (ifsta->ssid_len != len || memcmp(ifsta->ssid, ssid, len) != 0)
3039 ifsta->flags &= ~IEEE80211_STA_PREV_BSSID_SET;
3040 memcpy(ifsta->ssid, ssid, len);
3041 memset(ifsta->ssid + len, 0, IEEE80211_MAX_SSID_LEN - len);
3042 ifsta->ssid_len = len;
3043
3044 if (len)
3045 ifsta->flags |= IEEE80211_STA_SSID_SET;
3046 else
3047 ifsta->flags &= ~IEEE80211_STA_SSID_SET;
3048 if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS &&
3049 !(ifsta->flags & IEEE80211_STA_BSSID_SET)) {
3050 ifsta->ibss_join_req = jiffies;
3051 ifsta->state = IEEE80211_IBSS_SEARCH;
3052 return ieee80211_sta_find_ibss(dev, ifsta);
3053 }
3054 return 0;
3055 }
3056
3057
3058 int ieee80211_sta_get_ssid(struct net_device *dev, char *ssid, size_t *len)
3059 {
3060 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3061 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
3062 memcpy(ssid, ifsta->ssid, ifsta->ssid_len);
3063 *len = ifsta->ssid_len;
3064 return 0;
3065 }
3066
3067
3068 int ieee80211_sta_set_bssid(struct net_device *dev, u8 *bssid)
3069 {
3070 struct ieee80211_sub_if_data *sdata;
3071 struct ieee80211_if_sta *ifsta;
3072 int res;
3073
3074 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3075 ifsta = &sdata->u.sta;
3076
3077 if (memcmp(ifsta->bssid, bssid, ETH_ALEN) != 0) {
3078 memcpy(ifsta->bssid, bssid, ETH_ALEN);
3079 res = ieee80211_if_config(dev);
3080 if (res) {
3081 printk(KERN_DEBUG "%s: Failed to config new BSSID to "
3082 "the low-level driver\n", dev->name);
3083 return res;
3084 }
3085 }
3086
3087 if (is_valid_ether_addr(bssid))
3088 ifsta->flags |= IEEE80211_STA_BSSID_SET;
3089 else
3090 ifsta->flags &= ~IEEE80211_STA_BSSID_SET;
3091
3092 return 0;
3093 }
3094
3095
3096 static void ieee80211_send_nullfunc(struct ieee80211_local *local,
3097 struct ieee80211_sub_if_data *sdata,
3098 int powersave)
3099 {
3100 struct sk_buff *skb;
3101 struct ieee80211_hdr *nullfunc;
3102 u16 fc;
3103
3104 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);
3105 if (!skb) {
3106 printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
3107 "frame\n", sdata->dev->name);
3108 return;
3109 }
3110 skb_reserve(skb, local->hw.extra_tx_headroom);
3111
3112 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
3113 memset(nullfunc, 0, 24);
3114 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
3115 IEEE80211_FCTL_TODS;
3116 if (powersave)
3117 fc |= IEEE80211_FCTL_PM;
3118 nullfunc->frame_control = cpu_to_le16(fc);
3119 memcpy(nullfunc->addr1, sdata->u.sta.bssid, ETH_ALEN);
3120 memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);
3121 memcpy(nullfunc->addr3, sdata->u.sta.bssid, ETH_ALEN);
3122
3123 ieee80211_sta_tx(sdata->dev, skb, 0);
3124 }
3125
3126
3127 void ieee80211_scan_completed(struct ieee80211_hw *hw)
3128 {
3129 struct ieee80211_local *local = hw_to_local(hw);
3130 struct net_device *dev = local->scan_dev;
3131 struct ieee80211_sub_if_data *sdata;
3132 union iwreq_data wrqu;
3133
3134 local->last_scan_completed = jiffies;
3135 memset(&wrqu, 0, sizeof(wrqu));
3136 wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
3137
3138 if (local->sta_hw_scanning) {
3139 local->sta_hw_scanning = 0;
3140 goto done;
3141 }
3142
3143 local->sta_sw_scanning = 0;
3144 if (ieee80211_hw_config(local))
3145 printk(KERN_DEBUG "%s: failed to restore operational "
3146 "channel after scan\n", dev->name);
3147
3148
3149 netif_tx_lock_bh(local->mdev);
3150 local->filter_flags &= ~FIF_BCN_PRBRESP_PROMISC;
3151 local->ops->configure_filter(local_to_hw(local),
3152 FIF_BCN_PRBRESP_PROMISC,
3153 &local->filter_flags,
3154 local->mdev->mc_count,
3155 local->mdev->mc_list);
3156
3157 netif_tx_unlock_bh(local->mdev);
3158
3159 rcu_read_lock();
3160 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
3161
3162 /* No need to wake the master device. */
3163 if (sdata->dev == local->mdev)
3164 continue;
3165
3166 if (sdata->vif.type == IEEE80211_IF_TYPE_STA) {
3167 if (sdata->u.sta.flags & IEEE80211_STA_ASSOCIATED)
3168 ieee80211_send_nullfunc(local, sdata, 0);
3169 ieee80211_sta_timer((unsigned long)sdata);
3170 }
3171
3172 netif_wake_queue(sdata->dev);
3173 }
3174 rcu_read_unlock();
3175
3176 done:
3177 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3178 if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
3179 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
3180 if (!(ifsta->flags & IEEE80211_STA_BSSID_SET) ||
3181 (!ifsta->state == IEEE80211_IBSS_JOINED &&
3182 !ieee80211_sta_active_ibss(dev)))
3183 ieee80211_sta_find_ibss(dev, ifsta);
3184 }
3185 }
3186 EXPORT_SYMBOL(ieee80211_scan_completed);
3187
3188 void ieee80211_sta_scan_work(struct work_struct *work)
3189 {
3190 struct ieee80211_local *local =
3191 container_of(work, struct ieee80211_local, scan_work.work);
3192 struct net_device *dev = local->scan_dev;
3193 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3194 struct ieee80211_hw_mode *mode;
3195 struct ieee80211_channel *chan;
3196 int skip;
3197 unsigned long next_delay = 0;
3198
3199 if (!local->sta_sw_scanning)
3200 return;
3201
3202 switch (local->scan_state) {
3203 case SCAN_SET_CHANNEL:
3204 mode = local->scan_hw_mode;
3205 if (local->scan_hw_mode->list.next == &local->modes_list &&
3206 local->scan_channel_idx >= mode->num_channels) {
3207 ieee80211_scan_completed(local_to_hw(local));
3208 return;
3209 }
3210 skip = !(local->enabled_modes & (1 << mode->mode));
3211 chan = &mode->channels[local->scan_channel_idx];
3212 if (!(chan->flag & IEEE80211_CHAN_W_SCAN) ||
3213 (sdata->vif.type == IEEE80211_IF_TYPE_IBSS &&
3214 !(chan->flag & IEEE80211_CHAN_W_IBSS)) ||
3215 (local->hw_modes & local->enabled_modes &
3216 (1 << MODE_IEEE80211G) && mode->mode == MODE_IEEE80211B))
3217 skip = 1;
3218
3219 if (!skip) {
3220 #if 0
3221 printk(KERN_DEBUG "%s: scan channel %d (%d MHz)\n",
3222 dev->name, chan->chan, chan->freq);
3223 #endif
3224
3225 local->scan_channel = chan;
3226 if (ieee80211_hw_config(local)) {
3227 printk(KERN_DEBUG "%s: failed to set channel "
3228 "%d (%d MHz) for scan\n", dev->name,
3229 chan->chan, chan->freq);
3230 skip = 1;
3231 }
3232 }
3233
3234 local->scan_channel_idx++;
3235 if (local->scan_channel_idx >= local->scan_hw_mode->num_channels) {
3236 if (local->scan_hw_mode->list.next != &local->modes_list) {
3237 local->scan_hw_mode = list_entry(local->scan_hw_mode->list.next,
3238 struct ieee80211_hw_mode,
3239 list);
3240 local->scan_channel_idx = 0;
3241 }
3242 }
3243
3244 if (skip)
3245 break;
3246
3247 next_delay = IEEE80211_PROBE_DELAY +
3248 usecs_to_jiffies(local->hw.channel_change_time);
3249 local->scan_state = SCAN_SEND_PROBE;
3250 break;
3251 case SCAN_SEND_PROBE:
3252 if (local->scan_channel->flag & IEEE80211_CHAN_W_ACTIVE_SCAN) {
3253 ieee80211_send_probe_req(dev, NULL, local->scan_ssid,
3254 local->scan_ssid_len);
3255 next_delay = IEEE80211_CHANNEL_TIME;
3256 } else
3257 next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
3258 local->scan_state = SCAN_SET_CHANNEL;
3259 break;
3260 }
3261
3262 if (local->sta_sw_scanning)
3263 queue_delayed_work(local->hw.workqueue, &local->scan_work,
3264 next_delay);
3265 }
3266
3267
3268 static int ieee80211_sta_start_scan(struct net_device *dev,
3269 u8 *ssid, size_t ssid_len)
3270 {
3271 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
3272 struct ieee80211_sub_if_data *sdata;
3273
3274 if (ssid_len > IEEE80211_MAX_SSID_LEN)
3275 return -EINVAL;
3276
3277 /* MLME-SCAN.request (page 118) page 144 (11.1.3.1)
3278 * BSSType: INFRASTRUCTURE, INDEPENDENT, ANY_BSS
3279 * BSSID: MACAddress
3280 * SSID
3281 * ScanType: ACTIVE, PASSIVE
3282 * ProbeDelay: delay (in microseconds) to be used prior to transmitting
3283 * a Probe frame during active scanning
3284 * ChannelList
3285 * MinChannelTime (>= ProbeDelay), in TU
3286 * MaxChannelTime: (>= MinChannelTime), in TU
3287 */
3288
3289 /* MLME-SCAN.confirm
3290 * BSSDescriptionSet
3291 * ResultCode: SUCCESS, INVALID_PARAMETERS
3292 */
3293
3294 if (local->sta_sw_scanning || local->sta_hw_scanning) {
3295 if (local->scan_dev == dev)
3296 return 0;
3297 return -EBUSY;
3298 }
3299
3300 if (local->ops->hw_scan) {
3301 int rc = local->ops->hw_scan(local_to_hw(local),
3302 ssid, ssid_len);
3303 if (!rc) {
3304 local->sta_hw_scanning = 1;
3305 local->scan_dev = dev;
3306 }
3307 return rc;
3308 }
3309
3310 local->sta_sw_scanning = 1;
3311
3312 rcu_read_lock();
3313 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
3314
3315 /* Don't stop the master interface, otherwise we can't transmit
3316 * probes! */
3317 if (sdata->dev == local->mdev)
3318 continue;
3319
3320 netif_stop_queue(sdata->dev);
3321 if (sdata->vif.type == IEEE80211_IF_TYPE_STA &&
3322 (sdata->u.sta.flags & IEEE80211_STA_ASSOCIATED))
3323 ieee80211_send_nullfunc(local, sdata, 1);
3324 }
3325 rcu_read_unlock();
3326
3327 if (ssid) {
3328 local->scan_ssid_len = ssid_len;
3329 memcpy(local->scan_ssid, ssid, ssid_len);
3330 } else
3331 local->scan_ssid_len = 0;
3332 local->scan_state = SCAN_SET_CHANNEL;
3333 local->scan_hw_mode = list_entry(local->modes_list.next,
3334 struct ieee80211_hw_mode,
3335 list);
3336 local->scan_channel_idx = 0;
3337 local->scan_dev = dev;
3338
3339 netif_tx_lock_bh(local->mdev);
3340 local->filter_flags |= FIF_BCN_PRBRESP_PROMISC;
3341 local->ops->configure_filter(local_to_hw(local),
3342 FIF_BCN_PRBRESP_PROMISC,
3343 &local->filter_flags,
3344 local->mdev->mc_count,
3345 local->mdev->mc_list);
3346 netif_tx_unlock_bh(local->mdev);
3347
3348 /* TODO: start scan as soon as all nullfunc frames are ACKed */
3349 queue_delayed_work(local->hw.workqueue, &local->scan_work,
3350 IEEE80211_CHANNEL_TIME);
3351
3352 return 0;
3353 }
3354
3355
3356 int ieee80211_sta_req_scan(struct net_device *dev, u8 *ssid, size_t ssid_len)
3357 {
3358 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3359 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
3360 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
3361
3362 if (sdata->vif.type != IEEE80211_IF_TYPE_STA)
3363 return ieee80211_sta_start_scan(dev, ssid, ssid_len);
3364
3365 if (local->sta_sw_scanning || local->sta_hw_scanning) {
3366 if (local->scan_dev == dev)
3367 return 0;
3368 return -EBUSY;
3369 }
3370
3371 ifsta->scan_ssid_len = ssid_len;
3372 if (ssid_len)
3373 memcpy(ifsta->scan_ssid, ssid, ssid_len);
3374 set_bit(IEEE80211_STA_REQ_SCAN, &ifsta->request);
3375 queue_work(local->hw.workqueue, &ifsta->work);
3376 return 0;
3377 }
3378
3379 static char *
3380 ieee80211_sta_scan_result(struct net_device *dev,
3381 struct ieee80211_sta_bss *bss,
3382 char *current_ev, char *end_buf)
3383 {
3384 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
3385 struct iw_event iwe;
3386
3387 if (time_after(jiffies,
3388 bss->last_update + IEEE80211_SCAN_RESULT_EXPIRE))
3389 return current_ev;
3390
3391 if (!(local->enabled_modes & (1 << bss->hw_mode)))
3392 return current_ev;
3393
3394 memset(&iwe, 0, sizeof(iwe));
3395 iwe.cmd = SIOCGIWAP;
3396 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
3397 memcpy(iwe.u.ap_addr.sa_data, bss->bssid, ETH_ALEN);
3398 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
3399 IW_EV_ADDR_LEN);
3400
3401 memset(&iwe, 0, sizeof(iwe));
3402 iwe.cmd = SIOCGIWESSID;
3403 iwe.u.data.length = bss->ssid_len;
3404 iwe.u.data.flags = 1;
3405 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe,
3406 bss->ssid);
3407
3408 if (bss->capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS)) {
3409 memset(&iwe, 0, sizeof(iwe));
3410 iwe.cmd = SIOCGIWMODE;
3411 if (bss->capability & WLAN_CAPABILITY_ESS)
3412 iwe.u.mode = IW_MODE_MASTER;
3413 else
3414 iwe.u.mode = IW_MODE_ADHOC;
3415 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
3416 IW_EV_UINT_LEN);
3417 }
3418
3419 memset(&iwe, 0, sizeof(iwe));
3420 iwe.cmd = SIOCGIWFREQ;
3421 iwe.u.freq.m = bss->channel;
3422 iwe.u.freq.e = 0;
3423 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
3424 IW_EV_FREQ_LEN);
3425 iwe.u.freq.m = bss->freq * 100000;
3426 iwe.u.freq.e = 1;
3427 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
3428 IW_EV_FREQ_LEN);
3429
3430 memset(&iwe, 0, sizeof(iwe));
3431 iwe.cmd = IWEVQUAL;
3432 iwe.u.qual.qual = bss->signal;
3433 iwe.u.qual.level = bss->rssi;
3434 iwe.u.qual.noise = bss->noise;
3435 iwe.u.qual.updated = local->wstats_flags;
3436 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
3437 IW_EV_QUAL_LEN);
3438
3439 memset(&iwe, 0, sizeof(iwe));
3440 iwe.cmd = SIOCGIWENCODE;
3441 if (bss->capability & WLAN_CAPABILITY_PRIVACY)
3442 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
3443 else
3444 iwe.u.data.flags = IW_ENCODE_DISABLED;
3445 iwe.u.data.length = 0;
3446 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, "");
3447
3448 if (bss && bss->wpa_ie) {
3449 memset(&iwe, 0, sizeof(iwe));
3450 iwe.cmd = IWEVGENIE;
3451 iwe.u.data.length = bss->wpa_ie_len;
3452 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe,
3453 bss->wpa_ie);
3454 }
3455
3456 if (bss && bss->rsn_ie) {
3457 memset(&iwe, 0, sizeof(iwe));
3458 iwe.cmd = IWEVGENIE;
3459 iwe.u.data.length = bss->rsn_ie_len;
3460 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe,
3461 bss->rsn_ie);
3462 }
3463
3464 if (bss && bss->supp_rates_len > 0) {
3465 /* display all supported rates in readable format */
3466 char *p = current_ev + IW_EV_LCP_LEN;
3467 int i;
3468
3469 memset(&iwe, 0, sizeof(iwe));
3470 iwe.cmd = SIOCGIWRATE;
3471 /* Those two flags are ignored... */
3472 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
3473
3474 for (i = 0; i < bss->supp_rates_len; i++) {
3475 iwe.u.bitrate.value = ((bss->supp_rates[i] &
3476 0x7f) * 500000);
3477 p = iwe_stream_add_value(current_ev, p,
3478 end_buf, &iwe, IW_EV_PARAM_LEN);
3479 }
3480 current_ev = p;
3481 }
3482
3483 if (bss) {
3484 char *buf;
3485 buf = kmalloc(30, GFP_ATOMIC);
3486 if (buf) {
3487 memset(&iwe, 0, sizeof(iwe));
3488 iwe.cmd = IWEVCUSTOM;
3489 sprintf(buf, "tsf=%016llx", (unsigned long long)(bss->timestamp));
3490 iwe.u.data.length = strlen(buf);
3491 current_ev = iwe_stream_add_point(current_ev, end_buf,
3492 &iwe, buf);
3493 kfree(buf);
3494 }
3495 }
3496
3497 return current_ev;
3498 }
3499
3500
3501 int ieee80211_sta_scan_results(struct net_device *dev, char *buf, size_t len)
3502 {
3503 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
3504 char *current_ev = buf;
3505 char *end_buf = buf + len;
3506 struct ieee80211_sta_bss *bss;
3507
3508 spin_lock_bh(&local->sta_bss_lock);
3509 list_for_each_entry(bss, &local->sta_bss_list, list) {
3510 if (buf + len - current_ev <= IW_EV_ADDR_LEN) {
3511 spin_unlock_bh(&local->sta_bss_lock);
3512 return -E2BIG;
3513 }
3514 current_ev = ieee80211_sta_scan_result(dev, bss, current_ev,
3515 end_buf);
3516 }
3517 spin_unlock_bh(&local->sta_bss_lock);
3518 return current_ev - buf;
3519 }
3520
3521
3522 int ieee80211_sta_set_extra_ie(struct net_device *dev, char *ie, size_t len)
3523 {
3524 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3525 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
3526 kfree(ifsta->extra_ie);
3527 if (len == 0) {
3528 ifsta->extra_ie = NULL;
3529 ifsta->extra_ie_len = 0;
3530 return 0;
3531 }
3532 ifsta->extra_ie = kmalloc(len, GFP_KERNEL);
3533 if (!ifsta->extra_ie) {
3534 ifsta->extra_ie_len = 0;
3535 return -ENOMEM;
3536 }
3537 memcpy(ifsta->extra_ie, ie, len);
3538 ifsta->extra_ie_len = len;
3539 return 0;
3540 }
3541
3542
3543 struct sta_info * ieee80211_ibss_add_sta(struct net_device *dev,
3544 struct sk_buff *skb, u8 *bssid,
3545 u8 *addr)
3546 {
3547 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
3548 struct sta_info *sta;
3549 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3550 DECLARE_MAC_BUF(mac);
3551
3552 /* TODO: Could consider removing the least recently used entry and
3553 * allow new one to be added. */
3554 if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
3555 if (net_ratelimit()) {
3556 printk(KERN_DEBUG "%s: No room for a new IBSS STA "
3557 "entry %s\n", dev->name, print_mac(mac, addr));
3558 }
3559 return NULL;
3560 }
3561
3562 printk(KERN_DEBUG "%s: Adding new IBSS station %s (dev=%s)\n",
3563 wiphy_name(local->hw.wiphy), print_mac(mac, addr), dev->name);
3564
3565 sta = sta_info_add(local, dev, addr, GFP_ATOMIC);
3566 if (!sta)
3567 return NULL;
3568
3569 sta->supp_rates = sdata->u.sta.supp_rates_bits;
3570
3571 rate_control_rate_init(sta, local);
3572
3573 return sta; /* caller will call sta_info_put() */
3574 }
3575
3576
3577 int ieee80211_sta_deauthenticate(struct net_device *dev, u16 reason)
3578 {
3579 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3580 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
3581
3582 printk(KERN_DEBUG "%s: deauthenticate(reason=%d)\n",
3583 dev->name, reason);
3584
3585 if (sdata->vif.type != IEEE80211_IF_TYPE_STA &&
3586 sdata->vif.type != IEEE80211_IF_TYPE_IBSS)
3587 return -EINVAL;
3588
3589 ieee80211_send_deauth(dev, ifsta, reason);
3590 ieee80211_set_disassoc(dev, ifsta, 1);
3591 return 0;
3592 }
3593
3594
3595 int ieee80211_sta_disassociate(struct net_device *dev, u16 reason)
3596 {
3597 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3598 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
3599
3600 printk(KERN_DEBUG "%s: disassociate(reason=%d)\n",
3601 dev->name, reason);
3602
3603 if (sdata->vif.type != IEEE80211_IF_TYPE_STA)
3604 return -EINVAL;
3605
3606 if (!(ifsta->flags & IEEE80211_STA_ASSOCIATED))
3607 return -1;
3608
3609 ieee80211_send_disassoc(dev, ifsta, reason);
3610 ieee80211_set_disassoc(dev, ifsta, 0);
3611 return 0;
3612 }
WRT350N Kernel Patches