| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <stdlib.h> |
| #include <sys/types.h> |
| #include <fcntl.h> |
| #include <errno.h> |
| |
| #define LOG_TAG "Supplicant" |
| #include <cutils/log.h> |
| #include <cutils/properties.h> |
| |
| #include "private/android_filesystem_config.h" |
| |
| #include <sysutils/ServiceManager.h> |
| |
| #include "Supplicant.h" |
| #include "SupplicantListener.h" |
| #include "SupplicantState.h" |
| #include "SupplicantEvent.h" |
| #include "ScanResult.h" |
| #include "NetworkManager.h" |
| #include "ErrorCode.h" |
| |
| #include "libwpa_client/wpa_ctrl.h" |
| |
| #define IFACE_DIR "/data/system/wpa_supplicant" |
| #define DRIVER_PROP_NAME "wlan.driver.status" |
| #define SUPPLICANT_SERVICE_NAME "wpa_supplicant" |
| #define SUPP_CONFIG_TEMPLATE "/system/etc/wifi/wpa_supplicant.conf" |
| #define SUPP_CONFIG_FILE "/data/misc/wifi/wpa_supplicant.conf" |
| |
| Supplicant::Supplicant() { |
| mCtrl = NULL; |
| mMonitor = NULL; |
| mListener = NULL; |
| |
| mState = SupplicantState::UNKNOWN; |
| |
| mServiceManager = new ServiceManager(); |
| |
| mLatestScanResults = new ScanResultCollection(); |
| pthread_mutex_init(&mLatestScanResultsLock, NULL); |
| } |
| |
| Supplicant::~Supplicant() { |
| delete mServiceManager; |
| } |
| |
| int Supplicant::start() { |
| |
| if (setupConfig()) { |
| LOGW("Unable to setup supplicant.conf"); |
| } |
| |
| if (mServiceManager->start(SUPPLICANT_SERVICE_NAME)) { |
| LOGE("Error starting supplicant (%s)", strerror(errno)); |
| return -1; |
| } |
| |
| wpa_ctrl_cleanup(); |
| if (connectToSupplicant()) { |
| LOGE("Error connecting to supplicant (%s)\n", strerror(errno)); |
| return -1; |
| } |
| return 0; |
| } |
| |
| int Supplicant::stop() { |
| |
| if (mListener->stopListener()) { |
| LOGW("Unable to stop supplicant listener (%s)", strerror(errno)); |
| return -1; |
| } |
| |
| if (mServiceManager->stop(SUPPLICANT_SERVICE_NAME)) { |
| LOGW("Error stopping supplicant (%s)", strerror(errno)); |
| } |
| |
| if (mCtrl) { |
| wpa_ctrl_close(mCtrl); |
| mCtrl = NULL; |
| } |
| if (mMonitor) { |
| wpa_ctrl_close(mMonitor); |
| mMonitor = NULL; |
| } |
| |
| return 0; |
| } |
| |
| bool Supplicant::isStarted() { |
| return mServiceManager->isRunning(SUPPLICANT_SERVICE_NAME); |
| } |
| |
| int Supplicant::connectToSupplicant() { |
| if (!isStarted()) { |
| LOGE("Supplicant not running, cannot connect"); |
| return -1; |
| } |
| |
| mCtrl = wpa_ctrl_open("tiwlan0"); |
| if (mCtrl == NULL) { |
| LOGE("Unable to open connection to supplicant on \"%s\": %s", |
| "tiwlan0", strerror(errno)); |
| return -1; |
| } |
| mMonitor = wpa_ctrl_open("tiwlan0"); |
| if (mMonitor == NULL) { |
| wpa_ctrl_close(mCtrl); |
| mCtrl = NULL; |
| return -1; |
| } |
| if (wpa_ctrl_attach(mMonitor) != 0) { |
| wpa_ctrl_close(mMonitor); |
| wpa_ctrl_close(mCtrl); |
| mCtrl = mMonitor = NULL; |
| return -1; |
| } |
| |
| mListener = new SupplicantListener(this, mMonitor); |
| |
| if (mListener->startListener()) { |
| LOGE("Error - unable to start supplicant listener"); |
| stop(); |
| return -1; |
| } |
| return 0; |
| } |
| |
| int Supplicant::sendCommand(const char *cmd, char *reply, size_t *reply_len) |
| { |
| if (!mCtrl) { |
| errno = ENOTCONN; |
| return -1; |
| } |
| |
| // LOGD("sendCommand(): -> '%s'", cmd); |
| |
| int rc; |
| if ((rc = wpa_ctrl_request(mCtrl, cmd, strlen(cmd), reply, reply_len, NULL)) == -2) { |
| errno = ETIMEDOUT; |
| return -1; |
| } else if (rc < 0 || !strncmp(reply, "FAIL", 4)) { |
| LOGW("sendCommand(): <- '%s'", reply); |
| errno = EIO; |
| return -1; |
| } |
| |
| if (!strncmp(cmd, "PING", 4) || |
| !strncmp(cmd, "SCAN_RESULTS", 12)) |
| reply[*reply_len] = '\0'; |
| |
| // LOGD("sendCommand(): <- '%s'", reply); |
| return 0; |
| } |
| |
| int Supplicant::triggerScan(bool active) { |
| char reply[255]; |
| size_t len = sizeof(reply); |
| |
| if (sendCommand((active ? "DRIVER SCAN-ACTIVE" : "DRIVER SCAN-PASSIVE"), |
| reply, &len)) { |
| LOGW("triggerScan(%d): Error setting scan mode (%s)", active, |
| strerror(errno)); |
| return -1; |
| } |
| len = sizeof(reply); |
| |
| if (sendCommand("SCAN", reply, &len)) { |
| LOGW("triggerScan(%d): Error initiating scan", active); |
| return -1; |
| } |
| return 0; |
| } |
| |
| int Supplicant::onConnectedEvent(SupplicantEvent *evt) { |
| LOGD("onConnectedEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| int Supplicant::onDisconnectedEvent(SupplicantEvent *evt) { |
| LOGD("onDisconnectedEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| int Supplicant::onTerminatingEvent(SupplicantEvent *evt) { |
| LOGD("onTerminatingEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| int Supplicant::onPasswordChangedEvent(SupplicantEvent *evt) { |
| LOGD("onPasswordChangedEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| int Supplicant::onEapNotificationEvent(SupplicantEvent *evt) { |
| LOGD("onEapNotificationEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| int Supplicant::onEapStartedEvent(SupplicantEvent *evt) { |
| LOGD("onEapStartedEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| int Supplicant::onEapMethodEvent(SupplicantEvent *evt) { |
| LOGD("onEapMethodEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| int Supplicant::onEapSuccessEvent(SupplicantEvent *evt) { |
| LOGD("onEapSuccessEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| int Supplicant::onEapFailureEvent(SupplicantEvent *evt) { |
| LOGD("onEapFailureEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| int Supplicant::onScanResultsEvent(SupplicantEvent *evt) { |
| if (!strcmp(evt->getEvent(), "Ready")) { |
| char *reply; |
| |
| if (!(reply = (char *) malloc(4096))) { |
| errno = -ENOMEM; |
| return -1; |
| } |
| |
| size_t len = 4096; |
| |
| if (sendCommand("SCAN_RESULTS", reply, &len)) { |
| LOGW("onScanResultsEvent(%s): Error getting scan results (%s)", |
| evt->getEvent(), strerror(errno)); |
| free(reply); |
| return -1; |
| } |
| |
| pthread_mutex_lock(&mLatestScanResultsLock); |
| if (!mLatestScanResults->empty()) { |
| ScanResultCollection::iterator i; |
| |
| for (i = mLatestScanResults->begin(); |
| i !=mLatestScanResults->end(); ++i) { |
| delete *i; |
| } |
| mLatestScanResults->clear(); |
| } |
| |
| char *linep; |
| char *linep_next = NULL; |
| |
| if (!strtok_r(reply, "\n", &linep_next)) { |
| free(reply); |
| pthread_mutex_unlock(&mLatestScanResultsLock); |
| return 0; |
| } |
| |
| while((linep = strtok_r(NULL, "\n", &linep_next))) |
| mLatestScanResults->push_back(new ScanResult(linep)); |
| |
| char tmp[128]; |
| sprintf(tmp, "Scan results ready (%d)", mLatestScanResults->size()); |
| NetworkManager::Instance()->getBroadcaster()-> |
| sendBroadcast(ErrorCode::UnsolicitedInformational, tmp, false); |
| pthread_mutex_unlock(&mLatestScanResultsLock); |
| free(reply); |
| } else { |
| LOGW("Unknown SCAN_RESULTS event (%s)", evt->getEvent()); |
| } |
| return 0; |
| } |
| |
| int Supplicant::onStateChangeEvent(SupplicantEvent *evt) { |
| char *bword, *last; |
| char *tmp = strdup(evt->getEvent()); |
| |
| if (!(bword = strtok_r(tmp, " ", &last))) { |
| LOGE("Malformatted state update (%s)", evt->getEvent()); |
| free(tmp); |
| return 0; |
| } |
| |
| if (!(bword = strtok_r(NULL, " ", &last))) { |
| LOGE("Malformatted state update (%s)", evt->getEvent()); |
| free(tmp); |
| return 0; |
| } |
| |
| mState = atoi(&bword[strlen("state=")]); |
| LOGD("State changed to %d", mState); |
| free(tmp); |
| return 0; |
| } |
| |
| int Supplicant::onLinkSpeedEvent(SupplicantEvent *evt) { |
| LOGD("onLinkSpeedEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| int Supplicant::onDriverStateEvent(SupplicantEvent *evt) { |
| LOGD("onDriverStateEvent(%s)", evt->getEvent()); |
| return 0; |
| } |
| |
| // XXX: Use a cursor + smartptr instead |
| ScanResultCollection *Supplicant::createLatestScanResults() { |
| ScanResultCollection *d = new ScanResultCollection(); |
| ScanResultCollection::iterator i; |
| |
| pthread_mutex_lock(&mLatestScanResultsLock); |
| for (i = mLatestScanResults->begin(); i != mLatestScanResults->end(); ++i) { |
| d->push_back((*i)->clone()); |
| } |
| |
| pthread_mutex_unlock(&mLatestScanResultsLock); |
| return d; |
| } |
| |
| WifiNetworkCollection *Supplicant::createNetworkList() { |
| WifiNetworkCollection *d = new WifiNetworkCollection(); |
| return d; |
| } |
| |
| int Supplicant::addNetwork() { |
| char reply[32]; |
| size_t len = sizeof(reply) -1; |
| |
| memset(reply, 0, sizeof(reply)); |
| if (sendCommand("ADD_NETWORK", reply, &len)) |
| return -1; |
| |
| return atoi(reply); |
| } |
| |
| int Supplicant::removeNetwork(int networkId) { |
| char req[64]; |
| |
| sprintf(req, "REMOVE_NETWORK %d", networkId); |
| char reply[32]; |
| size_t len = sizeof(reply) -1; |
| memset(reply, 0, sizeof(reply)); |
| |
| if (sendCommand(req, reply, &len)) |
| return -1; |
| return 0; |
| } |
| |
| int Supplicant::setupConfig() { |
| char buf[2048]; |
| int srcfd, destfd; |
| int nread; |
| |
| if (access(SUPP_CONFIG_FILE, R_OK|W_OK) == 0) { |
| return 0; |
| } else if (errno != ENOENT) { |
| LOGE("Cannot access \"%s\": %s", SUPP_CONFIG_FILE, strerror(errno)); |
| return -1; |
| } |
| |
| srcfd = open(SUPP_CONFIG_TEMPLATE, O_RDONLY); |
| if (srcfd < 0) { |
| LOGE("Cannot open \"%s\": %s", SUPP_CONFIG_TEMPLATE, strerror(errno)); |
| return -1; |
| } |
| |
| destfd = open(SUPP_CONFIG_FILE, O_CREAT|O_WRONLY, 0660); |
| if (destfd < 0) { |
| close(srcfd); |
| LOGE("Cannot create \"%s\": %s", SUPP_CONFIG_FILE, strerror(errno)); |
| return -1; |
| } |
| |
| while ((nread = read(srcfd, buf, sizeof(buf))) != 0) { |
| if (nread < 0) { |
| LOGE("Error reading \"%s\": %s", SUPP_CONFIG_TEMPLATE, strerror(errno)); |
| close(srcfd); |
| close(destfd); |
| unlink(SUPP_CONFIG_FILE); |
| return -1; |
| } |
| write(destfd, buf, nread); |
| } |
| |
| close(destfd); |
| close(srcfd); |
| |
| if (chown(SUPP_CONFIG_FILE, AID_SYSTEM, AID_WIFI) < 0) { |
| LOGE("Error changing group ownership of %s to %d: %s", |
| SUPP_CONFIG_FILE, AID_WIFI, strerror(errno)); |
| unlink(SUPP_CONFIG_FILE); |
| return -1; |
| } |
| return 0; |
| } |