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