scan.c revision fcc6cb0c13555e78c2d47257b6d1b5e59b0c419a
1/* 2 * cfg80211 scan result handling 3 * 4 * Copyright 2008 Johannes Berg <johannes@sipsolutions.net> 5 */ 6#include <linux/kernel.h> 7#include <linux/module.h> 8#include <linux/netdevice.h> 9#include <linux/wireless.h> 10#include <linux/nl80211.h> 11#include <linux/etherdevice.h> 12#include <net/arp.h> 13#include <net/cfg80211.h> 14#include <net/iw_handler.h> 15#include "core.h" 16#include "nl80211.h" 17#include "wext-compat.h" 18 19#define IEEE80211_SCAN_RESULT_EXPIRE (15 * HZ) 20 21void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev, bool leak) 22{ 23 struct cfg80211_scan_request *request; 24 struct net_device *dev; 25#ifdef CONFIG_WIRELESS_EXT 26 union iwreq_data wrqu; 27#endif 28 29 ASSERT_RDEV_LOCK(rdev); 30 31 request = rdev->scan_req; 32 33 if (!request) 34 return; 35 36 dev = request->dev; 37 38 /* 39 * This must be before sending the other events! 40 * Otherwise, wpa_supplicant gets completely confused with 41 * wext events. 42 */ 43 cfg80211_sme_scan_done(dev); 44 45 if (request->aborted) 46 nl80211_send_scan_aborted(rdev, dev); 47 else 48 nl80211_send_scan_done(rdev, dev); 49 50#ifdef CONFIG_WIRELESS_EXT 51 if (!request->aborted) { 52 memset(&wrqu, 0, sizeof(wrqu)); 53 54 wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL); 55 } 56#endif 57 58 dev_put(dev); 59 60 rdev->scan_req = NULL; 61 62 /* 63 * OK. If this is invoked with "leak" then we can't 64 * free this ... but we've cleaned it up anyway. The 65 * driver failed to call the scan_done callback, so 66 * all bets are off, it might still be trying to use 67 * the scan request or not ... if it accesses the dev 68 * in there (it shouldn't anyway) then it may crash. 69 */ 70 if (!leak) 71 kfree(request); 72} 73 74void __cfg80211_scan_done(struct work_struct *wk) 75{ 76 struct cfg80211_registered_device *rdev; 77 78 rdev = container_of(wk, struct cfg80211_registered_device, 79 scan_done_wk); 80 81 cfg80211_lock_rdev(rdev); 82 ___cfg80211_scan_done(rdev, false); 83 cfg80211_unlock_rdev(rdev); 84} 85 86void cfg80211_scan_done(struct cfg80211_scan_request *request, bool aborted) 87{ 88 WARN_ON(request != wiphy_to_dev(request->wiphy)->scan_req); 89 90 request->aborted = aborted; 91 schedule_work(&wiphy_to_dev(request->wiphy)->scan_done_wk); 92} 93EXPORT_SYMBOL(cfg80211_scan_done); 94 95static void bss_release(struct kref *ref) 96{ 97 struct cfg80211_internal_bss *bss; 98 99 bss = container_of(ref, struct cfg80211_internal_bss, ref); 100 if (bss->pub.free_priv) 101 bss->pub.free_priv(&bss->pub); 102 103 if (bss->ies_allocated) 104 kfree(bss->pub.information_elements); 105 106 BUG_ON(atomic_read(&bss->hold)); 107 108 kfree(bss); 109} 110 111/* must hold dev->bss_lock! */ 112void cfg80211_bss_age(struct cfg80211_registered_device *dev, 113 unsigned long age_secs) 114{ 115 struct cfg80211_internal_bss *bss; 116 unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC); 117 118 list_for_each_entry(bss, &dev->bss_list, list) { 119 bss->ts -= age_jiffies; 120 } 121} 122 123/* must hold dev->bss_lock! */ 124void cfg80211_bss_expire(struct cfg80211_registered_device *dev) 125{ 126 struct cfg80211_internal_bss *bss, *tmp; 127 bool expired = false; 128 129 list_for_each_entry_safe(bss, tmp, &dev->bss_list, list) { 130 if (atomic_read(&bss->hold)) 131 continue; 132 if (!time_after(jiffies, bss->ts + IEEE80211_SCAN_RESULT_EXPIRE)) 133 continue; 134 list_del(&bss->list); 135 rb_erase(&bss->rbn, &dev->bss_tree); 136 kref_put(&bss->ref, bss_release); 137 expired = true; 138 } 139 140 if (expired) 141 dev->bss_generation++; 142} 143 144static u8 *find_ie(u8 num, u8 *ies, int len) 145{ 146 while (len > 2 && ies[0] != num) { 147 len -= ies[1] + 2; 148 ies += ies[1] + 2; 149 } 150 if (len < 2) 151 return NULL; 152 if (len < 2 + ies[1]) 153 return NULL; 154 return ies; 155} 156 157static int cmp_ies(u8 num, u8 *ies1, size_t len1, u8 *ies2, size_t len2) 158{ 159 const u8 *ie1 = find_ie(num, ies1, len1); 160 const u8 *ie2 = find_ie(num, ies2, len2); 161 int r; 162 163 if (!ie1 && !ie2) 164 return 0; 165 if (!ie1 || !ie2) 166 return -1; 167 168 r = memcmp(ie1 + 2, ie2 + 2, min(ie1[1], ie2[1])); 169 if (r == 0 && ie1[1] != ie2[1]) 170 return ie2[1] - ie1[1]; 171 return r; 172} 173 174static bool is_bss(struct cfg80211_bss *a, 175 const u8 *bssid, 176 const u8 *ssid, size_t ssid_len) 177{ 178 const u8 *ssidie; 179 180 if (bssid && compare_ether_addr(a->bssid, bssid)) 181 return false; 182 183 if (!ssid) 184 return true; 185 186 ssidie = find_ie(WLAN_EID_SSID, 187 a->information_elements, 188 a->len_information_elements); 189 if (!ssidie) 190 return false; 191 if (ssidie[1] != ssid_len) 192 return false; 193 return memcmp(ssidie + 2, ssid, ssid_len) == 0; 194} 195 196static bool is_mesh(struct cfg80211_bss *a, 197 const u8 *meshid, size_t meshidlen, 198 const u8 *meshcfg) 199{ 200 const u8 *ie; 201 202 if (!is_zero_ether_addr(a->bssid)) 203 return false; 204 205 ie = find_ie(WLAN_EID_MESH_ID, 206 a->information_elements, 207 a->len_information_elements); 208 if (!ie) 209 return false; 210 if (ie[1] != meshidlen) 211 return false; 212 if (memcmp(ie + 2, meshid, meshidlen)) 213 return false; 214 215 ie = find_ie(WLAN_EID_MESH_CONFIG, 216 a->information_elements, 217 a->len_information_elements); 218 if (!ie) 219 return false; 220 if (ie[1] != IEEE80211_MESH_CONFIG_LEN) 221 return false; 222 223 /* 224 * Ignore mesh capability (last two bytes of the IE) when 225 * comparing since that may differ between stations taking 226 * part in the same mesh. 227 */ 228 return memcmp(ie + 2, meshcfg, IEEE80211_MESH_CONFIG_LEN - 2) == 0; 229} 230 231static int cmp_bss(struct cfg80211_bss *a, 232 struct cfg80211_bss *b) 233{ 234 int r; 235 236 if (a->channel != b->channel) 237 return b->channel->center_freq - a->channel->center_freq; 238 239 r = memcmp(a->bssid, b->bssid, ETH_ALEN); 240 if (r) 241 return r; 242 243 if (is_zero_ether_addr(a->bssid)) { 244 r = cmp_ies(WLAN_EID_MESH_ID, 245 a->information_elements, 246 a->len_information_elements, 247 b->information_elements, 248 b->len_information_elements); 249 if (r) 250 return r; 251 return cmp_ies(WLAN_EID_MESH_CONFIG, 252 a->information_elements, 253 a->len_information_elements, 254 b->information_elements, 255 b->len_information_elements); 256 } 257 258 return cmp_ies(WLAN_EID_SSID, 259 a->information_elements, 260 a->len_information_elements, 261 b->information_elements, 262 b->len_information_elements); 263} 264 265struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy, 266 struct ieee80211_channel *channel, 267 const u8 *bssid, 268 const u8 *ssid, size_t ssid_len, 269 u16 capa_mask, u16 capa_val) 270{ 271 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy); 272 struct cfg80211_internal_bss *bss, *res = NULL; 273 274 spin_lock_bh(&dev->bss_lock); 275 276 list_for_each_entry(bss, &dev->bss_list, list) { 277 if ((bss->pub.capability & capa_mask) != capa_val) 278 continue; 279 if (channel && bss->pub.channel != channel) 280 continue; 281 if (is_bss(&bss->pub, bssid, ssid, ssid_len)) { 282 res = bss; 283 kref_get(&res->ref); 284 break; 285 } 286 } 287 288 spin_unlock_bh(&dev->bss_lock); 289 if (!res) 290 return NULL; 291 return &res->pub; 292} 293EXPORT_SYMBOL(cfg80211_get_bss); 294 295struct cfg80211_bss *cfg80211_get_mesh(struct wiphy *wiphy, 296 struct ieee80211_channel *channel, 297 const u8 *meshid, size_t meshidlen, 298 const u8 *meshcfg) 299{ 300 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy); 301 struct cfg80211_internal_bss *bss, *res = NULL; 302 303 spin_lock_bh(&dev->bss_lock); 304 305 list_for_each_entry(bss, &dev->bss_list, list) { 306 if (channel && bss->pub.channel != channel) 307 continue; 308 if (is_mesh(&bss->pub, meshid, meshidlen, meshcfg)) { 309 res = bss; 310 kref_get(&res->ref); 311 break; 312 } 313 } 314 315 spin_unlock_bh(&dev->bss_lock); 316 if (!res) 317 return NULL; 318 return &res->pub; 319} 320EXPORT_SYMBOL(cfg80211_get_mesh); 321 322 323static void rb_insert_bss(struct cfg80211_registered_device *dev, 324 struct cfg80211_internal_bss *bss) 325{ 326 struct rb_node **p = &dev->bss_tree.rb_node; 327 struct rb_node *parent = NULL; 328 struct cfg80211_internal_bss *tbss; 329 int cmp; 330 331 while (*p) { 332 parent = *p; 333 tbss = rb_entry(parent, struct cfg80211_internal_bss, rbn); 334 335 cmp = cmp_bss(&bss->pub, &tbss->pub); 336 337 if (WARN_ON(!cmp)) { 338 /* will sort of leak this BSS */ 339 return; 340 } 341 342 if (cmp < 0) 343 p = &(*p)->rb_left; 344 else 345 p = &(*p)->rb_right; 346 } 347 348 rb_link_node(&bss->rbn, parent, p); 349 rb_insert_color(&bss->rbn, &dev->bss_tree); 350} 351 352static struct cfg80211_internal_bss * 353rb_find_bss(struct cfg80211_registered_device *dev, 354 struct cfg80211_internal_bss *res) 355{ 356 struct rb_node *n = dev->bss_tree.rb_node; 357 struct cfg80211_internal_bss *bss; 358 int r; 359 360 while (n) { 361 bss = rb_entry(n, struct cfg80211_internal_bss, rbn); 362 r = cmp_bss(&res->pub, &bss->pub); 363 364 if (r == 0) 365 return bss; 366 else if (r < 0) 367 n = n->rb_left; 368 else 369 n = n->rb_right; 370 } 371 372 return NULL; 373} 374 375static struct cfg80211_internal_bss * 376cfg80211_bss_update(struct cfg80211_registered_device *dev, 377 struct cfg80211_internal_bss *res, 378 bool overwrite) 379{ 380 struct cfg80211_internal_bss *found = NULL; 381 const u8 *meshid, *meshcfg; 382 383 /* 384 * The reference to "res" is donated to this function. 385 */ 386 387 if (WARN_ON(!res->pub.channel)) { 388 kref_put(&res->ref, bss_release); 389 return NULL; 390 } 391 392 res->ts = jiffies; 393 394 if (is_zero_ether_addr(res->pub.bssid)) { 395 /* must be mesh, verify */ 396 meshid = find_ie(WLAN_EID_MESH_ID, res->pub.information_elements, 397 res->pub.len_information_elements); 398 meshcfg = find_ie(WLAN_EID_MESH_CONFIG, 399 res->pub.information_elements, 400 res->pub.len_information_elements); 401 if (!meshid || !meshcfg || 402 meshcfg[1] != IEEE80211_MESH_CONFIG_LEN) { 403 /* bogus mesh */ 404 kref_put(&res->ref, bss_release); 405 return NULL; 406 } 407 } 408 409 spin_lock_bh(&dev->bss_lock); 410 411 found = rb_find_bss(dev, res); 412 413 if (found) { 414 found->pub.beacon_interval = res->pub.beacon_interval; 415 found->pub.tsf = res->pub.tsf; 416 found->pub.signal = res->pub.signal; 417 found->pub.capability = res->pub.capability; 418 found->ts = res->ts; 419 420 /* overwrite IEs */ 421 if (overwrite) { 422 size_t used = dev->wiphy.bss_priv_size + sizeof(*res); 423 size_t ielen = res->pub.len_information_elements; 424 425 if (!found->ies_allocated && ksize(found) >= used + ielen) { 426 memcpy(found->pub.information_elements, 427 res->pub.information_elements, ielen); 428 found->pub.len_information_elements = ielen; 429 } else { 430 u8 *ies = found->pub.information_elements; 431 432 if (found->ies_allocated) 433 ies = krealloc(ies, ielen, GFP_ATOMIC); 434 else 435 ies = kmalloc(ielen, GFP_ATOMIC); 436 437 if (ies) { 438 memcpy(ies, res->pub.information_elements, ielen); 439 found->ies_allocated = true; 440 found->pub.information_elements = ies; 441 found->pub.len_information_elements = ielen; 442 } 443 } 444 } 445 446 kref_put(&res->ref, bss_release); 447 } else { 448 /* this "consumes" the reference */ 449 list_add_tail(&res->list, &dev->bss_list); 450 rb_insert_bss(dev, res); 451 found = res; 452 } 453 454 dev->bss_generation++; 455 spin_unlock_bh(&dev->bss_lock); 456 457 kref_get(&found->ref); 458 return found; 459} 460 461struct cfg80211_bss* 462cfg80211_inform_bss(struct wiphy *wiphy, 463 struct ieee80211_channel *channel, 464 const u8 *bssid, 465 u64 timestamp, u16 capability, u16 beacon_interval, 466 const u8 *ie, size_t ielen, 467 s32 signal, gfp_t gfp) 468{ 469 struct cfg80211_internal_bss *res; 470 size_t privsz; 471 472 if (WARN_ON(!wiphy)) 473 return NULL; 474 475 privsz = wiphy->bss_priv_size; 476 477 if (WARN_ON(wiphy->signal_type == NL80211_BSS_SIGNAL_UNSPEC && 478 (signal < 0 || signal > 100))) 479 return NULL; 480 481 res = kzalloc(sizeof(*res) + privsz + ielen, gfp); 482 if (!res) 483 return NULL; 484 485 memcpy(res->pub.bssid, bssid, ETH_ALEN); 486 res->pub.channel = channel; 487 res->pub.signal = signal; 488 res->pub.tsf = timestamp; 489 res->pub.beacon_interval = beacon_interval; 490 res->pub.capability = capability; 491 /* point to after the private area */ 492 res->pub.information_elements = (u8 *)res + sizeof(*res) + privsz; 493 memcpy(res->pub.information_elements, ie, ielen); 494 res->pub.len_information_elements = ielen; 495 496 kref_init(&res->ref); 497 498 res = cfg80211_bss_update(wiphy_to_dev(wiphy), res, 0); 499 if (!res) 500 return NULL; 501 502 if (res->pub.capability & WLAN_CAPABILITY_ESS) 503 regulatory_hint_found_beacon(wiphy, channel, gfp); 504 505 /* cfg80211_bss_update gives us a referenced result */ 506 return &res->pub; 507} 508EXPORT_SYMBOL(cfg80211_inform_bss); 509 510struct cfg80211_bss * 511cfg80211_inform_bss_frame(struct wiphy *wiphy, 512 struct ieee80211_channel *channel, 513 struct ieee80211_mgmt *mgmt, size_t len, 514 s32 signal, gfp_t gfp) 515{ 516 struct cfg80211_internal_bss *res; 517 size_t ielen = len - offsetof(struct ieee80211_mgmt, 518 u.probe_resp.variable); 519 bool overwrite; 520 size_t privsz = wiphy->bss_priv_size; 521 522 if (WARN_ON(wiphy->signal_type == NL80211_BSS_SIGNAL_UNSPEC && 523 (signal < 0 || signal > 100))) 524 return NULL; 525 526 if (WARN_ON(!mgmt || !wiphy || 527 len < offsetof(struct ieee80211_mgmt, u.probe_resp.variable))) 528 return NULL; 529 530 res = kzalloc(sizeof(*res) + privsz + ielen, gfp); 531 if (!res) 532 return NULL; 533 534 memcpy(res->pub.bssid, mgmt->bssid, ETH_ALEN); 535 res->pub.channel = channel; 536 res->pub.signal = signal; 537 res->pub.tsf = le64_to_cpu(mgmt->u.probe_resp.timestamp); 538 res->pub.beacon_interval = le16_to_cpu(mgmt->u.probe_resp.beacon_int); 539 res->pub.capability = le16_to_cpu(mgmt->u.probe_resp.capab_info); 540 /* point to after the private area */ 541 res->pub.information_elements = (u8 *)res + sizeof(*res) + privsz; 542 memcpy(res->pub.information_elements, mgmt->u.probe_resp.variable, ielen); 543 res->pub.len_information_elements = ielen; 544 545 kref_init(&res->ref); 546 547 overwrite = ieee80211_is_probe_resp(mgmt->frame_control); 548 549 res = cfg80211_bss_update(wiphy_to_dev(wiphy), res, overwrite); 550 if (!res) 551 return NULL; 552 553 if (res->pub.capability & WLAN_CAPABILITY_ESS) 554 regulatory_hint_found_beacon(wiphy, channel, gfp); 555 556 /* cfg80211_bss_update gives us a referenced result */ 557 return &res->pub; 558} 559EXPORT_SYMBOL(cfg80211_inform_bss_frame); 560 561void cfg80211_put_bss(struct cfg80211_bss *pub) 562{ 563 struct cfg80211_internal_bss *bss; 564 565 if (!pub) 566 return; 567 568 bss = container_of(pub, struct cfg80211_internal_bss, pub); 569 kref_put(&bss->ref, bss_release); 570} 571EXPORT_SYMBOL(cfg80211_put_bss); 572 573void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *pub) 574{ 575 struct cfg80211_registered_device *dev = wiphy_to_dev(wiphy); 576 struct cfg80211_internal_bss *bss; 577 578 if (WARN_ON(!pub)) 579 return; 580 581 bss = container_of(pub, struct cfg80211_internal_bss, pub); 582 583 spin_lock_bh(&dev->bss_lock); 584 585 list_del(&bss->list); 586 dev->bss_generation++; 587 rb_erase(&bss->rbn, &dev->bss_tree); 588 589 spin_unlock_bh(&dev->bss_lock); 590 591 kref_put(&bss->ref, bss_release); 592} 593EXPORT_SYMBOL(cfg80211_unlink_bss); 594 595#ifdef CONFIG_WIRELESS_EXT 596int cfg80211_wext_siwscan(struct net_device *dev, 597 struct iw_request_info *info, 598 union iwreq_data *wrqu, char *extra) 599{ 600 struct cfg80211_registered_device *rdev; 601 struct wiphy *wiphy; 602 struct iw_scan_req *wreq = NULL; 603 struct cfg80211_scan_request *creq; 604 int i, err, n_channels = 0; 605 enum ieee80211_band band; 606 607 if (!netif_running(dev)) 608 return -ENETDOWN; 609 610 rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex); 611 612 if (IS_ERR(rdev)) 613 return PTR_ERR(rdev); 614 615 if (rdev->scan_req) { 616 err = -EBUSY; 617 goto out; 618 } 619 620 wiphy = &rdev->wiphy; 621 622 for (band = 0; band < IEEE80211_NUM_BANDS; band++) 623 if (wiphy->bands[band]) 624 n_channels += wiphy->bands[band]->n_channels; 625 626 creq = kzalloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) + 627 n_channels * sizeof(void *), 628 GFP_ATOMIC); 629 if (!creq) { 630 err = -ENOMEM; 631 goto out; 632 } 633 634 creq->wiphy = wiphy; 635 creq->dev = dev; 636 /* SSIDs come after channels */ 637 creq->ssids = (void *)&creq->channels[n_channels]; 638 creq->n_channels = n_channels; 639 creq->n_ssids = 1; 640 641 /* all channels */ 642 i = 0; 643 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 644 int j; 645 if (!wiphy->bands[band]) 646 continue; 647 for (j = 0; j < wiphy->bands[band]->n_channels; j++) { 648 creq->channels[i] = &wiphy->bands[band]->channels[j]; 649 i++; 650 } 651 } 652 653 /* translate scan request */ 654 if (wrqu->data.length == sizeof(struct iw_scan_req)) { 655 wreq = (struct iw_scan_req *)extra; 656 657 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) { 658 if (wreq->essid_len > IEEE80211_MAX_SSID_LEN) 659 return -EINVAL; 660 memcpy(creq->ssids[0].ssid, wreq->essid, wreq->essid_len); 661 creq->ssids[0].ssid_len = wreq->essid_len; 662 } 663 if (wreq->scan_type == IW_SCAN_TYPE_PASSIVE) 664 creq->n_ssids = 0; 665 } 666 667 rdev->scan_req = creq; 668 err = rdev->ops->scan(wiphy, dev, creq); 669 if (err) { 670 rdev->scan_req = NULL; 671 kfree(creq); 672 } else { 673 nl80211_send_scan_start(rdev, dev); 674 dev_hold(dev); 675 } 676 out: 677 cfg80211_unlock_rdev(rdev); 678 return err; 679} 680EXPORT_SYMBOL_GPL(cfg80211_wext_siwscan); 681 682static void ieee80211_scan_add_ies(struct iw_request_info *info, 683 struct cfg80211_bss *bss, 684 char **current_ev, char *end_buf) 685{ 686 u8 *pos, *end, *next; 687 struct iw_event iwe; 688 689 if (!bss->information_elements || 690 !bss->len_information_elements) 691 return; 692 693 /* 694 * If needed, fragment the IEs buffer (at IE boundaries) into short 695 * enough fragments to fit into IW_GENERIC_IE_MAX octet messages. 696 */ 697 pos = bss->information_elements; 698 end = pos + bss->len_information_elements; 699 700 while (end - pos > IW_GENERIC_IE_MAX) { 701 next = pos + 2 + pos[1]; 702 while (next + 2 + next[1] - pos < IW_GENERIC_IE_MAX) 703 next = next + 2 + next[1]; 704 705 memset(&iwe, 0, sizeof(iwe)); 706 iwe.cmd = IWEVGENIE; 707 iwe.u.data.length = next - pos; 708 *current_ev = iwe_stream_add_point(info, *current_ev, 709 end_buf, &iwe, pos); 710 711 pos = next; 712 } 713 714 if (end > pos) { 715 memset(&iwe, 0, sizeof(iwe)); 716 iwe.cmd = IWEVGENIE; 717 iwe.u.data.length = end - pos; 718 *current_ev = iwe_stream_add_point(info, *current_ev, 719 end_buf, &iwe, pos); 720 } 721} 722 723static inline unsigned int elapsed_jiffies_msecs(unsigned long start) 724{ 725 unsigned long end = jiffies; 726 727 if (end >= start) 728 return jiffies_to_msecs(end - start); 729 730 return jiffies_to_msecs(end + (MAX_JIFFY_OFFSET - start) + 1); 731} 732 733static char * 734ieee80211_bss(struct wiphy *wiphy, struct iw_request_info *info, 735 struct cfg80211_internal_bss *bss, char *current_ev, 736 char *end_buf) 737{ 738 struct iw_event iwe; 739 u8 *buf, *cfg, *p; 740 u8 *ie = bss->pub.information_elements; 741 int rem = bss->pub.len_information_elements, i, sig; 742 bool ismesh = false; 743 744 memset(&iwe, 0, sizeof(iwe)); 745 iwe.cmd = SIOCGIWAP; 746 iwe.u.ap_addr.sa_family = ARPHRD_ETHER; 747 memcpy(iwe.u.ap_addr.sa_data, bss->pub.bssid, ETH_ALEN); 748 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, 749 IW_EV_ADDR_LEN); 750 751 memset(&iwe, 0, sizeof(iwe)); 752 iwe.cmd = SIOCGIWFREQ; 753 iwe.u.freq.m = ieee80211_frequency_to_channel(bss->pub.channel->center_freq); 754 iwe.u.freq.e = 0; 755 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, 756 IW_EV_FREQ_LEN); 757 758 memset(&iwe, 0, sizeof(iwe)); 759 iwe.cmd = SIOCGIWFREQ; 760 iwe.u.freq.m = bss->pub.channel->center_freq; 761 iwe.u.freq.e = 6; 762 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, 763 IW_EV_FREQ_LEN); 764 765 if (wiphy->signal_type != CFG80211_SIGNAL_TYPE_NONE) { 766 memset(&iwe, 0, sizeof(iwe)); 767 iwe.cmd = IWEVQUAL; 768 iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED | 769 IW_QUAL_NOISE_INVALID | 770 IW_QUAL_QUAL_UPDATED; 771 switch (wiphy->signal_type) { 772 case CFG80211_SIGNAL_TYPE_MBM: 773 sig = bss->pub.signal / 100; 774 iwe.u.qual.level = sig; 775 iwe.u.qual.updated |= IW_QUAL_DBM; 776 if (sig < -110) /* rather bad */ 777 sig = -110; 778 else if (sig > -40) /* perfect */ 779 sig = -40; 780 /* will give a range of 0 .. 70 */ 781 iwe.u.qual.qual = sig + 110; 782 break; 783 case CFG80211_SIGNAL_TYPE_UNSPEC: 784 iwe.u.qual.level = bss->pub.signal; 785 /* will give range 0 .. 100 */ 786 iwe.u.qual.qual = bss->pub.signal; 787 break; 788 default: 789 /* not reached */ 790 break; 791 } 792 current_ev = iwe_stream_add_event(info, current_ev, end_buf, 793 &iwe, IW_EV_QUAL_LEN); 794 } 795 796 memset(&iwe, 0, sizeof(iwe)); 797 iwe.cmd = SIOCGIWENCODE; 798 if (bss->pub.capability & WLAN_CAPABILITY_PRIVACY) 799 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY; 800 else 801 iwe.u.data.flags = IW_ENCODE_DISABLED; 802 iwe.u.data.length = 0; 803 current_ev = iwe_stream_add_point(info, current_ev, end_buf, 804 &iwe, ""); 805 806 while (rem >= 2) { 807 /* invalid data */ 808 if (ie[1] > rem - 2) 809 break; 810 811 switch (ie[0]) { 812 case WLAN_EID_SSID: 813 memset(&iwe, 0, sizeof(iwe)); 814 iwe.cmd = SIOCGIWESSID; 815 iwe.u.data.length = ie[1]; 816 iwe.u.data.flags = 1; 817 current_ev = iwe_stream_add_point(info, current_ev, end_buf, 818 &iwe, ie + 2); 819 break; 820 case WLAN_EID_MESH_ID: 821 memset(&iwe, 0, sizeof(iwe)); 822 iwe.cmd = SIOCGIWESSID; 823 iwe.u.data.length = ie[1]; 824 iwe.u.data.flags = 1; 825 current_ev = iwe_stream_add_point(info, current_ev, end_buf, 826 &iwe, ie + 2); 827 break; 828 case WLAN_EID_MESH_CONFIG: 829 ismesh = true; 830 if (ie[1] != IEEE80211_MESH_CONFIG_LEN) 831 break; 832 buf = kmalloc(50, GFP_ATOMIC); 833 if (!buf) 834 break; 835 cfg = ie + 2; 836 memset(&iwe, 0, sizeof(iwe)); 837 iwe.cmd = IWEVCUSTOM; 838 sprintf(buf, "Mesh network (version %d)", cfg[0]); 839 iwe.u.data.length = strlen(buf); 840 current_ev = iwe_stream_add_point(info, current_ev, 841 end_buf, 842 &iwe, buf); 843 sprintf(buf, "Path Selection Protocol ID: " 844 "0x%02X%02X%02X%02X", cfg[1], cfg[2], cfg[3], 845 cfg[4]); 846 iwe.u.data.length = strlen(buf); 847 current_ev = iwe_stream_add_point(info, current_ev, 848 end_buf, 849 &iwe, buf); 850 sprintf(buf, "Path Selection Metric ID: " 851 "0x%02X%02X%02X%02X", cfg[5], cfg[6], cfg[7], 852 cfg[8]); 853 iwe.u.data.length = strlen(buf); 854 current_ev = iwe_stream_add_point(info, current_ev, 855 end_buf, 856 &iwe, buf); 857 sprintf(buf, "Congestion Control Mode ID: " 858 "0x%02X%02X%02X%02X", cfg[9], cfg[10], 859 cfg[11], cfg[12]); 860 iwe.u.data.length = strlen(buf); 861 current_ev = iwe_stream_add_point(info, current_ev, 862 end_buf, 863 &iwe, buf); 864 sprintf(buf, "Channel Precedence: " 865 "0x%02X%02X%02X%02X", cfg[13], cfg[14], 866 cfg[15], cfg[16]); 867 iwe.u.data.length = strlen(buf); 868 current_ev = iwe_stream_add_point(info, current_ev, 869 end_buf, 870 &iwe, buf); 871 kfree(buf); 872 break; 873 case WLAN_EID_SUPP_RATES: 874 case WLAN_EID_EXT_SUPP_RATES: 875 /* display all supported rates in readable format */ 876 p = current_ev + iwe_stream_lcp_len(info); 877 878 memset(&iwe, 0, sizeof(iwe)); 879 iwe.cmd = SIOCGIWRATE; 880 /* Those two flags are ignored... */ 881 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0; 882 883 for (i = 0; i < ie[1]; i++) { 884 iwe.u.bitrate.value = 885 ((ie[i + 2] & 0x7f) * 500000); 886 p = iwe_stream_add_value(info, current_ev, p, 887 end_buf, &iwe, IW_EV_PARAM_LEN); 888 } 889 current_ev = p; 890 break; 891 } 892 rem -= ie[1] + 2; 893 ie += ie[1] + 2; 894 } 895 896 if (bss->pub.capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS) 897 || ismesh) { 898 memset(&iwe, 0, sizeof(iwe)); 899 iwe.cmd = SIOCGIWMODE; 900 if (ismesh) 901 iwe.u.mode = IW_MODE_MESH; 902 else if (bss->pub.capability & WLAN_CAPABILITY_ESS) 903 iwe.u.mode = IW_MODE_MASTER; 904 else 905 iwe.u.mode = IW_MODE_ADHOC; 906 current_ev = iwe_stream_add_event(info, current_ev, end_buf, 907 &iwe, IW_EV_UINT_LEN); 908 } 909 910 buf = kmalloc(30, GFP_ATOMIC); 911 if (buf) { 912 memset(&iwe, 0, sizeof(iwe)); 913 iwe.cmd = IWEVCUSTOM; 914 sprintf(buf, "tsf=%016llx", (unsigned long long)(bss->pub.tsf)); 915 iwe.u.data.length = strlen(buf); 916 current_ev = iwe_stream_add_point(info, current_ev, end_buf, 917 &iwe, buf); 918 memset(&iwe, 0, sizeof(iwe)); 919 iwe.cmd = IWEVCUSTOM; 920 sprintf(buf, " Last beacon: %ums ago", 921 elapsed_jiffies_msecs(bss->ts)); 922 iwe.u.data.length = strlen(buf); 923 current_ev = iwe_stream_add_point(info, current_ev, 924 end_buf, &iwe, buf); 925 kfree(buf); 926 } 927 928 ieee80211_scan_add_ies(info, &bss->pub, ¤t_ev, end_buf); 929 930 return current_ev; 931} 932 933 934static int ieee80211_scan_results(struct cfg80211_registered_device *dev, 935 struct iw_request_info *info, 936 char *buf, size_t len) 937{ 938 char *current_ev = buf; 939 char *end_buf = buf + len; 940 struct cfg80211_internal_bss *bss; 941 942 spin_lock_bh(&dev->bss_lock); 943 cfg80211_bss_expire(dev); 944 945 list_for_each_entry(bss, &dev->bss_list, list) { 946 if (buf + len - current_ev <= IW_EV_ADDR_LEN) { 947 spin_unlock_bh(&dev->bss_lock); 948 return -E2BIG; 949 } 950 current_ev = ieee80211_bss(&dev->wiphy, info, bss, 951 current_ev, end_buf); 952 } 953 spin_unlock_bh(&dev->bss_lock); 954 return current_ev - buf; 955} 956 957 958int cfg80211_wext_giwscan(struct net_device *dev, 959 struct iw_request_info *info, 960 struct iw_point *data, char *extra) 961{ 962 struct cfg80211_registered_device *rdev; 963 int res; 964 965 if (!netif_running(dev)) 966 return -ENETDOWN; 967 968 rdev = cfg80211_get_dev_from_ifindex(dev_net(dev), dev->ifindex); 969 970 if (IS_ERR(rdev)) 971 return PTR_ERR(rdev); 972 973 if (rdev->scan_req) { 974 res = -EAGAIN; 975 goto out; 976 } 977 978 res = ieee80211_scan_results(rdev, info, extra, data->length); 979 data->length = 0; 980 if (res >= 0) { 981 data->length = res; 982 res = 0; 983 } 984 985 out: 986 cfg80211_unlock_rdev(rdev); 987 return res; 988} 989EXPORT_SYMBOL_GPL(cfg80211_wext_giwscan); 990#endif 991