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