]>
Commit | Line | Data |
---|---|---|
0a51b27e | 1 | /* |
5484e237 JB |
2 | * Scanning implementation |
3 | * | |
0a51b27e JB |
4 | * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi> |
5 | * Copyright 2004, Instant802 Networks, Inc. | |
6 | * Copyright 2005, Devicescape Software, Inc. | |
7 | * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> | |
8 | * Copyright 2007, Michael Wu <flamingice@sourmilk.net> | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License version 2 as | |
12 | * published by the Free Software Foundation. | |
13 | */ | |
14 | ||
5484e237 JB |
15 | /* TODO: |
16 | * order BSS list by RSSI(?) ("quality of AP") | |
17 | * scan result table filtering (by capability (privacy, IBSS/BSS, WPA/RSN IE, | |
18 | * SSID) | |
19 | */ | |
20 | ||
0a51b27e JB |
21 | #include <linux/wireless.h> |
22 | #include <linux/if_arp.h> | |
23 | #include <net/mac80211.h> | |
24 | #include <net/iw_handler.h> | |
25 | ||
26 | #include "ieee80211_i.h" | |
5484e237 | 27 | #include "mesh.h" |
0a51b27e JB |
28 | |
29 | #define IEEE80211_PROBE_DELAY (HZ / 33) | |
30 | #define IEEE80211_CHANNEL_TIME (HZ / 33) | |
31 | #define IEEE80211_PASSIVE_CHANNEL_TIME (HZ / 5) | |
32 | ||
5484e237 JB |
33 | void ieee80211_rx_bss_list_init(struct ieee80211_local *local) |
34 | { | |
35 | spin_lock_init(&local->sta_bss_lock); | |
36 | INIT_LIST_HEAD(&local->sta_bss_list); | |
37 | } | |
38 | ||
39 | void ieee80211_rx_bss_list_deinit(struct ieee80211_local *local) | |
40 | { | |
41 | struct ieee80211_sta_bss *bss, *tmp; | |
42 | ||
43 | list_for_each_entry_safe(bss, tmp, &local->sta_bss_list, list) | |
44 | ieee80211_rx_bss_put(local, bss); | |
45 | } | |
46 | ||
47 | struct ieee80211_sta_bss * | |
48 | ieee80211_rx_bss_get(struct ieee80211_local *local, u8 *bssid, int freq, | |
49 | u8 *ssid, u8 ssid_len) | |
50 | { | |
51 | struct ieee80211_sta_bss *bss; | |
52 | ||
53 | spin_lock_bh(&local->sta_bss_lock); | |
54 | bss = local->sta_bss_hash[STA_HASH(bssid)]; | |
55 | while (bss) { | |
56 | if (!bss_mesh_cfg(bss) && | |
57 | !memcmp(bss->bssid, bssid, ETH_ALEN) && | |
58 | bss->freq == freq && | |
59 | bss->ssid_len == ssid_len && | |
60 | (ssid_len == 0 || !memcmp(bss->ssid, ssid, ssid_len))) { | |
61 | atomic_inc(&bss->users); | |
62 | break; | |
63 | } | |
64 | bss = bss->hnext; | |
65 | } | |
66 | spin_unlock_bh(&local->sta_bss_lock); | |
67 | return bss; | |
68 | } | |
69 | ||
70 | /* Caller must hold local->sta_bss_lock */ | |
71 | static void __ieee80211_rx_bss_hash_add(struct ieee80211_local *local, | |
72 | struct ieee80211_sta_bss *bss) | |
73 | { | |
74 | u8 hash_idx; | |
75 | ||
76 | if (bss_mesh_cfg(bss)) | |
77 | hash_idx = mesh_id_hash(bss_mesh_id(bss), | |
78 | bss_mesh_id_len(bss)); | |
79 | else | |
80 | hash_idx = STA_HASH(bss->bssid); | |
81 | ||
82 | bss->hnext = local->sta_bss_hash[hash_idx]; | |
83 | local->sta_bss_hash[hash_idx] = bss; | |
84 | } | |
85 | ||
86 | /* Caller must hold local->sta_bss_lock */ | |
87 | static void __ieee80211_rx_bss_hash_del(struct ieee80211_local *local, | |
88 | struct ieee80211_sta_bss *bss) | |
89 | { | |
90 | struct ieee80211_sta_bss *b, *prev = NULL; | |
91 | b = local->sta_bss_hash[STA_HASH(bss->bssid)]; | |
92 | while (b) { | |
93 | if (b == bss) { | |
94 | if (!prev) | |
95 | local->sta_bss_hash[STA_HASH(bss->bssid)] = | |
96 | bss->hnext; | |
97 | else | |
98 | prev->hnext = bss->hnext; | |
99 | break; | |
100 | } | |
101 | prev = b; | |
102 | b = b->hnext; | |
103 | } | |
104 | } | |
105 | ||
106 | struct ieee80211_sta_bss * | |
107 | ieee80211_rx_bss_add(struct ieee80211_local *local, u8 *bssid, int freq, | |
108 | u8 *ssid, u8 ssid_len) | |
109 | { | |
110 | struct ieee80211_sta_bss *bss; | |
111 | ||
112 | bss = kzalloc(sizeof(*bss), GFP_ATOMIC); | |
113 | if (!bss) | |
114 | return NULL; | |
115 | atomic_set(&bss->users, 2); | |
116 | memcpy(bss->bssid, bssid, ETH_ALEN); | |
117 | bss->freq = freq; | |
118 | if (ssid && ssid_len <= IEEE80211_MAX_SSID_LEN) { | |
119 | memcpy(bss->ssid, ssid, ssid_len); | |
120 | bss->ssid_len = ssid_len; | |
121 | } | |
122 | ||
123 | spin_lock_bh(&local->sta_bss_lock); | |
124 | /* TODO: order by RSSI? */ | |
125 | list_add_tail(&bss->list, &local->sta_bss_list); | |
126 | __ieee80211_rx_bss_hash_add(local, bss); | |
127 | spin_unlock_bh(&local->sta_bss_lock); | |
128 | return bss; | |
129 | } | |
130 | ||
131 | #ifdef CONFIG_MAC80211_MESH | |
132 | static struct ieee80211_sta_bss * | |
133 | ieee80211_rx_mesh_bss_get(struct ieee80211_local *local, u8 *mesh_id, int mesh_id_len, | |
134 | u8 *mesh_cfg, int freq) | |
135 | { | |
136 | struct ieee80211_sta_bss *bss; | |
137 | ||
138 | spin_lock_bh(&local->sta_bss_lock); | |
139 | bss = local->sta_bss_hash[mesh_id_hash(mesh_id, mesh_id_len)]; | |
140 | while (bss) { | |
141 | if (bss_mesh_cfg(bss) && | |
142 | !memcmp(bss_mesh_cfg(bss), mesh_cfg, MESH_CFG_CMP_LEN) && | |
143 | bss->freq == freq && | |
144 | mesh_id_len == bss->mesh_id_len && | |
145 | (mesh_id_len == 0 || !memcmp(bss->mesh_id, mesh_id, | |
146 | mesh_id_len))) { | |
147 | atomic_inc(&bss->users); | |
148 | break; | |
149 | } | |
150 | bss = bss->hnext; | |
151 | } | |
152 | spin_unlock_bh(&local->sta_bss_lock); | |
153 | return bss; | |
154 | } | |
155 | ||
156 | static struct ieee80211_sta_bss * | |
157 | ieee80211_rx_mesh_bss_add(struct ieee80211_local *local, u8 *mesh_id, int mesh_id_len, | |
158 | u8 *mesh_cfg, int mesh_config_len, int freq) | |
159 | { | |
160 | struct ieee80211_sta_bss *bss; | |
161 | ||
162 | if (mesh_config_len != MESH_CFG_LEN) | |
163 | return NULL; | |
164 | ||
165 | bss = kzalloc(sizeof(*bss), GFP_ATOMIC); | |
166 | if (!bss) | |
167 | return NULL; | |
168 | ||
169 | bss->mesh_cfg = kmalloc(MESH_CFG_CMP_LEN, GFP_ATOMIC); | |
170 | if (!bss->mesh_cfg) { | |
171 | kfree(bss); | |
172 | return NULL; | |
173 | } | |
174 | ||
175 | if (mesh_id_len && mesh_id_len <= IEEE80211_MAX_MESH_ID_LEN) { | |
176 | bss->mesh_id = kmalloc(mesh_id_len, GFP_ATOMIC); | |
177 | if (!bss->mesh_id) { | |
178 | kfree(bss->mesh_cfg); | |
179 | kfree(bss); | |
180 | return NULL; | |
181 | } | |
182 | memcpy(bss->mesh_id, mesh_id, mesh_id_len); | |
183 | } | |
184 | ||
185 | atomic_set(&bss->users, 2); | |
186 | memcpy(bss->mesh_cfg, mesh_cfg, MESH_CFG_CMP_LEN); | |
187 | bss->mesh_id_len = mesh_id_len; | |
188 | bss->freq = freq; | |
189 | spin_lock_bh(&local->sta_bss_lock); | |
190 | /* TODO: order by RSSI? */ | |
191 | list_add_tail(&bss->list, &local->sta_bss_list); | |
192 | __ieee80211_rx_bss_hash_add(local, bss); | |
193 | spin_unlock_bh(&local->sta_bss_lock); | |
194 | return bss; | |
195 | } | |
196 | #endif | |
197 | ||
198 | static void ieee80211_rx_bss_free(struct ieee80211_sta_bss *bss) | |
199 | { | |
200 | kfree(bss->ies); | |
201 | kfree(bss_mesh_id(bss)); | |
202 | kfree(bss_mesh_cfg(bss)); | |
203 | kfree(bss); | |
204 | } | |
205 | ||
206 | void ieee80211_rx_bss_put(struct ieee80211_local *local, | |
207 | struct ieee80211_sta_bss *bss) | |
208 | { | |
209 | local_bh_disable(); | |
210 | if (!atomic_dec_and_lock(&bss->users, &local->sta_bss_lock)) { | |
211 | local_bh_enable(); | |
212 | return; | |
213 | } | |
214 | ||
215 | __ieee80211_rx_bss_hash_del(local, bss); | |
216 | list_del(&bss->list); | |
217 | spin_unlock_bh(&local->sta_bss_lock); | |
218 | ieee80211_rx_bss_free(bss); | |
219 | } | |
220 | ||
221 | struct ieee80211_sta_bss * | |
222 | ieee80211_bss_info_update(struct ieee80211_local *local, | |
223 | struct ieee80211_rx_status *rx_status, | |
224 | struct ieee80211_mgmt *mgmt, | |
225 | size_t len, | |
226 | struct ieee802_11_elems *elems, | |
227 | int freq, bool beacon) | |
228 | { | |
229 | struct ieee80211_sta_bss *bss; | |
230 | int clen; | |
231 | ||
232 | #ifdef CONFIG_MAC80211_MESH | |
233 | if (elems->mesh_config) | |
234 | bss = ieee80211_rx_mesh_bss_get(local, elems->mesh_id, | |
235 | elems->mesh_id_len, elems->mesh_config, freq); | |
236 | else | |
237 | #endif | |
238 | bss = ieee80211_rx_bss_get(local, mgmt->bssid, freq, | |
239 | elems->ssid, elems->ssid_len); | |
240 | if (!bss) { | |
241 | #ifdef CONFIG_MAC80211_MESH | |
242 | if (elems->mesh_config) | |
243 | bss = ieee80211_rx_mesh_bss_add(local, elems->mesh_id, | |
244 | elems->mesh_id_len, elems->mesh_config, | |
245 | elems->mesh_config_len, freq); | |
246 | else | |
247 | #endif | |
248 | bss = ieee80211_rx_bss_add(local, mgmt->bssid, freq, | |
249 | elems->ssid, elems->ssid_len); | |
250 | if (!bss) | |
251 | return NULL; | |
252 | } else { | |
253 | #if 0 | |
254 | /* TODO: order by RSSI? */ | |
255 | spin_lock_bh(&local->sta_bss_lock); | |
256 | list_move_tail(&bss->list, &local->sta_bss_list); | |
257 | spin_unlock_bh(&local->sta_bss_lock); | |
258 | #endif | |
259 | } | |
260 | ||
261 | /* save the ERP value so that it is available at association time */ | |
262 | if (elems->erp_info && elems->erp_info_len >= 1) { | |
263 | bss->erp_value = elems->erp_info[0]; | |
264 | bss->has_erp_value = 1; | |
265 | } | |
266 | ||
267 | bss->beacon_int = le16_to_cpu(mgmt->u.beacon.beacon_int); | |
268 | bss->capability = le16_to_cpu(mgmt->u.beacon.capab_info); | |
269 | ||
270 | if (elems->tim) { | |
271 | struct ieee80211_tim_ie *tim_ie = | |
272 | (struct ieee80211_tim_ie *)elems->tim; | |
273 | bss->dtim_period = tim_ie->dtim_period; | |
274 | } | |
275 | ||
276 | /* set default value for buggy APs */ | |
277 | if (!elems->tim || bss->dtim_period == 0) | |
278 | bss->dtim_period = 1; | |
279 | ||
280 | bss->supp_rates_len = 0; | |
281 | if (elems->supp_rates) { | |
282 | clen = IEEE80211_MAX_SUPP_RATES - bss->supp_rates_len; | |
283 | if (clen > elems->supp_rates_len) | |
284 | clen = elems->supp_rates_len; | |
285 | memcpy(&bss->supp_rates[bss->supp_rates_len], elems->supp_rates, | |
286 | clen); | |
287 | bss->supp_rates_len += clen; | |
288 | } | |
289 | if (elems->ext_supp_rates) { | |
290 | clen = IEEE80211_MAX_SUPP_RATES - bss->supp_rates_len; | |
291 | if (clen > elems->ext_supp_rates_len) | |
292 | clen = elems->ext_supp_rates_len; | |
293 | memcpy(&bss->supp_rates[bss->supp_rates_len], | |
294 | elems->ext_supp_rates, clen); | |
295 | bss->supp_rates_len += clen; | |
296 | } | |
297 | ||
298 | bss->band = rx_status->band; | |
299 | ||
300 | bss->timestamp = le64_to_cpu(mgmt->u.beacon.timestamp); | |
301 | bss->last_update = jiffies; | |
302 | bss->signal = rx_status->signal; | |
303 | bss->noise = rx_status->noise; | |
304 | bss->qual = rx_status->qual; | |
305 | bss->wmm_used = elems->wmm_param || elems->wmm_info; | |
306 | ||
307 | if (!beacon) | |
308 | bss->last_probe_resp = jiffies; | |
309 | ||
310 | /* | |
311 | * For probe responses, or if we don't have any information yet, | |
312 | * use the IEs from the beacon. | |
313 | */ | |
314 | if (!bss->ies || !beacon) { | |
315 | if (bss->ies == NULL || bss->ies_len < elems->total_len) { | |
316 | kfree(bss->ies); | |
317 | bss->ies = kmalloc(elems->total_len, GFP_ATOMIC); | |
318 | } | |
319 | if (bss->ies) { | |
320 | memcpy(bss->ies, elems->ie_start, elems->total_len); | |
321 | bss->ies_len = elems->total_len; | |
322 | } else | |
323 | bss->ies_len = 0; | |
324 | } | |
325 | ||
326 | return bss; | |
327 | } | |
0a51b27e | 328 | |
98c8fccf JB |
329 | ieee80211_rx_result |
330 | ieee80211_sta_rx_scan(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb, | |
331 | struct ieee80211_rx_status *rx_status) | |
332 | { | |
333 | struct ieee80211_mgmt *mgmt; | |
334 | struct ieee80211_sta_bss *bss; | |
335 | u8 *elements; | |
336 | struct ieee80211_channel *channel; | |
337 | size_t baselen; | |
338 | int freq; | |
339 | __le16 fc; | |
340 | bool presp, beacon = false; | |
341 | struct ieee802_11_elems elems; | |
342 | ||
343 | if (skb->len < 2) | |
344 | return RX_DROP_UNUSABLE; | |
345 | ||
346 | mgmt = (struct ieee80211_mgmt *) skb->data; | |
347 | fc = mgmt->frame_control; | |
348 | ||
349 | if (ieee80211_is_ctl(fc)) | |
350 | return RX_CONTINUE; | |
351 | ||
352 | if (skb->len < 24) | |
353 | return RX_DROP_MONITOR; | |
354 | ||
355 | presp = ieee80211_is_probe_resp(fc); | |
356 | if (presp) { | |
357 | /* ignore ProbeResp to foreign address */ | |
358 | if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN)) | |
359 | return RX_DROP_MONITOR; | |
360 | ||
361 | presp = true; | |
362 | elements = mgmt->u.probe_resp.variable; | |
363 | baselen = offsetof(struct ieee80211_mgmt, u.probe_resp.variable); | |
364 | } else { | |
365 | beacon = ieee80211_is_beacon(fc); | |
366 | baselen = offsetof(struct ieee80211_mgmt, u.beacon.variable); | |
367 | elements = mgmt->u.beacon.variable; | |
368 | } | |
369 | ||
370 | if (!presp && !beacon) | |
371 | return RX_CONTINUE; | |
372 | ||
373 | if (baselen > skb->len) | |
374 | return RX_DROP_MONITOR; | |
375 | ||
376 | ieee802_11_parse_elems(elements, skb->len - baselen, &elems); | |
377 | ||
378 | if (elems.ds_params && elems.ds_params_len == 1) | |
379 | freq = ieee80211_channel_to_frequency(elems.ds_params[0]); | |
380 | else | |
381 | freq = rx_status->freq; | |
382 | ||
383 | channel = ieee80211_get_channel(sdata->local->hw.wiphy, freq); | |
384 | ||
385 | if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) | |
386 | return RX_DROP_MONITOR; | |
387 | ||
388 | bss = ieee80211_bss_info_update(sdata->local, rx_status, | |
389 | mgmt, skb->len, &elems, | |
390 | freq, beacon); | |
391 | ieee80211_rx_bss_put(sdata->local, bss); | |
392 | ||
393 | dev_kfree_skb(skb); | |
394 | return RX_QUEUED; | |
395 | } | |
396 | ||
0a51b27e JB |
397 | static void ieee80211_send_nullfunc(struct ieee80211_local *local, |
398 | struct ieee80211_sub_if_data *sdata, | |
399 | int powersave) | |
400 | { | |
401 | struct sk_buff *skb; | |
402 | struct ieee80211_hdr *nullfunc; | |
403 | __le16 fc; | |
404 | ||
405 | skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24); | |
406 | if (!skb) { | |
407 | printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc " | |
408 | "frame\n", sdata->dev->name); | |
409 | return; | |
410 | } | |
411 | skb_reserve(skb, local->hw.extra_tx_headroom); | |
412 | ||
413 | nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24); | |
414 | memset(nullfunc, 0, 24); | |
415 | fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC | | |
416 | IEEE80211_FCTL_TODS); | |
417 | if (powersave) | |
418 | fc |= cpu_to_le16(IEEE80211_FCTL_PM); | |
419 | nullfunc->frame_control = fc; | |
420 | memcpy(nullfunc->addr1, sdata->u.sta.bssid, ETH_ALEN); | |
421 | memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN); | |
422 | memcpy(nullfunc->addr3, sdata->u.sta.bssid, ETH_ALEN); | |
423 | ||
424 | ieee80211_sta_tx(sdata, skb, 0); | |
425 | } | |
426 | ||
427 | static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata) | |
428 | { | |
429 | if (sdata->vif.type == IEEE80211_IF_TYPE_STA || | |
430 | ieee80211_vif_is_mesh(&sdata->vif)) | |
431 | ieee80211_sta_timer((unsigned long)sdata); | |
432 | } | |
433 | ||
434 | void ieee80211_scan_completed(struct ieee80211_hw *hw) | |
435 | { | |
436 | struct ieee80211_local *local = hw_to_local(hw); | |
437 | struct ieee80211_sub_if_data *sdata; | |
438 | union iwreq_data wrqu; | |
439 | ||
440 | local->last_scan_completed = jiffies; | |
441 | memset(&wrqu, 0, sizeof(wrqu)); | |
442 | wireless_send_event(local->scan_sdata->dev, SIOCGIWSCAN, &wrqu, NULL); | |
443 | ||
444 | if (local->sta_hw_scanning) { | |
445 | local->sta_hw_scanning = 0; | |
446 | if (ieee80211_hw_config(local)) | |
447 | printk(KERN_DEBUG "%s: failed to restore operational " | |
448 | "channel after scan\n", wiphy_name(local->hw.wiphy)); | |
449 | /* Restart STA timer for HW scan case */ | |
450 | rcu_read_lock(); | |
451 | list_for_each_entry_rcu(sdata, &local->interfaces, list) | |
452 | ieee80211_restart_sta_timer(sdata); | |
453 | rcu_read_unlock(); | |
454 | ||
455 | goto done; | |
456 | } | |
457 | ||
458 | local->sta_sw_scanning = 0; | |
459 | if (ieee80211_hw_config(local)) | |
460 | printk(KERN_DEBUG "%s: failed to restore operational " | |
461 | "channel after scan\n", wiphy_name(local->hw.wiphy)); | |
462 | ||
463 | ||
464 | netif_tx_lock_bh(local->mdev); | |
465 | netif_addr_lock(local->mdev); | |
466 | local->filter_flags &= ~FIF_BCN_PRBRESP_PROMISC; | |
467 | local->ops->configure_filter(local_to_hw(local), | |
468 | FIF_BCN_PRBRESP_PROMISC, | |
469 | &local->filter_flags, | |
470 | local->mdev->mc_count, | |
471 | local->mdev->mc_list); | |
472 | ||
473 | netif_addr_unlock(local->mdev); | |
474 | netif_tx_unlock_bh(local->mdev); | |
475 | ||
476 | rcu_read_lock(); | |
477 | list_for_each_entry_rcu(sdata, &local->interfaces, list) { | |
478 | /* Tell AP we're back */ | |
479 | if (sdata->vif.type == IEEE80211_IF_TYPE_STA) { | |
480 | if (sdata->u.sta.flags & IEEE80211_STA_ASSOCIATED) { | |
481 | ieee80211_send_nullfunc(local, sdata, 0); | |
482 | netif_tx_wake_all_queues(sdata->dev); | |
483 | } | |
484 | } else | |
485 | netif_tx_wake_all_queues(sdata->dev); | |
486 | ||
487 | ieee80211_restart_sta_timer(sdata); | |
488 | } | |
489 | rcu_read_unlock(); | |
490 | ||
491 | done: | |
492 | ieee80211_mlme_notify_scan_completed(local); | |
493 | } | |
494 | EXPORT_SYMBOL(ieee80211_scan_completed); | |
495 | ||
496 | ||
497 | void ieee80211_sta_scan_work(struct work_struct *work) | |
498 | { | |
499 | struct ieee80211_local *local = | |
500 | container_of(work, struct ieee80211_local, scan_work.work); | |
501 | struct ieee80211_sub_if_data *sdata = local->scan_sdata; | |
502 | struct ieee80211_supported_band *sband; | |
503 | struct ieee80211_channel *chan; | |
504 | int skip; | |
505 | unsigned long next_delay = 0; | |
506 | ||
507 | if (!local->sta_sw_scanning) | |
508 | return; | |
509 | ||
510 | switch (local->scan_state) { | |
511 | case SCAN_SET_CHANNEL: | |
512 | /* | |
513 | * Get current scan band. scan_band may be IEEE80211_NUM_BANDS | |
514 | * after we successfully scanned the last channel of the last | |
515 | * band (and the last band is supported by the hw) | |
516 | */ | |
517 | if (local->scan_band < IEEE80211_NUM_BANDS) | |
518 | sband = local->hw.wiphy->bands[local->scan_band]; | |
519 | else | |
520 | sband = NULL; | |
521 | ||
522 | /* | |
523 | * If we are at an unsupported band and have more bands | |
524 | * left to scan, advance to the next supported one. | |
525 | */ | |
526 | while (!sband && local->scan_band < IEEE80211_NUM_BANDS - 1) { | |
527 | local->scan_band++; | |
528 | sband = local->hw.wiphy->bands[local->scan_band]; | |
529 | local->scan_channel_idx = 0; | |
530 | } | |
531 | ||
532 | /* if no more bands/channels left, complete scan */ | |
533 | if (!sband || local->scan_channel_idx >= sband->n_channels) { | |
534 | ieee80211_scan_completed(local_to_hw(local)); | |
535 | return; | |
536 | } | |
537 | skip = 0; | |
538 | chan = &sband->channels[local->scan_channel_idx]; | |
539 | ||
540 | if (chan->flags & IEEE80211_CHAN_DISABLED || | |
541 | (sdata->vif.type == IEEE80211_IF_TYPE_IBSS && | |
542 | chan->flags & IEEE80211_CHAN_NO_IBSS)) | |
543 | skip = 1; | |
544 | ||
545 | if (!skip) { | |
546 | local->scan_channel = chan; | |
547 | if (ieee80211_hw_config(local)) { | |
548 | printk(KERN_DEBUG "%s: failed to set freq to " | |
549 | "%d MHz for scan\n", wiphy_name(local->hw.wiphy), | |
550 | chan->center_freq); | |
551 | skip = 1; | |
552 | } | |
553 | } | |
554 | ||
555 | /* advance state machine to next channel/band */ | |
556 | local->scan_channel_idx++; | |
557 | if (local->scan_channel_idx >= sband->n_channels) { | |
558 | /* | |
559 | * scan_band may end up == IEEE80211_NUM_BANDS, but | |
560 | * we'll catch that case above and complete the scan | |
561 | * if that is the case. | |
562 | */ | |
563 | local->scan_band++; | |
564 | local->scan_channel_idx = 0; | |
565 | } | |
566 | ||
567 | if (skip) | |
568 | break; | |
569 | ||
570 | next_delay = IEEE80211_PROBE_DELAY + | |
571 | usecs_to_jiffies(local->hw.channel_change_time); | |
572 | local->scan_state = SCAN_SEND_PROBE; | |
573 | break; | |
574 | case SCAN_SEND_PROBE: | |
575 | next_delay = IEEE80211_PASSIVE_CHANNEL_TIME; | |
576 | local->scan_state = SCAN_SET_CHANNEL; | |
577 | ||
578 | if (local->scan_channel->flags & IEEE80211_CHAN_PASSIVE_SCAN) | |
579 | break; | |
580 | ieee80211_send_probe_req(sdata, NULL, local->scan_ssid, | |
581 | local->scan_ssid_len); | |
582 | next_delay = IEEE80211_CHANNEL_TIME; | |
583 | break; | |
584 | } | |
585 | ||
586 | if (local->sta_sw_scanning) | |
587 | queue_delayed_work(local->hw.workqueue, &local->scan_work, | |
588 | next_delay); | |
589 | } | |
590 | ||
591 | ||
592 | int ieee80211_sta_start_scan(struct ieee80211_sub_if_data *scan_sdata, | |
593 | u8 *ssid, size_t ssid_len) | |
594 | { | |
595 | struct ieee80211_local *local = scan_sdata->local; | |
596 | struct ieee80211_sub_if_data *sdata; | |
597 | ||
598 | if (ssid_len > IEEE80211_MAX_SSID_LEN) | |
599 | return -EINVAL; | |
600 | ||
601 | /* MLME-SCAN.request (page 118) page 144 (11.1.3.1) | |
602 | * BSSType: INFRASTRUCTURE, INDEPENDENT, ANY_BSS | |
603 | * BSSID: MACAddress | |
604 | * SSID | |
605 | * ScanType: ACTIVE, PASSIVE | |
606 | * ProbeDelay: delay (in microseconds) to be used prior to transmitting | |
607 | * a Probe frame during active scanning | |
608 | * ChannelList | |
609 | * MinChannelTime (>= ProbeDelay), in TU | |
610 | * MaxChannelTime: (>= MinChannelTime), in TU | |
611 | */ | |
612 | ||
613 | /* MLME-SCAN.confirm | |
614 | * BSSDescriptionSet | |
615 | * ResultCode: SUCCESS, INVALID_PARAMETERS | |
616 | */ | |
617 | ||
618 | if (local->sta_sw_scanning || local->sta_hw_scanning) { | |
619 | if (local->scan_sdata == scan_sdata) | |
620 | return 0; | |
621 | return -EBUSY; | |
622 | } | |
623 | ||
624 | if (local->ops->hw_scan) { | |
625 | int rc = local->ops->hw_scan(local_to_hw(local), | |
626 | ssid, ssid_len); | |
627 | if (!rc) { | |
628 | local->sta_hw_scanning = 1; | |
629 | local->scan_sdata = scan_sdata; | |
630 | } | |
631 | return rc; | |
632 | } | |
633 | ||
634 | local->sta_sw_scanning = 1; | |
635 | ||
636 | rcu_read_lock(); | |
637 | list_for_each_entry_rcu(sdata, &local->interfaces, list) { | |
638 | if (sdata->vif.type == IEEE80211_IF_TYPE_STA) { | |
639 | if (sdata->u.sta.flags & IEEE80211_STA_ASSOCIATED) { | |
640 | netif_tx_stop_all_queues(sdata->dev); | |
641 | ieee80211_send_nullfunc(local, sdata, 1); | |
642 | } | |
643 | } else | |
644 | netif_tx_stop_all_queues(sdata->dev); | |
645 | } | |
646 | rcu_read_unlock(); | |
647 | ||
648 | if (ssid) { | |
649 | local->scan_ssid_len = ssid_len; | |
650 | memcpy(local->scan_ssid, ssid, ssid_len); | |
651 | } else | |
652 | local->scan_ssid_len = 0; | |
653 | local->scan_state = SCAN_SET_CHANNEL; | |
654 | local->scan_channel_idx = 0; | |
655 | local->scan_band = IEEE80211_BAND_2GHZ; | |
656 | local->scan_sdata = scan_sdata; | |
657 | ||
658 | netif_addr_lock_bh(local->mdev); | |
659 | local->filter_flags |= FIF_BCN_PRBRESP_PROMISC; | |
660 | local->ops->configure_filter(local_to_hw(local), | |
661 | FIF_BCN_PRBRESP_PROMISC, | |
662 | &local->filter_flags, | |
663 | local->mdev->mc_count, | |
664 | local->mdev->mc_list); | |
665 | netif_addr_unlock_bh(local->mdev); | |
666 | ||
667 | /* TODO: start scan as soon as all nullfunc frames are ACKed */ | |
668 | queue_delayed_work(local->hw.workqueue, &local->scan_work, | |
669 | IEEE80211_CHANNEL_TIME); | |
670 | ||
671 | return 0; | |
672 | } | |
673 | ||
674 | ||
675 | int ieee80211_sta_req_scan(struct ieee80211_sub_if_data *sdata, u8 *ssid, size_t ssid_len) | |
676 | { | |
677 | struct ieee80211_if_sta *ifsta = &sdata->u.sta; | |
678 | struct ieee80211_local *local = sdata->local; | |
679 | ||
680 | if (sdata->vif.type != IEEE80211_IF_TYPE_STA) | |
681 | return ieee80211_sta_start_scan(sdata, ssid, ssid_len); | |
682 | ||
683 | if (local->sta_sw_scanning || local->sta_hw_scanning) { | |
684 | if (local->scan_sdata == sdata) | |
685 | return 0; | |
686 | return -EBUSY; | |
687 | } | |
688 | ||
689 | ifsta->scan_ssid_len = ssid_len; | |
690 | if (ssid_len) | |
691 | memcpy(ifsta->scan_ssid, ssid, ssid_len); | |
692 | set_bit(IEEE80211_STA_REQ_SCAN, &ifsta->request); | |
693 | queue_work(local->hw.workqueue, &ifsta->work); | |
694 | return 0; | |
695 | } | |
696 | ||
697 | ||
698 | static void ieee80211_sta_add_scan_ies(struct iw_request_info *info, | |
699 | struct ieee80211_sta_bss *bss, | |
700 | char **current_ev, char *end_buf) | |
701 | { | |
702 | u8 *pos, *end, *next; | |
703 | struct iw_event iwe; | |
704 | ||
705 | if (bss == NULL || bss->ies == NULL) | |
706 | return; | |
707 | ||
708 | /* | |
709 | * If needed, fragment the IEs buffer (at IE boundaries) into short | |
710 | * enough fragments to fit into IW_GENERIC_IE_MAX octet messages. | |
711 | */ | |
712 | pos = bss->ies; | |
713 | end = pos + bss->ies_len; | |
714 | ||
715 | while (end - pos > IW_GENERIC_IE_MAX) { | |
716 | next = pos + 2 + pos[1]; | |
717 | while (next + 2 + next[1] - pos < IW_GENERIC_IE_MAX) | |
718 | next = next + 2 + next[1]; | |
719 | ||
720 | memset(&iwe, 0, sizeof(iwe)); | |
721 | iwe.cmd = IWEVGENIE; | |
722 | iwe.u.data.length = next - pos; | |
723 | *current_ev = iwe_stream_add_point(info, *current_ev, | |
724 | end_buf, &iwe, pos); | |
725 | ||
726 | pos = next; | |
727 | } | |
728 | ||
729 | if (end > pos) { | |
730 | memset(&iwe, 0, sizeof(iwe)); | |
731 | iwe.cmd = IWEVGENIE; | |
732 | iwe.u.data.length = end - pos; | |
733 | *current_ev = iwe_stream_add_point(info, *current_ev, | |
734 | end_buf, &iwe, pos); | |
735 | } | |
736 | } | |
737 | ||
738 | ||
739 | static char * | |
740 | ieee80211_sta_scan_result(struct ieee80211_local *local, | |
741 | struct iw_request_info *info, | |
742 | struct ieee80211_sta_bss *bss, | |
743 | char *current_ev, char *end_buf) | |
744 | { | |
745 | struct iw_event iwe; | |
746 | char *buf; | |
747 | ||
748 | if (time_after(jiffies, | |
749 | bss->last_update + IEEE80211_SCAN_RESULT_EXPIRE)) | |
750 | return current_ev; | |
751 | ||
752 | memset(&iwe, 0, sizeof(iwe)); | |
753 | iwe.cmd = SIOCGIWAP; | |
754 | iwe.u.ap_addr.sa_family = ARPHRD_ETHER; | |
755 | memcpy(iwe.u.ap_addr.sa_data, bss->bssid, ETH_ALEN); | |
756 | current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, | |
757 | IW_EV_ADDR_LEN); | |
758 | ||
759 | memset(&iwe, 0, sizeof(iwe)); | |
760 | iwe.cmd = SIOCGIWESSID; | |
761 | if (bss_mesh_cfg(bss)) { | |
762 | iwe.u.data.length = bss_mesh_id_len(bss); | |
763 | iwe.u.data.flags = 1; | |
764 | current_ev = iwe_stream_add_point(info, current_ev, end_buf, | |
765 | &iwe, bss_mesh_id(bss)); | |
766 | } else { | |
767 | iwe.u.data.length = bss->ssid_len; | |
768 | iwe.u.data.flags = 1; | |
769 | current_ev = iwe_stream_add_point(info, current_ev, end_buf, | |
770 | &iwe, bss->ssid); | |
771 | } | |
772 | ||
773 | if (bss->capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS) | |
774 | || bss_mesh_cfg(bss)) { | |
775 | memset(&iwe, 0, sizeof(iwe)); | |
776 | iwe.cmd = SIOCGIWMODE; | |
777 | if (bss_mesh_cfg(bss)) | |
778 | iwe.u.mode = IW_MODE_MESH; | |
779 | else if (bss->capability & WLAN_CAPABILITY_ESS) | |
780 | iwe.u.mode = IW_MODE_MASTER; | |
781 | else | |
782 | iwe.u.mode = IW_MODE_ADHOC; | |
783 | current_ev = iwe_stream_add_event(info, current_ev, end_buf, | |
784 | &iwe, IW_EV_UINT_LEN); | |
785 | } | |
786 | ||
787 | memset(&iwe, 0, sizeof(iwe)); | |
788 | iwe.cmd = SIOCGIWFREQ; | |
789 | iwe.u.freq.m = ieee80211_frequency_to_channel(bss->freq); | |
790 | iwe.u.freq.e = 0; | |
791 | current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, | |
792 | IW_EV_FREQ_LEN); | |
793 | ||
794 | memset(&iwe, 0, sizeof(iwe)); | |
795 | iwe.cmd = SIOCGIWFREQ; | |
796 | iwe.u.freq.m = bss->freq; | |
797 | iwe.u.freq.e = 6; | |
798 | current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, | |
799 | IW_EV_FREQ_LEN); | |
800 | memset(&iwe, 0, sizeof(iwe)); | |
801 | iwe.cmd = IWEVQUAL; | |
802 | iwe.u.qual.qual = bss->qual; | |
803 | iwe.u.qual.level = bss->signal; | |
804 | iwe.u.qual.noise = bss->noise; | |
805 | iwe.u.qual.updated = local->wstats_flags; | |
806 | current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, | |
807 | IW_EV_QUAL_LEN); | |
808 | ||
809 | memset(&iwe, 0, sizeof(iwe)); | |
810 | iwe.cmd = SIOCGIWENCODE; | |
811 | if (bss->capability & WLAN_CAPABILITY_PRIVACY) | |
812 | iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY; | |
813 | else | |
814 | iwe.u.data.flags = IW_ENCODE_DISABLED; | |
815 | iwe.u.data.length = 0; | |
816 | current_ev = iwe_stream_add_point(info, current_ev, end_buf, | |
817 | &iwe, ""); | |
818 | ||
819 | ieee80211_sta_add_scan_ies(info, bss, ¤t_ev, end_buf); | |
820 | ||
821 | if (bss->supp_rates_len > 0) { | |
822 | /* display all supported rates in readable format */ | |
823 | char *p = current_ev + iwe_stream_lcp_len(info); | |
824 | int i; | |
825 | ||
826 | memset(&iwe, 0, sizeof(iwe)); | |
827 | iwe.cmd = SIOCGIWRATE; | |
828 | /* Those two flags are ignored... */ | |
829 | iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0; | |
830 | ||
831 | for (i = 0; i < bss->supp_rates_len; i++) { | |
832 | iwe.u.bitrate.value = ((bss->supp_rates[i] & | |
833 | 0x7f) * 500000); | |
834 | p = iwe_stream_add_value(info, current_ev, p, | |
835 | end_buf, &iwe, IW_EV_PARAM_LEN); | |
836 | } | |
837 | current_ev = p; | |
838 | } | |
839 | ||
840 | buf = kmalloc(30, GFP_ATOMIC); | |
841 | if (buf) { | |
842 | memset(&iwe, 0, sizeof(iwe)); | |
843 | iwe.cmd = IWEVCUSTOM; | |
844 | sprintf(buf, "tsf=%016llx", (unsigned long long)(bss->timestamp)); | |
845 | iwe.u.data.length = strlen(buf); | |
846 | current_ev = iwe_stream_add_point(info, current_ev, end_buf, | |
847 | &iwe, buf); | |
848 | memset(&iwe, 0, sizeof(iwe)); | |
849 | iwe.cmd = IWEVCUSTOM; | |
850 | sprintf(buf, " Last beacon: %dms ago", | |
851 | jiffies_to_msecs(jiffies - bss->last_update)); | |
852 | iwe.u.data.length = strlen(buf); | |
853 | current_ev = iwe_stream_add_point(info, current_ev, | |
854 | end_buf, &iwe, buf); | |
855 | kfree(buf); | |
856 | } | |
857 | ||
858 | if (bss_mesh_cfg(bss)) { | |
859 | u8 *cfg = bss_mesh_cfg(bss); | |
860 | buf = kmalloc(50, GFP_ATOMIC); | |
861 | if (buf) { | |
862 | memset(&iwe, 0, sizeof(iwe)); | |
863 | iwe.cmd = IWEVCUSTOM; | |
864 | sprintf(buf, "Mesh network (version %d)", cfg[0]); | |
865 | iwe.u.data.length = strlen(buf); | |
866 | current_ev = iwe_stream_add_point(info, current_ev, | |
867 | end_buf, | |
868 | &iwe, buf); | |
869 | sprintf(buf, "Path Selection Protocol ID: " | |
870 | "0x%02X%02X%02X%02X", cfg[1], cfg[2], cfg[3], | |
871 | cfg[4]); | |
872 | iwe.u.data.length = strlen(buf); | |
873 | current_ev = iwe_stream_add_point(info, current_ev, | |
874 | end_buf, | |
875 | &iwe, buf); | |
876 | sprintf(buf, "Path Selection Metric ID: " | |
877 | "0x%02X%02X%02X%02X", cfg[5], cfg[6], cfg[7], | |
878 | cfg[8]); | |
879 | iwe.u.data.length = strlen(buf); | |
880 | current_ev = iwe_stream_add_point(info, current_ev, | |
881 | end_buf, | |
882 | &iwe, buf); | |
883 | sprintf(buf, "Congestion Control Mode ID: " | |
884 | "0x%02X%02X%02X%02X", cfg[9], cfg[10], | |
885 | cfg[11], cfg[12]); | |
886 | iwe.u.data.length = strlen(buf); | |
887 | current_ev = iwe_stream_add_point(info, current_ev, | |
888 | end_buf, | |
889 | &iwe, buf); | |
890 | sprintf(buf, "Channel Precedence: " | |
891 | "0x%02X%02X%02X%02X", cfg[13], cfg[14], | |
892 | cfg[15], cfg[16]); | |
893 | iwe.u.data.length = strlen(buf); | |
894 | current_ev = iwe_stream_add_point(info, current_ev, | |
895 | end_buf, | |
896 | &iwe, buf); | |
897 | kfree(buf); | |
898 | } | |
899 | } | |
900 | ||
901 | return current_ev; | |
902 | } | |
903 | ||
904 | ||
905 | int ieee80211_sta_scan_results(struct ieee80211_local *local, | |
906 | struct iw_request_info *info, | |
907 | char *buf, size_t len) | |
908 | { | |
909 | char *current_ev = buf; | |
910 | char *end_buf = buf + len; | |
911 | struct ieee80211_sta_bss *bss; | |
912 | ||
913 | spin_lock_bh(&local->sta_bss_lock); | |
914 | list_for_each_entry(bss, &local->sta_bss_list, list) { | |
915 | if (buf + len - current_ev <= IW_EV_ADDR_LEN) { | |
916 | spin_unlock_bh(&local->sta_bss_lock); | |
917 | return -E2BIG; | |
918 | } | |
919 | current_ev = ieee80211_sta_scan_result(local, info, bss, | |
920 | current_ev, end_buf); | |
921 | } | |
922 | spin_unlock_bh(&local->sta_bss_lock); | |
923 | return current_ev - buf; | |
924 | } |