system/core/nexus/WifiController.cpp

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <errno.h>
  20
  21 #define LOG_TAG "WifiController"
  22 #include <cutils/log.h>
  23
  24 #include "Supplicant.h"
  25 #include "WifiController.h"
  26 #include "NetworkManager.h"
  27 #include "ResponseCode.h"
  28 #include "WifiNetwork.h"
  29 #include "ISupplicantEventHandler.h"
  30 #include "SupplicantState.h"
  31 #include "SupplicantStatus.h"
  32 #include "SupplicantAssociatingEvent.h"
  33 #include "SupplicantAssociatedEvent.h"
  34 #include "SupplicantConnectedEvent.h"
  35 #include "SupplicantScanResultsEvent.h"
  36 #include "SupplicantStateChangeEvent.h"
  37 #include "SupplicantConnectionTimeoutEvent.h"
  38 #include "SupplicantDisconnectedEvent.h"
  39 #include "WifiStatusPoller.h"
  40
  41 WifiController::WifiController(PropertyManager *mPropMngr,
  42                                IControllerHandler *handlers,
  43                                char *modpath, char *modname, char *modargs) :
  44                 Controller("wifi", mPropMngr, handlers) {
  45     strncpy(mModulePath, modpath, sizeof(mModulePath));
  46     strncpy(mModuleName, modname, sizeof(mModuleName));
  47     strncpy(mModuleArgs, modargs, sizeof(mModuleArgs));
  48
  49     mLatestScanResults = new ScanResultCollection();
  50     pthread_mutex_init(&mLatestScanResultsLock, NULL);
  51
  52     pthread_mutex_init(&mLock, NULL);
  53
  54     mSupplicant = new Supplicant(this, this);
  55     mActiveScan = false;
  56     mEnabled = false;
  57     mScanOnly = false;
  58     mPacketFilter = false;
  59     mBluetoothCoexScan = false;
  60     mBluetoothCoexMode = 0;
  61     mCurrentlyConnectedNetworkId = -1;
  62     mStatusPoller = new WifiStatusPoller(this);
  63     mRssiEventThreshold = 5;
  64     mLastLinkSpeed = 0;
  65
  66     mSupplicantState = SupplicantState::UNKNOWN;
  67
  68     mStaticProperties.propEnabled = new WifiEnabledProperty(this);
  69     mStaticProperties.propScanOnly = new WifiScanOnlyProperty(this);
  70     mStaticProperties.propAllowedChannels = new WifiAllowedChannelsProperty(this);
  71
  72     mStaticProperties.propRssiEventThreshold =
  73             new IntegerPropertyHelper("RssiEventThreshold", false, &mRssiEventThreshold);
  74
  75     mDynamicProperties.propSupplicantState = new WifiSupplicantStateProperty(this);
  76     mDynamicProperties.propActiveScan = new WifiActiveScanProperty(this);
  77     mDynamicProperties.propInterface = new WifiInterfaceProperty(this);
  78     mDynamicProperties.propSearching = new WifiSearchingProperty(this);
  79     mDynamicProperties.propPacketFilter = new WifiPacketFilterProperty(this);
  80     mDynamicProperties.propBluetoothCoexScan = new WifiBluetoothCoexScanProperty(this);
  81     mDynamicProperties.propBluetoothCoexMode = new WifiBluetoothCoexModeProperty(this);
  82     mDynamicProperties.propCurrentNetwork = new WifiCurrentNetworkProperty(this);
  83
  84     mDynamicProperties.propRssi = new IntegerPropertyHelper("Rssi", true, &mLastRssi);
  85     mDynamicProperties.propLinkSpeed = new IntegerPropertyHelper("LinkSpeed", true, &mLastLinkSpeed);
  86
  87     mDynamicProperties.propSuspended = new WifiSuspendedProperty(this);
  88     mDynamicProperties.propNetCount = new WifiNetCountProperty(this);
  89     mDynamicProperties.propTriggerScan = new WifiTriggerScanProperty(this);
  90 }
  91
  92 int WifiController::start() {
  93     mPropMngr->attachProperty("wifi", mStaticProperties.propEnabled);
  94     mPropMngr->attachProperty("wifi", mStaticProperties.propScanOnly);
  95     mPropMngr->attachProperty("wifi", mStaticProperties.propAllowedChannels);
  96     mPropMngr->attachProperty("wifi", mStaticProperties.propRssiEventThreshold);
  97     return 0;
  98 }
  99
 100 int WifiController::stop() {
 101     mPropMngr->detachProperty("wifi", mStaticProperties.propEnabled);
 102     mPropMngr->detachProperty("wifi", mStaticProperties.propScanOnly);
 103     mPropMngr->detachProperty("wifi", mStaticProperties.propAllowedChannels);
 104     mPropMngr->detachProperty("wifi", mStaticProperties.propRssiEventThreshold);
 105     return 0;
 106 }
 107
 108 int WifiController::enable() {
 109
 110     if (!isPoweredUp()) {
 111         LOGI("Powering up");
 112         sendStatusBroadcast("Powering up WiFi hardware");
 113         if (powerUp()) {
 114             LOGE("Powerup failed (%s)", strerror(errno));
 115             return -1;
 116         }
 117     }
 118
 119     if (mModuleName[0] != '\0' && !isKernelModuleLoaded(mModuleName)) {
 120         LOGI("Loading driver");
 121         sendStatusBroadcast("Loading WiFi driver");
 122         if (loadKernelModule(mModulePath, mModuleArgs)) {
 123             LOGE("Kernel module load failed (%s)", strerror(errno));
 124             goto out_powerdown;
 125         }
 126     }
 127
 128     if (!isFirmwareLoaded()) {
 129         LOGI("Loading firmware");
 130         sendStatusBroadcast("Loading WiFI firmware");
 131         if (loadFirmware()) {
 132             LOGE("Firmware load failed (%s)", strerror(errno));
 133             goto out_powerdown;
 134         }
 135     }
 136
 137     if (!mSupplicant->isStarted()) {
 138         LOGI("Starting WPA Supplicant");
 139         sendStatusBroadcast("Starting WPA Supplicant");
 140         if (mSupplicant->start()) {
 141             LOGE("Supplicant start failed (%s)", strerror(errno));
 142             goto out_unloadmodule;
 143         }
 144     }
 145
 146     if (Controller::bindInterface(mSupplicant->getInterfaceName())) {
 147         LOGE("Error binding interface (%s)", strerror(errno));
 148         goto out_unloadmodule;
 149     }
 150
 151     if (mSupplicant->refreshNetworkList())
 152         LOGW("Error getting list of networks (%s)", strerror(errno));
 153
 154     LOGW("TODO: Set # of allowed regulatory channels!");
 155
 156     mPropMngr->attachProperty("wifi", mDynamicProperties.propSupplicantState);
 157     mPropMngr->attachProperty("wifi", mDynamicProperties.propActiveScan);
 158     mPropMngr->attachProperty("wifi", mDynamicProperties.propInterface);
 159     mPropMngr->attachProperty("wifi", mDynamicProperties.propSearching);
 160     mPropMngr->attachProperty("wifi", mDynamicProperties.propPacketFilter);
 161     mPropMngr->attachProperty("wifi", mDynamicProperties.propBluetoothCoexScan);
 162     mPropMngr->attachProperty("wifi", mDynamicProperties.propBluetoothCoexMode);
 163     mPropMngr->attachProperty("wifi", mDynamicProperties.propCurrentNetwork);
 164     mPropMngr->attachProperty("wifi", mDynamicProperties.propRssi);
 165     mPropMngr->attachProperty("wifi", mDynamicProperties.propLinkSpeed);
 166     mPropMngr->attachProperty("wifi", mDynamicProperties.propSuspended);
 167     mPropMngr->attachProperty("wifi", mDynamicProperties.propNetCount);
 168     mPropMngr->attachProperty("wifi", mDynamicProperties.propTriggerScan);
 169
 170     LOGI("Enabled successfully");
 171     return 0;
 172
 173 out_unloadmodule:
 174     if (mModuleName[0] != '\0' && !isKernelModuleLoaded(mModuleName)) {
 175         if (unloadKernelModule(mModuleName)) {
 176             LOGE("Unable to unload module after failure!");
 177         }
 178     }
 179
 180 out_powerdown:
 181     if (powerDown()) {
 182         LOGE("Unable to powerdown after failure!");
 183     }
 184     return -1;
 185 }
 186
 187 bool WifiController::getSuspended() {
 188     pthread_mutex_lock(&mLock);
 189     bool r = mSuspended;
 190     pthread_mutex_unlock(&mLock);
 191     return r;
 192 }
 193
 194 int WifiController::setSuspend(bool suspend) {
 195
 196     pthread_mutex_lock(&mLock);
 197     if (suspend == mSuspended) {
 198         LOGW("Suspended state already = %d", suspend);
 199         pthread_mutex_unlock(&mLock);
 200         return 0;
 201     }
 202
 203     if (suspend) {
 204         mHandlers->onControllerSuspending(this);
 205
 206         char tmp[80];
 207         LOGD("Suspending from supplicant state %s",
 208              SupplicantState::toString(mSupplicantState,
 209                                        tmp,
 210                                        sizeof(tmp)));
 211
 212         if (mSupplicantState != SupplicantState::IDLE) {
 213             LOGD("Forcing Supplicant disconnect");
 214             if (mSupplicant->disconnect()) {
 215                 LOGW("Error disconnecting (%s)", strerror(errno));
 216             }
 217         }
 218
 219         LOGD("Stopping Supplicant driver");
 220         if (mSupplicant->stopDriver()) {
 221             LOGE("Error stopping driver (%s)", strerror(errno));
 222             pthread_mutex_unlock(&mLock);
 223             return -1;
 224         }
 225     } else {
 226         LOGD("Resuming");
 227
 228         if (mSupplicant->startDriver()) {
 229             LOGE("Error resuming driver (%s)", strerror(errno));
 230             pthread_mutex_unlock(&mLock);
 231             return -1;
 232         }
 233         // XXX: set regulatory max channels
 234         if (mScanOnly)
 235             mSupplicant->triggerScan();
 236         else
 237             mSupplicant->reconnect();
 238
 239         mHandlers->onControllerResumed(this);
 240     }
 241
 242     mSuspended = suspend;
 243     pthread_mutex_unlock(&mLock);
 244     LOGD("Suspend / Resume completed");
 245     return 0;
 246 }
 247
 248 void WifiController::sendStatusBroadcast(const char *msg) {
 249     NetworkManager::Instance()->
 250                     getBroadcaster()->
 251                     sendBroadcast(ResponseCode::UnsolicitedInformational, msg, false);
 252 }
 253
 254 int WifiController::disable() {
 255
 256     mPropMngr->detachProperty("wifi", mDynamicProperties.propSupplicantState);
 257     mPropMngr->detachProperty("wifi", mDynamicProperties.propActiveScan);
 258     mPropMngr->detachProperty("wifi", mDynamicProperties.propInterface);
 259     mPropMngr->detachProperty("wifi", mDynamicProperties.propSearching);
 260     mPropMngr->detachProperty("wifi", mDynamicProperties.propPacketFilter);
 261     mPropMngr->detachProperty("wifi", mDynamicProperties.propBluetoothCoexScan);
 262     mPropMngr->detachProperty("wifi", mDynamicProperties.propBluetoothCoexMode);
 263     mPropMngr->detachProperty("wifi", mDynamicProperties.propCurrentNetwork);
 264     mPropMngr->detachProperty("wifi", mDynamicProperties.propRssi);
 265     mPropMngr->detachProperty("wifi", mDynamicProperties.propLinkSpeed);
 266     mPropMngr->detachProperty("wifi", mDynamicProperties.propSuspended);
 267     mPropMngr->detachProperty("wifi", mDynamicProperties.propNetCount);
 268
 269     if (mSupplicant->isStarted()) {
 270         sendStatusBroadcast("Stopping WPA Supplicant");
 271         if (mSupplicant->stop()) {
 272             LOGE("Supplicant stop failed (%s)", strerror(errno));
 273             return -1;
 274         }
 275     } else
 276         LOGW("disable(): Supplicant not running?");
 277
 278     if (mModuleName[0] != '\0' && isKernelModuleLoaded(mModuleName)) {
 279         sendStatusBroadcast("Unloading WiFi driver");
 280         if (unloadKernelModule(mModuleName)) {
 281             LOGE("Unable to unload module (%s)", strerror(errno));
 282             return -1;
 283         }
 284     }
 285
 286     if (isPoweredUp()) {
 287         sendStatusBroadcast("Powering down WiFi hardware");
 288         if (powerDown()) {
 289             LOGE("Powerdown failed (%s)", strerror(errno));
 290             return -1;
 291         }
 292     }
 293     return 0;
 294 }
 295
 296 int WifiController::loadFirmware() {
 297     return 0;
 298 }
 299
 300 int WifiController::triggerScan() {
 301     pthread_mutex_lock(&mLock);
 302     if (verifyNotSuspended()) {
 303         pthread_mutex_unlock(&mLock);
 304         return -1;
 305     }
 306
 307     switch (mSupplicantState) {
 308         case SupplicantState::DISCONNECTED:
 309         case SupplicantState::INACTIVE:
 310         case SupplicantState::SCANNING:
 311         case SupplicantState::IDLE:
 312             break;
 313         default:
 314             // Switch to scan only mode
 315             mSupplicant->setApScanMode(2);
 316             break;
 317     }
 318
 319     int rc = mSupplicant->triggerScan();
 320     pthread_mutex_unlock(&mLock);
 321     return rc;
 322 }
 323
 324 int WifiController::setActiveScan(bool active) {
 325     pthread_mutex_lock(&mLock);
 326     if (mActiveScan == active) {
 327         pthread_mutex_unlock(&mLock);
 328         return 0;
 329     }
 330     mActiveScan = active;
 331
 332     int rc = mSupplicant->setScanMode(active);
 333     pthread_mutex_unlock(&mLock);
 334     return rc;
 335 }
 336
 337 WifiNetwork *WifiController::createNetwork() {
 338     pthread_mutex_lock(&mLock);
 339     WifiNetwork *wn = mSupplicant->createNetwork();
 340     pthread_mutex_unlock(&mLock);
 341     return wn;
 342 }
 343
 344 int WifiController::removeNetwork(int networkId) {
 345     pthread_mutex_lock(&mLock);
 346     WifiNetwork *wn = mSupplicant->lookupNetwork(networkId);
 347
 348     if (!wn) {
 349         pthread_mutex_unlock(&mLock);
 350         return -1;
 351     }
 352     int rc = mSupplicant->removeNetwork(wn);
 353     pthread_mutex_unlock(&mLock);
 354     return rc;
 355 }
 356
 357 ScanResultCollection *WifiController::createScanResults() {
 358     ScanResultCollection *d = new ScanResultCollection();
 359     ScanResultCollection::iterator i;
 360
 361     pthread_mutex_lock(&mLatestScanResultsLock);
 362     for (i = mLatestScanResults->begin(); i != mLatestScanResults->end(); ++i)
 363         d->push_back((*i)->clone());
 364
 365     pthread_mutex_unlock(&mLatestScanResultsLock);
 366     return d;
 367 }
 368
 369 WifiNetworkCollection *WifiController::createNetworkList() {
 370     return mSupplicant->createNetworkList();
 371 }
 372
 373 int WifiController::setPacketFilter(bool enable) {
 374     int rc;
 375
 376     pthread_mutex_lock(&mLock);
 377     if (enable)
 378         rc = mSupplicant->enablePacketFilter();
 379     else
 380         rc = mSupplicant->disablePacketFilter();
 381
 382     if (!rc)
 383         mPacketFilter = enable;
 384     pthread_mutex_unlock(&mLock);
 385     return rc;
 386 }
 387
 388 int WifiController::setBluetoothCoexistenceScan(bool enable) {
 389     int rc;
 390
 391     pthread_mutex_lock(&mLock);
 392
 393     if (enable)
 394         rc = mSupplicant->enableBluetoothCoexistenceScan();
 395     else
 396         rc = mSupplicant->disableBluetoothCoexistenceScan();
 397
 398     if (!rc)
 399         mBluetoothCoexScan = enable;
 400     pthread_mutex_unlock(&mLock);
 401     return rc;
 402 }
 403
 404 int WifiController::setScanOnly(bool scanOnly) {
 405     pthread_mutex_lock(&mLock);
 406     int rc = mSupplicant->setApScanMode((scanOnly ? 2 : 1));
 407     if (!rc)
 408         mScanOnly = scanOnly;
 409     if (!mSuspended) {
 410         if (scanOnly)
 411             mSupplicant->disconnect();
 412         else
 413             mSupplicant->reconnect();
 414     }
 415     pthread_mutex_unlock(&mLock);
 416     return rc;
 417 }
 418
 419 int WifiController::setBluetoothCoexistenceMode(int mode) {
 420     pthread_mutex_lock(&mLock);
 421     int rc = mSupplicant->setBluetoothCoexistenceMode(mode);
 422     if (!rc)
 423         mBluetoothCoexMode = mode;
 424     pthread_mutex_unlock(&mLock);
 425     return rc;
 426 }
 427
 428 void WifiController::onAssociatingEvent(SupplicantAssociatingEvent *evt) {
 429     LOGD("onAssociatingEvent(%s, %s, %d)",
 430          (evt->getBssid() ? evt->getBssid() : "n/a"),
 431          (evt->getSsid() ? evt->getSsid() : "n/a"),
 432          evt->getFreq());
 433 }
 434
 435 void WifiController::onAssociatedEvent(SupplicantAssociatedEvent *evt) {
 436     LOGD("onAssociatedEvent(%s)", evt->getBssid());
 437 }
 438
 439 void WifiController::onConnectedEvent(SupplicantConnectedEvent *evt) {
 440     LOGD("onConnectedEvent(%s, %d)", evt->getBssid(), evt->getReassociated());
 441     SupplicantStatus *ss = mSupplicant->getStatus();
 442     WifiNetwork *wn;
 443
 444     if (ss->getWpaState() != SupplicantState::COMPLETED) {
 445         char tmp[32];
 446
 447         LOGW("onConnected() with SupplicantState = %s!",
 448              SupplicantState::toString(ss->getWpaState(), tmp,
 449              sizeof(tmp)));
 450         return;
 451     }
 452
 453     if (ss->getId() == -1) {
 454         LOGW("onConnected() with id = -1!");
 455         return;
 456     }
 457
 458     mCurrentlyConnectedNetworkId = ss->getId();
 459     if (!(wn = mSupplicant->lookupNetwork(ss->getId()))) {
 460         LOGW("Error looking up connected network id %d (%s)",
 461              ss->getId(), strerror(errno));
 462         return;
 463     }
 464
 465     delete ss;
 466     mHandlers->onInterfaceConnected(this);
 467 }
 468
 469 void WifiController::onScanResultsEvent(SupplicantScanResultsEvent *evt) {
 470     char *reply;
 471
 472     if (!(reply = (char *) malloc(4096))) {
 473         LOGE("Out of memory");
 474         return;
 475     }
 476
 477     mNumScanResultsSinceLastStateChange++;
 478     if (mNumScanResultsSinceLastStateChange >= 3)
 479         mIsSupplicantSearching = false;
 480
 481     size_t len = 4096;
 482
 483     if (mSupplicant->sendCommand("SCAN_RESULTS", reply, &len)) {
 484         LOGW("onScanResultsEvent: Error getting scan results (%s)",
 485              strerror(errno));
 486         free(reply);
 487         return;
 488     }
 489
 490     pthread_mutex_lock(&mLatestScanResultsLock);
 491     if (!mLatestScanResults->empty()) {
 492         ScanResultCollection::iterator i;
 493
 494         for (i = mLatestScanResults->begin();
 495              i !=mLatestScanResults->end(); ++i) {
 496             delete *i;
 497         }
 498         mLatestScanResults->clear();
 499     }
 500
 501     char *linep;
 502     char *linep_next = NULL;
 503
 504     if (!strtok_r(reply, "\n", &linep_next)) {
 505         free(reply);
 506         pthread_mutex_unlock(&mLatestScanResultsLock);
 507         return;
 508     }
 509
 510     while((linep = strtok_r(NULL, "\n", &linep_next)))
 511         mLatestScanResults->push_back(new ScanResult(linep));
 512
 513     // Switch handling of scan results back to normal mode
 514     mSupplicant->setApScanMode(1);
 515
 516     char *tmp;
 517     asprintf(&tmp, "Scan results ready (%d)", mLatestScanResults->size());
 518     NetworkManager::Instance()->getBroadcaster()->
 519                                 sendBroadcast(ResponseCode::ScanResultsReady,
 520                                               tmp, false);
 521     free(tmp);
 522     pthread_mutex_unlock(&mLatestScanResultsLock);
 523     free(reply);
 524 }
 525
 526 void WifiController::onStateChangeEvent(SupplicantStateChangeEvent *evt) {
 527     char tmp[32];
 528     char tmp2[32];
 529
 530     if (evt->getState() == mSupplicantState)
 531         return;
 532
 533     LOGD("onStateChangeEvent(%s -> %s)",
 534          SupplicantState::toString(mSupplicantState, tmp, sizeof(tmp)),
 535          SupplicantState::toString(evt->getState(), tmp2, sizeof(tmp2)));
 536
 537     if (evt->getState() != SupplicantState::SCANNING) {
 538         mIsSupplicantSearching = true;
 539         mNumScanResultsSinceLastStateChange = 0;
 540     }
 541
 542     char *tmp3;
 543     asprintf(&tmp3,
 544              "Supplicant state changed from %d (%s) -> %d (%s)",
 545              mSupplicantState, tmp, evt->getState(), tmp2);
 546
 547     mSupplicantState = evt->getState();
 548
 549     if (mSupplicantState == SupplicantState::COMPLETED) {
 550         mStatusPoller->start();
 551     } else if (mStatusPoller->isStarted()) {
 552         mStatusPoller->stop();
 553     }
 554
 555     NetworkManager::Instance()->getBroadcaster()->
 556                                 sendBroadcast(ResponseCode::SupplicantStateChange,
 557                                               tmp3, false);
 558     free(tmp3);
 559 }
 560
 561 void WifiController::onConnectionTimeoutEvent(SupplicantConnectionTimeoutEvent *evt) {
 562     LOGD("onConnectionTimeoutEvent(%s)", evt->getBssid());
 563 }
 564
 565 void WifiController::onDisconnectedEvent(SupplicantDisconnectedEvent *evt) {
 566     mCurrentlyConnectedNetworkId = -1;
 567     mHandlers->onInterfaceDisconnected(this);
 568 }
 569
 570 #if 0
 571 void WifiController::onTerminatingEvent(SupplicantEvent *evt) {
 572     LOGD("onTerminatingEvent(%s)", evt->getEvent());
 573 }
 574
 575 void WifiController::onPasswordChangedEvent(SupplicantEvent *evt) {
 576     LOGD("onPasswordChangedEvent(%s)", evt->getEvent());
 577 }
 578
 579 void WifiController::onEapNotificationEvent(SupplicantEvent *evt) {
 580     LOGD("onEapNotificationEvent(%s)", evt->getEvent());
 581 }
 582
 583 void WifiController::onEapStartedEvent(SupplicantEvent *evt) {
 584     LOGD("onEapStartedEvent(%s)", evt->getEvent());
 585 }
 586
 587 void WifiController::onEapMethodEvent(SupplicantEvent *evt) {
 588     LOGD("onEapMethodEvent(%s)", evt->getEvent());
 589 }
 590
 591 void WifiController::onEapSuccessEvent(SupplicantEvent *evt) {
 592     LOGD("onEapSuccessEvent(%s)", evt->getEvent());
 593 }
 594
 595 void WifiController::onEapFailureEvent(SupplicantEvent *evt) {
 596     LOGD("onEapFailureEvent(%s)", evt->getEvent());
 597 }
 598
 599 void WifiController::onLinkSpeedEvent(SupplicantEvent *evt) {
 600     LOGD("onLinkSpeedEvent(%s)", evt->getEvent());
 601 }
 602
 603 void WifiController::onDriverStateEvent(SupplicantEvent *evt) {
 604     LOGD("onDriverStateEvent(%s)", evt->getEvent());
 605 }
 606 #endif
 607
 608 void WifiController::onStatusPollInterval() {
 609     pthread_mutex_lock(&mLock);
 610     int rssi;
 611     if (mSupplicant->getRssi(&rssi)) {
 612         LOGE("Failed to get rssi (%s)", strerror(errno));
 613         pthread_mutex_unlock(&mLock);
 614         return;
 615     }
 616
 617     if (abs(mLastRssi - rssi) > mRssiEventThreshold) {
 618         char *tmp3;
 619         asprintf(&tmp3, "RSSI changed from %d -> %d",
 620                  mLastRssi, rssi);
 621         mLastRssi = rssi;
 622         NetworkManager::Instance()->getBroadcaster()->
 623                                sendBroadcast(ResponseCode::RssiChange,
 624                                              tmp3, false);
 625         free(tmp3);
 626     }
 627
 628     int linkspeed = mSupplicant->getLinkSpeed();
 629     if (linkspeed != mLastLinkSpeed) {
 630         char *tmp3;
 631         asprintf(&tmp3, "Link speed changed from %d -> %d",
 632                  mLastLinkSpeed, linkspeed);
 633         mLastLinkSpeed = linkspeed;
 634         NetworkManager::Instance()->getBroadcaster()->
 635                                sendBroadcast(ResponseCode::LinkSpeedChange,
 636                                              tmp3, false);
 637         free(tmp3);
 638
 639     }
 640     pthread_mutex_unlock(&mLock);
 641 }
 642
 643 int WifiController::verifyNotSuspended() {
 644     if (mSuspended) {
 645         errno = ESHUTDOWN;
 646         return -1;
 647     }
 648     return 0;
 649 }
 650
 651 /*
 652  * Property inner classes
 653  */
 654
 655 WifiController::WifiIntegerProperty::WifiIntegerProperty(WifiController *c,
 656                                                          const char *name,
 657                                                          bool ro,
 658                                                          int elements) :
 659                 IntegerProperty(name, ro, elements) {
 660     mWc = c;
 661 }
 662
 663 WifiController::WifiStringProperty::WifiStringProperty(WifiController *c,
 664                                                        const char *name,
 665                                                        bool ro, int elements) :
 666                 StringProperty(name, ro, elements) {
 667     mWc = c;
 668 }
 669
 670 WifiController::WifiEnabledProperty::WifiEnabledProperty(WifiController *c) :
 671                 WifiIntegerProperty(c, "Enabled", false, 1) {
 672 }
 673
 674 int WifiController::WifiEnabledProperty::get(int idx, int *buffer) {
 675     *buffer = mWc->mEnabled;
 676     return 0;
 677 }
 678 int WifiController::WifiEnabledProperty::set(int idx, int value) {
 679     int rc = (value ? mWc->enable() : mWc->disable());
 680     if (!rc)
 681         mWc->mEnabled = value;
 682     return rc;
 683 }
 684
 685 WifiController::WifiScanOnlyProperty::WifiScanOnlyProperty(WifiController *c) :
 686                 WifiIntegerProperty(c, "ScanOnly", false, 1) {
 687 }
 688 int WifiController::WifiScanOnlyProperty::get(int idx, int *buffer) {
 689     *buffer = mWc->mScanOnly;
 690     return 0;
 691 }
 692 int WifiController::WifiScanOnlyProperty::set(int idx, int value) {
 693     return mWc->setScanOnly(value == 1);
 694 }
 695
 696 WifiController::WifiAllowedChannelsProperty::WifiAllowedChannelsProperty(WifiController *c) :
 697                 WifiIntegerProperty(c, "AllowedChannels", false, 1) {
 698 }
 699 int WifiController::WifiAllowedChannelsProperty::get(int idx, int *buffer) {
 700     *buffer = mWc->mNumAllowedChannels;
 701     return 0;
 702 }
 703 int WifiController::WifiAllowedChannelsProperty::set(int idx, int value) {
 704     // XXX: IMPL
 705     errno = ENOSYS;
 706     return -1;
 707 }
 708
 709 WifiController::WifiSupplicantStateProperty::WifiSupplicantStateProperty(WifiController *c) :
 710                 WifiStringProperty(c, "SupplicantState", true, 1) {
 711 }
 712 int WifiController::WifiSupplicantStateProperty::get(int idx, char *buffer, size_t max) {
 713     if (!SupplicantState::toString(mWc->mSupplicantState, buffer, max))
 714         return -1;
 715     return 0;
 716 }
 717
 718 WifiController::WifiActiveScanProperty::WifiActiveScanProperty(WifiController *c) :
 719                 WifiIntegerProperty(c, "ActiveScan", false, 1) {
 720 }
 721 int WifiController::WifiActiveScanProperty::get(int idx, int *buffer) {
 722     *buffer = mWc->mActiveScan;
 723     return 0;
 724 }
 725 int WifiController::WifiActiveScanProperty::set(int idx, int value) {
 726     return mWc->setActiveScan(value);
 727 }
 728
 729 WifiController::WifiInterfaceProperty::WifiInterfaceProperty(WifiController *c) :
 730                 WifiStringProperty(c, "Interface", true, 1) {
 731 }
 732 int WifiController::WifiInterfaceProperty::get(int idx, char *buffer, size_t max) {
 733     strncpy(buffer, (mWc->getBoundInterface() ? mWc->getBoundInterface() : "none"), max);
 734     return 0;
 735 }
 736
 737 WifiController::WifiSearchingProperty::WifiSearchingProperty(WifiController *c) :
 738                 WifiIntegerProperty(c, "Searching", true, 1) {
 739 }
 740 int WifiController::WifiSearchingProperty::get(int idx, int *buffer) {
 741     *buffer = mWc->mIsSupplicantSearching;
 742     return 0;
 743 }
 744
 745 WifiController::WifiPacketFilterProperty::WifiPacketFilterProperty(WifiController *c) :
 746                 WifiIntegerProperty(c, "PacketFilter", false, 1) {
 747 }
 748 int WifiController::WifiPacketFilterProperty::get(int idx, int *buffer) {
 749     *buffer = mWc->mPacketFilter;
 750     return 0;
 751 }
 752 int WifiController::WifiPacketFilterProperty::set(int idx, int value) {
 753     return mWc->setPacketFilter(value);
 754 }
 755
 756 WifiController::WifiBluetoothCoexScanProperty::WifiBluetoothCoexScanProperty(WifiController *c) :
 757                 WifiIntegerProperty(c, "BluetoothCoexScan", false, 1) {
 758 }
 759 int WifiController::WifiBluetoothCoexScanProperty::get(int idx, int *buffer) {
 760     *buffer = mWc->mBluetoothCoexScan;
 761     return 0;
 762 }
 763 int WifiController::WifiBluetoothCoexScanProperty::set(int idx, int value) {
 764     return mWc->setBluetoothCoexistenceScan(value == 1);
 765 }
 766
 767 WifiController::WifiBluetoothCoexModeProperty::WifiBluetoothCoexModeProperty(WifiController *c) :
 768                 WifiIntegerProperty(c, "BluetoothCoexMode", false, 1) {
 769 }
 770 int WifiController::WifiBluetoothCoexModeProperty::get(int idx, int *buffer) {
 771     *buffer = mWc->mBluetoothCoexMode;
 772     return 0;
 773 }
 774 int WifiController::WifiBluetoothCoexModeProperty::set(int idx, int value) {
 775     return mWc->setBluetoothCoexistenceMode(value);
 776 }
 777
 778 WifiController::WifiCurrentNetworkProperty::WifiCurrentNetworkProperty(WifiController *c) :
 779                 WifiIntegerProperty(c, "CurrentlyConnectedNetworkId", true, 1) {
 780 }
 781 int WifiController::WifiCurrentNetworkProperty::get(int idx, int *buffer) {
 782     *buffer = mWc->mCurrentlyConnectedNetworkId;
 783     return 0;
 784 }
 785
 786 WifiController::WifiSuspendedProperty::WifiSuspendedProperty(WifiController *c) :
 787                 WifiIntegerProperty(c, "Suspended", false, 1) {
 788 }
 789 int WifiController::WifiSuspendedProperty::get(int idx, int *buffer) {
 790     *buffer = mWc->getSuspended();
 791     return 0;
 792 }
 793 int WifiController::WifiSuspendedProperty::set(int idx, int value) {
 794     return mWc->setSuspend(value == 1);
 795 }
 796
 797 WifiController::WifiNetCountProperty::WifiNetCountProperty(WifiController *c) :
 798                 WifiIntegerProperty(c, "NetCount", true, 1) {
 799 }
 800 int WifiController::WifiNetCountProperty::get(int idx, int *buffer) {
 801     pthread_mutex_lock(&mWc->mLock);
 802     *buffer = mWc->mSupplicant->getNetworkCount();
 803     pthread_mutex_unlock(&mWc->mLock);
 804     return 0;
 805 }
 806
 807 WifiController::WifiTriggerScanProperty::WifiTriggerScanProperty(WifiController *c) :
 808                 WifiIntegerProperty(c, "TriggerScan", false, 1) {
 809 }
 810 int WifiController::WifiTriggerScanProperty::get(int idx, int *buffer) {
 811     // XXX: Need action type
 812     *buffer = 0;
 813     return 0;
 814 }
 815
 816 int WifiController::WifiTriggerScanProperty::set(int idx, int value) {
 817     return mWc->triggerScan();
 818 }
 819