diff options
Diffstat (limited to 'dom/wifi/WifiWorker.js')
| -rw-r--r-- | dom/wifi/WifiWorker.js | 3928 |
1 files changed, 3928 insertions, 0 deletions
diff --git a/dom/wifi/WifiWorker.js b/dom/wifi/WifiWorker.js new file mode 100644 index 000000000..243ba8b97 --- /dev/null +++ b/dom/wifi/WifiWorker.js @@ -0,0 +1,3928 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/systemlibs.js"); +Cu.import("resource://gre/modules/FileUtils.jsm"); +Cu.import("resource://gre/modules/WifiCommand.jsm"); +Cu.import("resource://gre/modules/WifiNetUtil.jsm"); +Cu.import("resource://gre/modules/WifiP2pManager.jsm"); +Cu.import("resource://gre/modules/WifiP2pWorkerObserver.jsm"); + +var DEBUG = false; // set to true to show debug messages. + +const WIFIWORKER_CONTRACTID = "@mozilla.org/wifi/worker;1"; +const WIFIWORKER_CID = Components.ID("{a14e8977-d259-433a-a88d-58dd44657e5b}"); + +const WIFIWORKER_WORKER = "resource://gre/modules/wifi_worker.js"; + +const kMozSettingsChangedObserverTopic = "mozsettings-changed"; + +const MAX_RETRIES_ON_AUTHENTICATION_FAILURE = 2; +const MAX_SUPPLICANT_LOOP_ITERATIONS = 4; +const MAX_RETRIES_ON_DHCP_FAILURE = 2; + +// Settings DB path for wifi +const SETTINGS_WIFI_ENABLED = "wifi.enabled"; +const SETTINGS_WIFI_DEBUG_ENABLED = "wifi.debugging.enabled"; +// Settings DB path for Wifi tethering. +const SETTINGS_WIFI_TETHERING_ENABLED = "tethering.wifi.enabled"; +const SETTINGS_WIFI_SSID = "tethering.wifi.ssid"; +const SETTINGS_WIFI_SECURITY_TYPE = "tethering.wifi.security.type"; +const SETTINGS_WIFI_SECURITY_PASSWORD = "tethering.wifi.security.password"; +const SETTINGS_WIFI_IP = "tethering.wifi.ip"; +const SETTINGS_WIFI_PREFIX = "tethering.wifi.prefix"; +const SETTINGS_WIFI_DHCPSERVER_STARTIP = "tethering.wifi.dhcpserver.startip"; +const SETTINGS_WIFI_DHCPSERVER_ENDIP = "tethering.wifi.dhcpserver.endip"; +const SETTINGS_WIFI_DNS1 = "tethering.wifi.dns1"; +const SETTINGS_WIFI_DNS2 = "tethering.wifi.dns2"; + +// Settings DB path for USB tethering. +const SETTINGS_USB_DHCPSERVER_STARTIP = "tethering.usb.dhcpserver.startip"; +const SETTINGS_USB_DHCPSERVER_ENDIP = "tethering.usb.dhcpserver.endip"; + +// Default value for WIFI tethering. +const DEFAULT_WIFI_IP = "192.168.1.1"; +const DEFAULT_WIFI_PREFIX = "24"; +const DEFAULT_WIFI_DHCPSERVER_STARTIP = "192.168.1.10"; +const DEFAULT_WIFI_DHCPSERVER_ENDIP = "192.168.1.30"; +const DEFAULT_WIFI_SSID = "FirefoxHotspot"; +const DEFAULT_WIFI_SECURITY_TYPE = "open"; +const DEFAULT_WIFI_SECURITY_PASSWORD = "1234567890"; +const DEFAULT_DNS1 = "8.8.8.8"; +const DEFAULT_DNS2 = "8.8.4.4"; + +// Default value for USB tethering. +const DEFAULT_USB_DHCPSERVER_STARTIP = "192.168.0.10"; +const DEFAULT_USB_DHCPSERVER_ENDIP = "192.168.0.30"; + +const WIFI_FIRMWARE_AP = "AP"; +const WIFI_FIRMWARE_STATION = "STA"; +const WIFI_SECURITY_TYPE_NONE = "open"; +const WIFI_SECURITY_TYPE_WPA_PSK = "wpa-psk"; +const WIFI_SECURITY_TYPE_WPA2_PSK = "wpa2-psk"; + +const NETWORK_INTERFACE_UP = "up"; +const NETWORK_INTERFACE_DOWN = "down"; + +const DEFAULT_WLAN_INTERFACE = "wlan0"; + +const DRIVER_READY_WAIT = 2000; + +const SUPP_PROP = "init.svc.wpa_supplicant"; +const WPA_SUPPLICANT = "wpa_supplicant"; +const DHCP_PROP = "init.svc.dhcpcd"; +const DHCP = "dhcpcd"; + +const MODE_ESS = 0; +const MODE_IBSS = 1; + +XPCOMUtils.defineLazyServiceGetter(this, "gNetworkManager", + "@mozilla.org/network/manager;1", + "nsINetworkManager"); + +XPCOMUtils.defineLazyServiceGetter(this, "gNetworkService", + "@mozilla.org/network/service;1", + "nsINetworkService"); + +XPCOMUtils.defineLazyServiceGetter(this, "gSettingsService", + "@mozilla.org/settingsService;1", + "nsISettingsService"); + +XPCOMUtils.defineLazyServiceGetter(this, "gTetheringService", + "@mozilla.org/tethering/service;1", + "nsITetheringService"); + +// A note about errors and error handling in this file: +// The libraries that we use in this file are intended for C code. For +// C code, it is natural to return -1 for errors and 0 for success. +// Therefore, the code that interacts directly with the worker uses this +// convention (note: command functions do get boolean results since the +// command always succeeds and we do a string/boolean check for the +// expected results). +var WifiManager = (function() { + var manager = {}; + + function getStartupPrefs() { + return { + sdkVersion: parseInt(libcutils.property_get("ro.build.version.sdk"), 10), + unloadDriverEnabled: libcutils.property_get("ro.moz.wifi.unloaddriver") === "1", + schedScanRecovery: libcutils.property_get("ro.moz.wifi.sched_scan_recover") === "false" ? false : true, + driverDelay: libcutils.property_get("ro.moz.wifi.driverDelay"), + p2pSupported: libcutils.property_get("ro.moz.wifi.p2p_supported") === "1", + eapSimSupported: libcutils.property_get("ro.moz.wifi.eapsim_supported") === "1", + ibssSupported: libcutils.property_get("ro.moz.wifi.ibss_supported", "true") === "true", + ifname: libcutils.property_get("wifi.interface") + }; + } + + let {sdkVersion, unloadDriverEnabled, schedScanRecovery, + driverDelay, p2pSupported, eapSimSupported, ibssSupported, ifname} = getStartupPrefs(); + + let capabilities = { + security: ["OPEN", "WEP", "WPA-PSK", "WPA-EAP"], + eapMethod: ["PEAP", "TTLS", "TLS"], + eapPhase2: ["MSCHAPV2"], + certificate: ["SERVER"], + mode: [MODE_ESS] + }; + if (eapSimSupported) { + capabilities.eapMethod.unshift("SIM"); + } + if (ibssSupported) { + capabilities.mode.push(MODE_IBSS); + } + + let wifiListener = { + onWaitEvent: function(event, iface) { + if (manager.ifname === iface && handleEvent(event)) { + waitForEvent(iface); + } else if (p2pSupported) { + // Please refer to + // http://androidxref.com/4.4.2_r1/xref/frameworks/base/wifi/java/android/net/wifi/WifiMonitor.java#519 + // for interface event mux/demux rules. In short words, both + // 'p2p0' and 'p2p-' should go to Wifi P2P state machine. + if (WifiP2pManager.INTERFACE_NAME === iface || -1 !== iface.indexOf('p2p-')) { + // If the connection is closed, wifi.c::wifi_wait_for_event() + // will still return 'CTRL-EVENT-TERMINATING - connection closed' + // rather than blocking. So when we see this special event string, + // just return immediately. + const TERMINATED_EVENT = 'CTRL-EVENT-TERMINATING - connection closed'; + if (-1 !== event.indexOf(TERMINATED_EVENT)) { + return; + } + p2pManager.handleEvent(event); + waitForEvent(iface); + } + } + }, + + onCommand: function(event, iface) { + onmessageresult(event, iface); + } + } + + manager.ifname = ifname; + manager.connectToSupplicant = false; + // Emulator build runs to here. + // The debug() should only be used after WifiManager. + if (!ifname) { + manager.ifname = DEFAULT_WLAN_INTERFACE; + } + manager.schedScanRecovery = schedScanRecovery; + manager.driverDelay = driverDelay ? parseInt(driverDelay, 10) : DRIVER_READY_WAIT; + + // Regular Wifi stuff. + var netUtil = WifiNetUtil(controlMessage); + var wifiCommand = WifiCommand(controlMessage, manager.ifname, sdkVersion); + + // Wifi P2P stuff + var p2pManager; + if (p2pSupported) { + let p2pCommand = WifiCommand(controlMessage, WifiP2pManager.INTERFACE_NAME, sdkVersion); + p2pManager = WifiP2pManager(p2pCommand, netUtil); + } + + let wifiService = Cc["@mozilla.org/wifi/service;1"]; + if (wifiService) { + wifiService = wifiService.getService(Ci.nsIWifiProxyService); + let interfaces = [manager.ifname]; + if (p2pSupported) { + interfaces.push(WifiP2pManager.INTERFACE_NAME); + } + wifiService.start(wifiListener, interfaces, interfaces.length); + } else { + debug("No wifi service component available!"); + } + + // Callbacks to invoke when a reply arrives from the wifi service. + var controlCallbacks = Object.create(null); + var idgen = 0; + + function controlMessage(obj, callback) { + var id = idgen++; + obj.id = id; + if (callback) { + controlCallbacks[id] = callback; + } + wifiService.sendCommand(obj, obj.iface); + } + + let onmessageresult = function(data, iface) { + var id = data.id; + var callback = controlCallbacks[id]; + if (callback) { + callback(data); + delete controlCallbacks[id]; + } + } + + // Polling the status worker + var recvErrors = 0; + + function waitForEvent(iface) { + wifiService.waitForEvent(iface); + } + + // Commands to the control worker. + + var driverLoaded = false; + + function loadDriver(callback) { + if (driverLoaded) { + callback(0); + return; + } + + wifiCommand.loadDriver(function (status) { + driverLoaded = (status >= 0); + callback(status) + }); + } + + function unloadDriver(type, callback) { + if (!unloadDriverEnabled) { + // Unloading drivers is generally unnecessary and + // can trigger bugs in some drivers. + // On properly written drivers, bringing the interface + // down powers down the interface. + if (type === WIFI_FIRMWARE_STATION) { + notify("supplicantlost", { success: true }); + } + callback(0); + return; + } + + wifiCommand.unloadDriver(function(status) { + driverLoaded = (status < 0); + if (type === WIFI_FIRMWARE_STATION) { + notify("supplicantlost", { success: true }); + } + callback(status); + }); + } + + // A note about background scanning: + // Normally, background scanning shouldn't be necessary as wpa_supplicant + // has the capability to automatically schedule its own scans at appropriate + // intervals. However, with some drivers, this appears to get stuck after + // three scans, so we enable the driver's background scanning to work around + // that when we're not connected to any network. This ensures that we'll + // automatically reconnect to networks if one falls out of range. + var reEnableBackgroundScan = false; + + // NB: This is part of the internal API. + manager.backgroundScanEnabled = false; + function setBackgroundScan(enable, callback) { + var doEnable = (enable === "ON"); + if (doEnable === manager.backgroundScanEnabled) { + callback(false, true); + return; + } + + manager.backgroundScanEnabled = doEnable; + wifiCommand.setBackgroundScan(manager.backgroundScanEnabled, callback); + } + + var scanModeActive = false; + + function scan(forceActive, callback) { + if (forceActive && !scanModeActive) { + // Note: we ignore errors from doSetScanMode. + wifiCommand.doSetScanMode(true, function(ignore) { + setBackgroundScan("OFF", function(turned, ignore) { + reEnableBackgroundScan = turned; + manager.handlePreWifiScan(); + wifiCommand.scan(function(ok) { + wifiCommand.doSetScanMode(false, function(ignore) { + // The result of scanCommand is the result of the actual SCAN + // request. + callback(ok); + }); + }); + }); + }); + return; + } + manager.handlePreWifiScan(); + wifiCommand.scan(callback); + } + + var debugEnabled = false; + + function syncDebug() { + if (debugEnabled !== DEBUG) { + let wanted = DEBUG; + wifiCommand.setLogLevel(wanted ? "DEBUG" : "INFO", function(ok) { + if (ok) + debugEnabled = wanted; + }); + if (p2pSupported && p2pManager) { + p2pManager.setDebug(DEBUG); + } + } + } + + function getDebugEnabled(callback) { + wifiCommand.getLogLevel(function(level) { + if (level === null) { + debug("Unable to get wpa_supplicant's log level"); + callback(false); + return; + } + + var lines = level.split("\n"); + for (let i = 0; i < lines.length; ++i) { + let match = /Current level: (.*)/.exec(lines[i]); + if (match) { + debugEnabled = match[1].toLowerCase() === "debug"; + callback(true); + return; + } + } + + // If we're here, we didn't get the current level. + callback(false); + }); + } + + function setScanMode(setActive, callback) { + scanModeActive = setActive; + wifiCommand.doSetScanMode(setActive, callback); + } + + var httpProxyConfig = Object.create(null); + + /** + * Given a network, configure http proxy when using wifi. + * @param network A network object to update http proxy + * @param info Info should have following field: + * - httpProxyHost ip address of http proxy. + * - httpProxyPort port of http proxy, set 0 to use default port 8080. + * @param callback callback function. + */ + function configureHttpProxy(network, info, callback) { + if (!network) + return; + + let networkKey = getNetworkKey(network); + + if (!info || info.httpProxyHost === "") { + delete httpProxyConfig[networkKey]; + } else { + httpProxyConfig[networkKey] = network; + httpProxyConfig[networkKey].httpProxyHost = info.httpProxyHost; + httpProxyConfig[networkKey].httpProxyPort = info.httpProxyPort; + } + + callback(true); + } + + function getHttpProxyNetwork(network) { + if (!network) + return null; + + let networkKey = getNetworkKey(network); + return httpProxyConfig[networkKey]; + } + + function setHttpProxy(network) { + if (!network) + return; + + // If we got here, arg network must be the currentNetwork, so we just update + // WifiNetworkInterface correspondingly and notify NetworkManager. + WifiNetworkInterface.httpProxyHost = network.httpProxyHost; + WifiNetworkInterface.httpProxyPort = network.httpProxyPort; + + if (WifiNetworkInterface.info.state == + Ci.nsINetworkInfo.NETWORK_STATE_CONNECTED) { + gNetworkManager.updateNetworkInterface(WifiNetworkInterface); + } + } + + var staticIpConfig = Object.create(null); + function setStaticIpMode(network, info, callback) { + let setNetworkKey = getNetworkKey(network); + let curNetworkKey = null; + let currentNetwork = Object.create(null); + currentNetwork.netId = manager.connectionInfo.id; + + manager.getNetworkConfiguration(currentNetwork, function () { + curNetworkKey = getNetworkKey(currentNetwork); + + // Add additional information to static ip configuration + // It is used to compatiable with information dhcp callback. + info.ipaddr = netHelpers.stringToIP(info.ipaddr_str); + info.gateway = netHelpers.stringToIP(info.gateway_str); + info.mask_str = netHelpers.ipToString(netHelpers.makeMask(info.maskLength)); + + // Optional + info.dns1 = netHelpers.stringToIP(info.dns1_str); + info.dns2 = netHelpers.stringToIP(info.dns2_str); + info.proxy = netHelpers.stringToIP(info.proxy_str); + + staticIpConfig[setNetworkKey] = info; + + // If the ssid of current connection is the same as configured ssid + // It means we need update current connection to use static IP address. + if (setNetworkKey == curNetworkKey) { + // Use configureInterface directly doesn't work, the network interface + // and routing table is changed but still cannot connect to network + // so the workaround here is disable interface the enable again to + // trigger network reconnect with static ip. + gNetworkService.disableInterface(manager.ifname, function (ok) { + gNetworkService.enableInterface(manager.ifname, function (ok) { + callback(ok); + }); + }); + return; + } + + callback(true); + }); + } + + var dhcpInfo = null; + + function runStaticIp(ifname, key) { + debug("Run static ip"); + + // Read static ip information from settings. + let staticIpInfo; + + if (!(key in staticIpConfig)) + return; + + staticIpInfo = staticIpConfig[key]; + + // Stop dhcpd when use static IP + if (dhcpInfo != null) { + netUtil.stopDhcp(manager.ifname, function() {}); + } + + // Set ip, mask length, gateway, dns to network interface + gNetworkService.configureInterface( { ifname: ifname, + ipaddr: staticIpInfo.ipaddr, + mask: staticIpInfo.maskLength, + gateway: staticIpInfo.gateway, + dns1: staticIpInfo.dns1, + dns2: staticIpInfo.dns2 }, function (data) { + netUtil.runIpConfig(ifname, staticIpInfo, function(data) { + dhcpInfo = data.info; + notify("networkconnected", data); + }); + }); + } + + var suppressEvents = false; + function notify(eventName, eventObject) { + if (suppressEvents) + return; + var handler = manager["on" + eventName]; + if (handler) { + if (!eventObject) + eventObject = ({}); + handler.call(eventObject); + } + } + + function notifyStateChange(fields) { + // If we're already in the COMPLETED state, we might receive events from + // the supplicant that tell us that we're re-authenticating or reminding + // us that we're associated to a network. In those cases, we don't need to + // do anything, so just ignore them. + if (manager.state === "COMPLETED" && + fields.state !== "DISCONNECTED" && + fields.state !== "INTERFACE_DISABLED" && + fields.state !== "INACTIVE" && + fields.state !== "SCANNING") { + return false; + } + + // Stop background scanning if we're trying to connect to a network. + if (manager.backgroundScanEnabled && + (fields.state === "ASSOCIATING" || + fields.state === "ASSOCIATED" || + fields.state === "FOUR_WAY_HANDSHAKE" || + fields.state === "GROUP_HANDSHAKE" || + fields.state === "COMPLETED")) { + setBackgroundScan("OFF", function() {}); + } + + fields.prevState = manager.state; + // Detect wpa_supplicant's loop iterations. + manager.supplicantLoopDetection(fields.prevState, fields.state); + notify("statechange", fields); + + // Don't update state when and after disabling. + if (manager.state === "DISABLING" || + manager.state === "UNINITIALIZED") { + return false; + } + + manager.state = fields.state; + return true; + } + + function parseStatus(status) { + if (status === null) { + debug("Unable to get wpa supplicant's status"); + return; + } + + var ssid; + var bssid; + var state; + var ip_address; + var id; + + var lines = status.split("\n"); + for (let i = 0; i < lines.length; ++i) { + let [key, value] = lines[i].split("="); + switch (key) { + case "wpa_state": + state = value; + break; + case "ssid": + ssid = value; + break; + case "bssid": + bssid = value; + break; + case "ip_address": + ip_address = value; + break; + case "id": + id = value; + break; + } + } + + if (bssid && ssid) { + manager.connectionInfo.bssid = bssid; + manager.connectionInfo.ssid = ssid; + manager.connectionInfo.id = id; + } + + if (ip_address) + dhcpInfo = { ip_address: ip_address }; + + notifyStateChange({ state: state, fromStatus: true }); + + // If we parse the status and the supplicant has already entered the + // COMPLETED state, then we need to set up DHCP right away. + if (state === "COMPLETED") + onconnected(); + } + + // try to connect to the supplicant + var connectTries = 0; + var retryTimer = null; + function connectCallback(ok) { + if (ok === 0) { + // Tell the event worker to start waiting for events. + retryTimer = null; + connectTries = 0; + recvErrors = 0; + manager.connectToSupplicant = true; + didConnectSupplicant(function(){}); + return; + } + if (connectTries++ < 5) { + // Try again in 1 seconds. + if (!retryTimer) + retryTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + + retryTimer.initWithCallback(function(timer) { + wifiCommand.connectToSupplicant(connectCallback); + }, 1000, Ci.nsITimer.TYPE_ONE_SHOT); + return; + } + + retryTimer = null; + connectTries = 0; + notify("supplicantlost", { success: false }); + } + + manager.connectionDropped = function(callback) { + // Reset network interface when connection drop + gNetworkService.configureInterface( { ifname: manager.ifname, + ipaddr: 0, + mask: 0, + gateway: 0, + dns1: 0, + dns2: 0 }, function (data) { + }); + + // If we got disconnected, kill the DHCP client in preparation for + // reconnection. + gNetworkService.resetConnections(manager.ifname, function() { + netUtil.stopDhcp(manager.ifname, function() { + callback(); + }); + }); + } + + manager.start = function() { + debug("detected SDK version " + sdkVersion); + wifiCommand.connectToSupplicant(connectCallback); + } + + let dhcpRequestGen = 0; + + function onconnected() { + // For now we do our own DHCP. In the future, this should be handed + // off to the Network Manager. + let currentNetwork = Object.create(null); + currentNetwork.netId = manager.connectionInfo.id; + + manager.getNetworkConfiguration(currentNetwork, function (){ + let key = getNetworkKey(currentNetwork); + if (staticIpConfig && + (key in staticIpConfig) && + staticIpConfig[key].enabled) { + debug("Run static ip"); + runStaticIp(manager.ifname, key); + return; + } + netUtil.runDhcp(manager.ifname, dhcpRequestGen++, function(data, gen) { + dhcpInfo = data.info; + debug('dhcpRequestGen: ' + dhcpRequestGen + ', gen: ' + gen); + if (!dhcpInfo) { + if (gen + 1 < dhcpRequestGen) { + debug('Do not bother younger DHCP request.'); + return; + } + if (++manager.dhcpFailuresCount >= MAX_RETRIES_ON_DHCP_FAILURE) { + manager.dhcpFailuresCount = 0; + notify("disconnected", {connectionInfo: manager.connectionInfo}); + return; + } + // NB: We have to call disconnect first. Otherwise, we only reauth with + // the existing AP and don't retrigger DHCP. + manager.disconnect(function() { + manager.reassociate(function(){}); + }); + return; + } + + manager.dhcpFailuresCount = 0; + notify("networkconnected", data); + }); + }); + } + + var supplicantStatesMap = (sdkVersion >= 15) ? + ["DISCONNECTED", "INTERFACE_DISABLED", "INACTIVE", "SCANNING", + "AUTHENTICATING", "ASSOCIATING", "ASSOCIATED", "FOUR_WAY_HANDSHAKE", + "GROUP_HANDSHAKE", "COMPLETED"] + : + ["DISCONNECTED", "INACTIVE", "SCANNING", "ASSOCIATING", + "ASSOCIATED", "FOUR_WAY_HANDSHAKE", "GROUP_HANDSHAKE", + "COMPLETED", "DORMANT", "UNINITIALIZED"]; + + var driverEventMap = { STOPPED: "driverstopped", STARTED: "driverstarted", HANGED: "driverhung" }; + + manager.getNetworkId = function (ssid, callback) { + manager.getConfiguredNetworks(function(networks) { + if (!networks) { + debug("Unable to get configured networks"); + return callback(null); + } + for (let net in networks) { + let network = networks[net]; + // Trying to get netId from + // 1. network matching SSID if SSID is provided. + // 2. current network if no SSID is provided, it's not guaranteed that + // current network matches requested SSID. + if ((!ssid && network.status === "CURRENT") || + (ssid && network.ssid && ssid === dequote(network.ssid))) { + return callback(net); + } + } + callback(null); + }); + } + + function handleWpaEapEvents(event) { + if (event.indexOf("CTRL-EVENT-EAP-FAILURE") !== -1) { + if (event.indexOf("EAP authentication failed") !== -1) { + notify("passwordmaybeincorrect"); + if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) { + manager.authenticationFailuresCount = 0; + notify("disconnected", {connectionInfo: manager.connectionInfo}); + } + } + return true; + } + if (event.indexOf("CTRL-EVENT-EAP-TLS-CERT-ERROR") !== -1) { + // Cert Error + notify("passwordmaybeincorrect"); + if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) { + manager.authenticationFailuresCount = 0; + notify("disconnected", {connectionInfo: manager.connectionInfo}); + } + return true; + } + if (event.indexOf("CTRL-EVENT-EAP-STARTED") !== -1) { + notifyStateChange({ state: "AUTHENTICATING" }); + return true; + } + return true; + } + + // Handle events sent to us by the event worker. + function handleEvent(event) { + debug("Event coming in: " + event); + if (event.indexOf("CTRL-EVENT-") !== 0 && event.indexOf("WPS") !== 0) { + // Handle connection fail exception on WEP-128, while password length + // is not 5 nor 13 bytes. + if (event.indexOf("Association request to the driver failed") !== -1) { + notify("passwordmaybeincorrect"); + if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) { + manager.authenticationFailuresCount = 0; + notify("disconnected", {connectionInfo: manager.connectionInfo}); + } + return true; + } + + if (event.indexOf("WPA:") == 0 && + event.indexOf("pre-shared key may be incorrect") != -1) { + notify("passwordmaybeincorrect"); + } + + // This is ugly, but we need to grab the SSID here. BSSID is not guaranteed + // to be provided, so don't grab BSSID here. + var match = /Trying to associate with.*SSID[ =]'(.*)'/.exec(event); + if (match) { + debug("Matched: " + match[1] + "\n"); + manager.connectionInfo.ssid = match[1]; + } + return true; + } + + var space = event.indexOf(" "); + var eventData = event.substr(0, space + 1); + if (eventData.indexOf("CTRL-EVENT-STATE-CHANGE") === 0) { + // Parse the event data. + var fields = {}; + var tokens = event.substr(space + 1).split(" "); + for (var n = 0; n < tokens.length; ++n) { + var kv = tokens[n].split("="); + if (kv.length === 2) + fields[kv[0]] = kv[1]; + } + if (!("state" in fields)) + return true; + fields.state = supplicantStatesMap[fields.state]; + + // The BSSID field is only valid in the ASSOCIATING and ASSOCIATED + // states, except when we "reauth", except this seems to depend on the + // driver, so simply check to make sure that we don't have a null BSSID. + if (fields.BSSID !== "00:00:00:00:00:00") + manager.connectionInfo.bssid = fields.BSSID; + + if (notifyStateChange(fields) && fields.state === "COMPLETED") { + onconnected(); + } + return true; + } + if (eventData.indexOf("CTRL-EVENT-DRIVER-STATE") === 0) { + var handlerName = driverEventMap[eventData]; + if (handlerName) + notify(handlerName); + return true; + } + if (eventData.indexOf("CTRL-EVENT-TERMINATING") === 0) { + // As long the monitor socket is not closed and we haven't seen too many + // recv errors yet, we will keep going for a bit longer. + if (event.indexOf("connection closed") === -1 && + event.indexOf("recv error") !== -1 && ++recvErrors < 10) + return true; + + notifyStateChange({ state: "DISCONNECTED", BSSID: null, id: -1 }); + + // If the supplicant is terminated as commanded, the supplicant lost + // notification will be sent after driver unloaded. In such case, the + // manager state will be "DISABLING" or "UNINITIALIZED". + // So if supplicant terminated with incorrect manager state, implying + // unexpected condition, we should notify supplicant lost here. + if (manager.state !== "DISABLING" && manager.state !== "UNINITIALIZED") { + notify("supplicantlost", { success: true }); + } + + if (manager.stopSupplicantCallback) { + cancelWaitForTerminateEventTimer(); + // It's possible that the terminating event triggered by timer comes + // earlier than the event from wpa_supplicant. Since + // stopSupplicantCallback contains async. callbacks, swap it to local + // to prevent calling the callback twice. + let stopSupplicantCallback = manager.stopSupplicantCallback.bind(manager); + manager.stopSupplicantCallback = null; + stopSupplicantCallback(); + stopSupplicantCallback = null; + } + return false; + } + if (eventData.indexOf("CTRL-EVENT-DISCONNECTED") === 0) { + var token = event.split(" ")[1]; + var bssid = token.split("=")[1]; + if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) { + manager.authenticationFailuresCount = 0; + notify("disconnected", {connectionInfo: manager.connectionInfo}); + } + manager.connectionInfo.bssid = null; + manager.connectionInfo.ssid = null; + manager.connectionInfo.id = -1; + return true; + } + if (eventData.indexOf("CTRL-EVENT-CONNECTED") === 0) { + // Format: CTRL-EVENT-CONNECTED - Connection to 00:1e:58:ec:d5:6d completed (reauth) [id=1 id_str=] + var bssid = event.split(" ")[4]; + + var keyword = "id="; + var id = event.substr(event.indexOf(keyword) + keyword.length).split(" ")[0]; + // Read current BSSID here, it will always being provided. + manager.connectionInfo.id = id; + manager.connectionInfo.bssid = bssid; + return true; + } + if (eventData.indexOf("CTRL-EVENT-SCAN-RESULTS") === 0) { + debug("Notifying of scan results available"); + if (reEnableBackgroundScan) { + reEnableBackgroundScan = false; + setBackgroundScan("ON", function() {}); + } + manager.handlePostWifiScan(); + notify("scanresultsavailable"); + return true; + } + if (eventData.indexOf("CTRL-EVENT-EAP") === 0) { + return handleWpaEapEvents(event); + } + if (eventData.indexOf("CTRL-EVENT-ASSOC-REJECT") === 0) { + debug("CTRL-EVENT-ASSOC-REJECT: network error"); + notify("passwordmaybeincorrect"); + if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) { + manager.authenticationFailuresCount = 0; + debug("CTRL-EVENT-ASSOC-REJECT: disconnect network"); + notify("disconnected", {connectionInfo: manager.connectionInfo}); + } + return true; + } + if (eventData.indexOf("WPS-TIMEOUT") === 0) { + notifyStateChange({ state: "WPS_TIMEOUT", BSSID: null, id: -1 }); + return true; + } + if (eventData.indexOf("WPS-FAIL") === 0) { + notifyStateChange({ state: "WPS_FAIL", BSSID: null, id: -1 }); + return true; + } + if (eventData.indexOf("WPS-OVERLAP-DETECTED") === 0) { + notifyStateChange({ state: "WPS_OVERLAP_DETECTED", BSSID: null, id: -1 }); + return true; + } + // Unknown event. + return true; + } + + function setPowerSavingMode(enabled) { + let mode = enabled ? "AUTO" : "ACTIVE"; + // Some wifi drivers may not implement this command. Set power mode + // even if suspend optimization command failed. + manager.setSuspendOptimizations(enabled, function(ok) { + manager.setPowerMode(mode, function() {}); + }); + } + + function didConnectSupplicant(callback) { + waitForEvent(manager.ifname); + + // Load up the supplicant state. + getDebugEnabled(function(ok) { + syncDebug(); + }); + wifiCommand.status(function(status) { + parseStatus(status); + notify("supplicantconnection"); + callback(); + }); + // WPA supplicant already connected. + manager.setPowerSavingMode(true); + if (p2pSupported) { + manager.enableP2p(function(success) {}); + } + } + + function prepareForStartup(callback) { + let status = libcutils.property_get(DHCP_PROP + "_" + manager.ifname); + if (status !== "running") { + tryStopSupplicant(); + return; + } + manager.connectionDropped(function() { + tryStopSupplicant(); + }); + + // Ignore any errors and kill any currently-running supplicants. On some + // phones, stopSupplicant won't work for a supplicant that we didn't + // start, so we hand-roll it here. + function tryStopSupplicant () { + let status = libcutils.property_get(SUPP_PROP); + if (status !== "running") { + callback(); + return; + } + suppressEvents = true; + wifiCommand.killSupplicant(function() { + gNetworkService.disableInterface(manager.ifname, function (ok) { + suppressEvents = false; + callback(); + }); + }); + } + } + + // Initial state. + manager.state = "UNINITIALIZED"; + manager.tetheringState = "UNINITIALIZED"; + manager.supplicantStarted = false; + manager.connectionInfo = { ssid: null, bssid: null, id: -1 }; + manager.authenticationFailuresCount = 0; + manager.loopDetectionCount = 0; + manager.dhcpFailuresCount = 0; + manager.stopSupplicantCallback = null; + + manager.__defineGetter__("enabled", function() { + switch (manager.state) { + case "UNINITIALIZED": + case "INITIALIZING": + case "DISABLING": + return false; + default: + return true; + } + }); + + var waitForTerminateEventTimer = null; + function cancelWaitForTerminateEventTimer() { + if (waitForTerminateEventTimer) { + waitForTerminateEventTimer.cancel(); + waitForTerminateEventTimer = null; + } + }; + function createWaitForTerminateEventTimer(onTimeout) { + if (waitForTerminateEventTimer) { + return; + } + waitForTerminateEventTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + waitForTerminateEventTimer.initWithCallback(onTimeout, + 4000, + Ci.nsITimer.TYPE_ONE_SHOT); + }; + + var waitForDriverReadyTimer = null; + function cancelWaitForDriverReadyTimer() { + if (waitForDriverReadyTimer) { + waitForDriverReadyTimer.cancel(); + waitForDriverReadyTimer = null; + } + }; + function createWaitForDriverReadyTimer(onTimeout) { + waitForDriverReadyTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + waitForDriverReadyTimer.initWithCallback(onTimeout, + manager.driverDelay, + Ci.nsITimer.TYPE_ONE_SHOT); + }; + + // Public interface of the wifi service. + manager.setWifiEnabled = function(enabled, callback) { + if (enabled === manager.isWifiEnabled(manager.state)) { + callback("no change"); + return; + } + + if (enabled) { + manager.state = "INITIALIZING"; + // Register as network interface. + WifiNetworkInterface.info.name = manager.ifname; + if (!WifiNetworkInterface.registered) { + gNetworkManager.registerNetworkInterface(WifiNetworkInterface); + WifiNetworkInterface.registered = true; + } + WifiNetworkInterface.info.state = + Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED; + WifiNetworkInterface.info.ips = []; + WifiNetworkInterface.info.prefixLengths = []; + WifiNetworkInterface.info.gateways = []; + WifiNetworkInterface.info.dnses = []; + gNetworkManager.updateNetworkInterface(WifiNetworkInterface); + + prepareForStartup(function() { + loadDriver(function (status) { + if (status < 0) { + callback(status); + manager.state = "UNINITIALIZED"; + return; + } + // This command is mandatory for Nexus 4. But some devices like + // Galaxy S2 don't support it. Continue to start wpa_supplicant + // even if we fail to set wifi operation mode to station. + gNetworkService.setWifiOperationMode(manager.ifname, + WIFI_FIRMWARE_STATION, + function (status) { + + function startSupplicantInternal() { + wifiCommand.startSupplicant(function (status) { + if (status < 0) { + unloadDriver(WIFI_FIRMWARE_STATION, function() { + callback(status); + }); + manager.state = "UNINITIALIZED"; + return; + } + + manager.supplicantStarted = true; + gNetworkService.enableInterface(manager.ifname, function (ok) { + callback(ok ? 0 : -1); + }); + }); + } + + function doStartSupplicant() { + cancelWaitForDriverReadyTimer(); + + if (!manager.connectToSupplicant) { + startSupplicantInternal(); + return; + } + wifiCommand.closeSupplicantConnection(function () { + manager.connectToSupplicant = false; + // closeSupplicantConnection() will trigger onsupplicantlost + // and set manager.state to "UNINITIALIZED", we have to + // restore it here. + manager.state = "INITIALIZING"; + startSupplicantInternal(); + }); + } + // Driver startup on certain platforms takes longer than it takes for us + // to return from loadDriver, so wait 2 seconds before starting + // the supplicant to give it a chance to start. + if (manager.driverDelay > 0) { + createWaitForDriverReadyTimer(doStartSupplicant); + } else { + doStartSupplicant(); + } + }); + }); + }); + } else { + manager.state = "DISABLING"; + // Note these following calls ignore errors. If we fail to kill the + // supplicant gracefully, then we need to continue telling it to die + // until it does. + let doDisableWifi = function() { + manager.stopSupplicantCallback = (function () { + wifiCommand.stopSupplicant(function (status) { + wifiCommand.closeSupplicantConnection(function() { + manager.connectToSupplicant = false; + manager.state = "UNINITIALIZED"; + gNetworkService.disableInterface(manager.ifname, function (ok) { + unloadDriver(WIFI_FIRMWARE_STATION, callback); + }); + }); + }); + }).bind(this); + + let terminateEventCallback = (function() { + handleEvent("CTRL-EVENT-TERMINATING"); + }).bind(this); + createWaitForTerminateEventTimer(terminateEventCallback); + + // We are going to terminate the connection between wpa_supplicant. + // Stop the polling timer immediately to prevent connection info update + // command blocking in control thread until socket timeout. + notify("stopconnectioninfotimer"); + + wifiCommand.terminateSupplicant(function (ok) { + manager.connectionDropped(function () { + }); + }); + } + + if (p2pSupported) { + p2pManager.setEnabled(false, { onDisabled: doDisableWifi }); + } else { + doDisableWifi(); + } + } + } + + var wifiHotspotStatusTimer = null; + function cancelWifiHotspotStatusTimer() { + if (wifiHotspotStatusTimer) { + wifiHotspotStatusTimer.cancel(); + wifiHotspotStatusTimer = null; + } + } + + function createWifiHotspotStatusTimer(onTimeout) { + wifiHotspotStatusTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + wifiHotspotStatusTimer.init(onTimeout, 5000, Ci.nsITimer.TYPE_REPEATING_SLACK); + } + + // Get wifi interface and load wifi driver when enable Ap mode. + manager.setWifiApEnabled = function(enabled, configuration, callback) { + if (enabled === manager.isWifiTetheringEnabled(manager.tetheringState)) { + callback("no change"); + return; + } + + if (enabled) { + manager.tetheringState = "INITIALIZING"; + loadDriver(function (status) { + if (status < 0) { + callback(); + manager.tetheringState = "UNINITIALIZED"; + if (wifiHotspotStatusTimer) { + cancelWifiHotspotStatusTimer(); + wifiCommand.closeHostapdConnection(function(result) { + }); + } + return; + } + + function getWifiHotspotStatus() { + wifiCommand.hostapdGetStations(function(result) { + notify("stationinfoupdate", {station: result}); + }); + } + + function doStartWifiTethering() { + cancelWaitForDriverReadyTimer(); + WifiNetworkInterface.info.name = + libcutils.property_get("wifi.tethering.interface", manager.ifname); + gTetheringService.setWifiTethering(enabled, + WifiNetworkInterface.info.name, + configuration, function(result) { + if (result) { + manager.tetheringState = "UNINITIALIZED"; + } else { + manager.tetheringState = "COMPLETED"; + wifiCommand.connectToHostapd(function(result) { + if (result) { + return; + } + // Create a timer to track the connection status. + createWifiHotspotStatusTimer(getWifiHotspotStatus); + }); + } + // Pop out current request. + callback(); + // Should we fire a dom event if we fail to set wifi tethering ? + debug("Enable Wifi tethering result: " + (result ? result : "successfully")); + }); + } + + // Driver startup on certain platforms takes longer than it takes + // for us to return from loadDriver, so wait 2 seconds before + // turning on Wifi tethering. + createWaitForDriverReadyTimer(doStartWifiTethering); + }); + } else { + cancelWifiHotspotStatusTimer(); + gTetheringService.setWifiTethering(enabled, WifiNetworkInterface, + configuration, function(result) { + // Should we fire a dom event if we fail to set wifi tethering ? + debug("Disable Wifi tethering result: " + (result ? result : "successfully")); + // Unload wifi driver even if we fail to control wifi tethering. + unloadDriver(WIFI_FIRMWARE_AP, function(status) { + if (status < 0) { + debug("Fail to unload wifi driver"); + } + manager.tetheringState = "UNINITIALIZED"; + callback(); + }); + }); + } + } + + manager.disconnect = wifiCommand.disconnect; + manager.reconnect = wifiCommand.reconnect; + manager.reassociate = wifiCommand.reassociate; + + var networkConfigurationFields = [ + {name: "ssid", type: "string"}, + {name: "bssid", type: "string"}, + {name: "psk", type: "string"}, + {name: "wep_key0", type: "string"}, + {name: "wep_key1", type: "string"}, + {name: "wep_key2", type: "string"}, + {name: "wep_key3", type: "string"}, + {name: "wep_tx_keyidx", type: "integer"}, + {name: "priority", type: "integer"}, + {name: "key_mgmt", type: "string"}, + {name: "scan_ssid", type: "string"}, + {name: "disabled", type: "integer"}, + {name: "identity", type: "string"}, + {name: "password", type: "string"}, + {name: "auth_alg", type: "string"}, + {name: "phase1", type: "string"}, + {name: "phase2", type: "string"}, + {name: "eap", type: "string"}, + {name: "pin", type: "string"}, + {name: "pcsc", type: "string"}, + {name: "ca_cert", type: "string"}, + {name: "subject_match", type: "string"}, + {name: "client_cert", type: "string"}, + {name: "private_key", type: "stirng"}, + {name: "engine", type: "integer"}, + {name: "engine_id", type: "string"}, + {name: "key_id", type: "string"}, + {name: "frequency", type: "integer"}, + {name: "mode", type: "integer"} + ]; + // These fields are only handled in IBSS (aka ad-hoc) mode + var ibssNetworkConfigurationFields = [ + "frequency", "mode" + ]; + + manager.getNetworkConfiguration = function(config, callback) { + var netId = config.netId; + var done = 0; + for (var n = 0; n < networkConfigurationFields.length; ++n) { + let fieldName = networkConfigurationFields[n].name; + let fieldType = networkConfigurationFields[n].type; + wifiCommand.getNetworkVariable(netId, fieldName, function(value) { + if (value !== null) { + if (fieldType === "integer") { + config[fieldName] = parseInt(value, 10); + } else if ( fieldName == "ssid" && value[0] != '"' ) { + // SET_NETWORK will set a quoted ssid to wpa_supplicant. + // But if ssid contains non-ascii char, it will be converted into utf-8. + // For example: "Testçš„wifi" --> 54657374e79a8477696669 + // When GET_NETWORK receive a un-quoted utf-8 ssid, it must be decoded and quoted. + config[fieldName] = quote(decodeURIComponent(value.replace(/[0-9a-f]{2}/g, '%$&'))); + } else { + // value is string type by default. + config[fieldName] = value; + } + } + if (++done == networkConfigurationFields.length) + callback(config); + }); + } + } + manager.setNetworkConfiguration = function(config, callback) { + var netId = config.netId; + var done = 0; + var errors = 0; + + function hasValidProperty(name) { + return ((name in config) && + config[name] != null && + (["password", "wep_key0", "psk"].indexOf(name) === -1 || + config[name] !== '*')); + } + + function getModeFromConfig() { + /* we use the mode from the config, or ESS as default */ + return hasValidProperty("mode") ? config["mode"] : MODE_ESS; + } + + var mode = getModeFromConfig(); + + function validForMode(name, mode) { + /* all fields are valid for IBSS */ + return (mode == MODE_IBSS) || + /* IBSS fields are not valid for ESS */ + ((mode == MODE_ESS) && !(name in ibssNetworkConfigurationFields)); + } + + for (var n = 0; n < networkConfigurationFields.length; ++n) { + let fieldName = networkConfigurationFields[n].name; + if (!hasValidProperty(fieldName) || !validForMode(fieldName, mode)) { + ++done; + } else { + wifiCommand.setNetworkVariable(netId, fieldName, config[fieldName], function(ok) { + if (!ok) + ++errors; + if (++done == networkConfigurationFields.length) + callback(errors == 0); + }); + } + } + // If config didn't contain any of the fields we want, don't lose the error callback. + if (done == networkConfigurationFields.length) + callback(false); + } + manager.getConfiguredNetworks = function(callback) { + wifiCommand.listNetworks(function (reply) { + var networks = Object.create(null); + var lines = reply ? reply.split("\n") : 0; + if (lines.length <= 1) { + // We need to make sure we call the callback even if there are no + // configured networks. + callback(networks); + return; + } + + var done = 0; + var errors = 0; + for (var n = 1; n < lines.length; ++n) { + var result = lines[n].split("\t"); + var netId = parseInt(result[0], 10); + var config = networks[netId] = { netId: netId }; + switch (result[3]) { + case "[CURRENT]": + config.status = "CURRENT"; + break; + case "[DISABLED]": + config.status = "DISABLED"; + break; + default: + config.status = "ENABLED"; + break; + } + manager.getNetworkConfiguration(config, function (ok) { + if (!ok) + ++errors; + if (++done == lines.length - 1) { + if (errors) { + // If an error occured, delete the new netId. + wifiCommand.removeNetwork(netId, function() { + callback(null); + }); + } else { + callback(networks); + } + } + }); + } + }); + } + manager.addNetwork = function(config, callback) { + wifiCommand.addNetwork(function (netId) { + config.netId = netId; + manager.setNetworkConfiguration(config, function (ok) { + if (!ok) { + wifiCommand.removeNetwork(netId, function() { callback(false); }); + return; + } + + callback(ok); + }); + }); + } + manager.updateNetwork = function(config, callback) { + manager.setNetworkConfiguration(config, callback); + } + manager.removeNetwork = function(netId, callback) { + wifiCommand.removeNetwork(netId, callback); + } + + manager.saveConfig = function(callback) { + wifiCommand.saveConfig(callback); + } + manager.enableNetwork = function(netId, disableOthers, callback) { + if (p2pSupported) { + // We have to stop wifi direct scan before associating to an AP. + // Otherwise we will get a "REJECT" wpa supplicant event. + p2pManager.setScanEnabled(false, function(success) {}); + } + wifiCommand.enableNetwork(netId, disableOthers, callback); + } + manager.disableNetwork = function(netId, callback) { + wifiCommand.disableNetwork(netId, callback); + } + manager.getMacAddress = wifiCommand.getMacAddress; + manager.getScanResults = wifiCommand.scanResults; + manager.setScanMode = function(mode, callback) { + setScanMode(mode === "active", callback); // Use our own version. + } + manager.setBackgroundScan = setBackgroundScan; // Use our own version. + manager.scan = scan; // Use our own version. + manager.wpsPbc = wifiCommand.wpsPbc; + manager.wpsPin = wifiCommand.wpsPin; + manager.wpsCancel = wifiCommand.wpsCancel; + manager.setPowerMode = (sdkVersion >= 16) + ? wifiCommand.setPowerModeJB + : wifiCommand.setPowerModeICS; + manager.setPowerSavingMode = setPowerSavingMode; + manager.getHttpProxyNetwork = getHttpProxyNetwork; + manager.setHttpProxy = setHttpProxy; + manager.configureHttpProxy = configureHttpProxy; + manager.setSuspendOptimizations = (sdkVersion >= 16) + ? wifiCommand.setSuspendOptimizationsJB + : wifiCommand.setSuspendOptimizationsICS; + manager.setStaticIpMode = setStaticIpMode; + manager.getRssiApprox = wifiCommand.getRssiApprox; + manager.getLinkSpeed = wifiCommand.getLinkSpeed; + manager.getDhcpInfo = function() { return dhcpInfo; } + manager.getConnectionInfo = (sdkVersion >= 15) + ? wifiCommand.getConnectionInfoICS + : wifiCommand.getConnectionInfoGB; + + manager.ensureSupplicantDetached = aCallback => { + if (!manager.enabled) { + aCallback(); + return; + } + wifiCommand.closeSupplicantConnection(aCallback); + }; + + manager.isHandShakeState = function(state) { + switch (state) { + case "AUTHENTICATING": + case "ASSOCIATING": + case "ASSOCIATED": + case "FOUR_WAY_HANDSHAKE": + case "GROUP_HANDSHAKE": + return true; + case "DORMANT": + case "COMPLETED": + case "DISCONNECTED": + case "INTERFACE_DISABLED": + case "INACTIVE": + case "SCANNING": + case "UNINITIALIZED": + case "INVALID": + case "CONNECTED": + default: + return false; + } + } + + manager.isWifiEnabled = function(state) { + switch (state) { + case "UNINITIALIZED": + case "DISABLING": + return false; + default: + return true; + } + } + + manager.isWifiTetheringEnabled = function(state) { + switch (state) { + case "UNINITIALIZED": + return false; + default: + return true; + } + } + + manager.syncDebug = syncDebug; + manager.stateOrdinal = function(state) { + return supplicantStatesMap.indexOf(state); + } + manager.supplicantLoopDetection = function(prevState, state) { + var isPrevStateInHandShake = manager.isHandShakeState(prevState); + var isStateInHandShake = manager.isHandShakeState(state); + + if (isPrevStateInHandShake) { + if (isStateInHandShake) { + // Increase the count only if we are in the loop. + if (manager.stateOrdinal(state) > manager.stateOrdinal(prevState)) { + manager.loopDetectionCount++; + } + if (manager.loopDetectionCount > MAX_SUPPLICANT_LOOP_ITERATIONS) { + notify("disconnected", {connectionInfo: manager.connectionInfo}); + manager.loopDetectionCount = 0; + } + } + } else { + // From others state to HandShake state. Reset the count. + if (isStateInHandShake) { + manager.loopDetectionCount = 0; + } + } + } + + manager.handlePreWifiScan = function() { + if (p2pSupported) { + // Before doing regular wifi scan, we have to disable wifi direct + // scan first. Otherwise we will never get the scan result. + p2pManager.blockScan(); + } + }; + + manager.handlePostWifiScan = function() { + if (p2pSupported) { + // After regular wifi scanning, we should restore the restricted + // wifi direct scan. + p2pManager.unblockScan(); + } + }; + + // + // Public APIs for P2P. + // + + manager.p2pSupported = function() { + return p2pSupported; + }; + + manager.getP2pManager = function() { + return p2pManager; + }; + + manager.enableP2p = function(callback) { + p2pManager.setEnabled(true, { + onSupplicantConnected: function() { + waitForEvent(WifiP2pManager.INTERFACE_NAME); + }, + + onEnabled: function(success) { + callback(success); + } + }); + }; + + manager.getCapabilities = function() { + return capabilities; + } + + // Cert Services + let wifiCertService = Cc["@mozilla.org/wifi/certservice;1"]; + if (wifiCertService) { + wifiCertService = wifiCertService.getService(Ci.nsIWifiCertService); + wifiCertService.start(wifiListener); + } else { + debug("No wifi CA service component available"); + } + + manager.importCert = function(caInfo, callback) { + var id = idgen++; + if (callback) { + controlCallbacks[id] = callback; + } + + wifiCertService.importCert(id, caInfo.certBlob, caInfo.certPassword, + caInfo.certNickname); + } + + manager.deleteCert = function(caInfo, callback) { + var id = idgen++; + if (callback) { + controlCallbacks[id] = callback; + } + + wifiCertService.deleteCert(id, caInfo.certNickname); + } + + manager.sdkVersion = function() { + return sdkVersion; + } + + return manager; +})(); + +// Get unique key for a network, now the key is created by escape(SSID)+Security. +// So networks of same SSID but different security mode can be identified. +function getNetworkKey(network) +{ + var ssid = "", + encryption = "OPEN"; + + if ("security" in network) { + // manager network object, represents an AP + // object structure + // { + // .ssid : SSID of AP + // .security[] : "WPA-PSK" for WPA-PSK + // "WPA-EAP" for WPA-EAP + // "WEP" for WEP + // "" for OPEN + // other keys + // } + + var security = network.security; + ssid = network.ssid; + + for (let j = 0; j < security.length; j++) { + if (security[j] === "WPA-PSK") { + encryption = "WPA-PSK"; + break; + } else if (security[j] === "WPA-EAP") { + encryption = "WPA-EAP"; + break; + } else if (security[j] === "WEP") { + encryption = "WEP"; + break; + } + } + } else if ("key_mgmt" in network) { + // configure network object, represents a network + // object structure + // { + // .ssid : SSID of network, quoted + // .key_mgmt : Encryption type + // "WPA-PSK" for WPA-PSK + // "WPA-EAP" for WPA-EAP + // "NONE" for WEP/OPEN + // .auth_alg : Encryption algorithm(WEP mode only) + // "OPEN_SHARED" for WEP + // other keys + // } + var key_mgmt = network.key_mgmt, + auth_alg = network.auth_alg; + ssid = dequote(network.ssid); + + if (key_mgmt == "WPA-PSK") { + encryption = "WPA-PSK"; + } else if (key_mgmt.indexOf("WPA-EAP") != -1) { + encryption = "WPA-EAP"; + } else if (key_mgmt == "NONE" && auth_alg === "OPEN SHARED") { + encryption = "WEP"; + } + } + + // ssid here must be dequoted, and it's safer to esacpe it. + // encryption won't be empty and always be assigned one of the followings : + // "OPEN"/"WEP"/"WPA-PSK"/"WPA-EAP". + // So for a invalid network object, the returned key will be "OPEN". + return escape(ssid) + encryption; +} + +function getMode(flags) { + if (/\[IBSS/.test(flags)) + return MODE_IBSS; + + return MODE_ESS; +} + +function getKeyManagement(flags) { + var types = []; + if (!flags) + return types; + + if (/\[WPA2?-PSK/.test(flags)) + types.push("WPA-PSK"); + if (/\[WPA2?-EAP/.test(flags)) + types.push("WPA-EAP"); + if (/\[WEP/.test(flags)) + types.push("WEP"); + return types; +} + +function getCapabilities(flags) { + var types = []; + if (!flags) + return types; + + if (/\[WPS/.test(flags)) + types.push("WPS"); + return types; +} + +// These constants shamelessly ripped from WifiManager.java +// strength is the value returned by scan_results. It is nominally in dB. We +// transform it into a percentage for clients looking to simply show a +// relative indication of the strength of a network. +const MIN_RSSI = -100; +const MAX_RSSI = -55; + +function calculateSignal(strength) { + // Some wifi drivers represent their signal strengths as 8-bit integers, so + // in order to avoid negative numbers, they add 256 to the actual values. + // While we don't *know* that this is the case here, we make an educated + // guess. + if (strength > 0) + strength -= 256; + + if (strength <= MIN_RSSI) + return 0; + if (strength >= MAX_RSSI) + return 100; + return Math.floor(((strength - MIN_RSSI) / (MAX_RSSI - MIN_RSSI)) * 100); +} + +function Network(ssid, mode, frequency, security, password, capabilities) { + this.ssid = ssid; + this.mode = mode; + this.frequency = frequency; + this.security = security; + + if (typeof password !== "undefined") + this.password = password; + if (capabilities !== undefined) + this.capabilities = capabilities; + // TODO connected here as well? + + this.__exposedProps__ = Network.api; +} + +Network.api = { + ssid: "r", + mode: "r", + frequency: "r", + security: "r", + capabilities: "r", + known: "r", + + password: "rw", + keyManagement: "rw", + psk: "rw", + identity: "rw", + wep: "rw", + hidden: "rw", + eap: "rw", + pin: "rw", + phase1: "rw", + phase2: "rw", + serverCertificate: "rw", + userCertificate: "rw" +}; + +// Note: We never use ScanResult.prototype, so the fact that it's unrelated to +// Network.prototype is OK. +function ScanResult(ssid, bssid, frequency, flags, signal) { + Network.call(this, ssid, getMode(flags), frequency, + getKeyManagement(flags), undefined, getCapabilities(flags)); + this.bssid = bssid; + this.signalStrength = signal; + this.relSignalStrength = calculateSignal(Number(signal)); + + this.__exposedProps__ = ScanResult.api; +} + +// XXX This should probably live in the DOM-facing side, but it's hard to do +// there, so we stick this here. +ScanResult.api = { + bssid: "r", + signalStrength: "r", + relSignalStrength: "r", + connected: "r" +}; + +for (let i in Network.api) { + ScanResult.api[i] = Network.api[i]; +} + +function quote(s) { + return '"' + s + '"'; +} + +function dequote(s) { + if (s[0] != '"' || s[s.length - 1] != '"') + throw "Invalid argument, not a quoted string: " + s; + return s.substr(1, s.length - 2); +} + +function isWepHexKey(s) { + if (s.length != 10 && s.length != 26 && s.length != 58) + return false; + return !/[^a-fA-F0-9]/.test(s); +} + + +var WifiNetworkInterface = { + + QueryInterface: XPCOMUtils.generateQI([Ci.nsINetworkInterface]), + + registered: false, + + // nsINetworkInterface + + NETWORK_STATE_UNKNOWN: Ci.nsINetworkInfo.NETWORK_STATE_UNKNOWN, + NETWORK_STATE_CONNECTING: Ci.nsINetworkInfo.CONNECTING, + NETWORK_STATE_CONNECTED: Ci.nsINetworkInfo.CONNECTED, + NETWORK_STATE_DISCONNECTING: Ci.nsINetworkInfo.DISCONNECTING, + NETWORK_STATE_DISCONNECTED: Ci.nsINetworkInfo.DISCONNECTED, + + NETWORK_TYPE_WIFI: Ci.nsINetworkInfo.NETWORK_TYPE_WIFI, + NETWORK_TYPE_MOBILE: Ci.nsINetworkInfo.NETWORK_TYPE_MOBILE, + NETWORK_TYPE_MOBILE_MMS: Ci.nsINetworkInfo.NETWORK_TYPE_MOBILE_MMS, + NETWORK_TYPE_MOBILE_SUPL: Ci.nsINetworkInfo.NETWORK_TYPE_MOBILE_SUPL, + + info: { + QueryInterface: XPCOMUtils.generateQI([Ci.nsINetworkInfo]), + + state: Ci.nsINetworkInfo.NETWORK_STATE_UNKNOWN, + + type: Ci.nsINetworkInfo.NETWORK_TYPE_WIFI, + + name: null, + + ips: [], + + prefixLengths: [], + + dnses: [], + + gateways: [], + + getAddresses: function (ips, prefixLengths) { + ips.value = this.ips.slice(); + prefixLengths.value = this.prefixLengths.slice(); + + return this.ips.length; + }, + + getGateways: function (count) { + if (count) { + count.value = this.gateways.length; + } + return this.gateways.slice(); + }, + + getDnses: function (count) { + if (count) { + count.value = this.dnses.length; + } + return this.dnses.slice(); + } + }, + + httpProxyHost: null, + + httpProxyPort: null +}; + +function WifiScanResult() {} + +// TODO Make the difference between a DOM-based network object and our +// networks objects much clearer. +var netToDOM; +var netFromDOM; + +function WifiWorker() { + var self = this; + + this._mm = Cc["@mozilla.org/parentprocessmessagemanager;1"] + .getService(Ci.nsIMessageListenerManager); + const messages = ["WifiManager:getNetworks", "WifiManager:getKnownNetworks", + "WifiManager:associate", "WifiManager:forget", + "WifiManager:wps", "WifiManager:getState", + "WifiManager:setPowerSavingMode", + "WifiManager:setHttpProxy", + "WifiManager:setStaticIpMode", + "WifiManager:importCert", + "WifiManager:getImportedCerts", + "WifiManager:deleteCert", + "WifiManager:setWifiEnabled", + "WifiManager:setWifiTethering", + "child-process-shutdown"]; + + messages.forEach((function(msgName) { + this._mm.addMessageListener(msgName, this); + }).bind(this)); + + Services.obs.addObserver(this, kMozSettingsChangedObserverTopic, false); + Services.obs.addObserver(this, "xpcom-shutdown", false); + + this.wantScanResults = []; + + this._needToEnableNetworks = false; + this._highestPriority = -1; + + // Networks is a map from SSID -> a scan result. + this.networks = Object.create(null); + + // ConfiguredNetworks is a map from SSID -> our view of a network. It only + // lists networks known to the wpa_supplicant. The SSID field (and other + // fields) are quoted for ease of use with WifiManager commands. + // Note that we don't have to worry about escaping embedded quotes since in + // all cases, the supplicant will take the last quotation that we pass it as + // the end of the string. + this.configuredNetworks = Object.create(null); + this._addingNetworks = Object.create(null); + + this.currentNetwork = null; + this.ipAddress = ""; + this.macAddress = null; + + this._lastConnectionInfo = null; + this._connectionInfoTimer = null; + this._reconnectOnDisconnect = false; + + // Create p2pObserver and assign to p2pManager. + if (WifiManager.p2pSupported()) { + this._p2pObserver = WifiP2pWorkerObserver(WifiManager.getP2pManager()); + WifiManager.getP2pManager().setObserver(this._p2pObserver); + + // Add DOM message observerd by p2pObserver to the message listener as well. + this._p2pObserver.getObservedDOMMessages().forEach((function(msgName) { + this._mm.addMessageListener(msgName, this); + }).bind(this)); + } + + // Users of instances of nsITimer should keep a reference to the timer until + // it is no longer needed in order to assure the timer is fired. + this._callbackTimer = null; + + // XXX On some phones (Otoro and Unagi) the wifi driver doesn't play nicely + // with the automatic scans that wpa_supplicant does (it appears that the + // driver forgets that it's returned scan results and then refuses to try to + // rescan. In order to detect this case we start a timer when we enter the + // SCANNING state and reset it whenever we either get scan results or leave + // the SCANNING state. If the timer fires, we assume that we are stuck and + // forceably try to unstick the supplican, also turning on background + // scanning to avoid having to constantly poke the supplicant. + + // How long we wait is controlled by the SCAN_STUCK_WAIT constant. + const SCAN_STUCK_WAIT = 12000; + this._scanStuckTimer = null; + this._turnOnBackgroundScan = false; + + function startScanStuckTimer() { + if (WifiManager.schedScanRecovery) { + self._scanStuckTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + self._scanStuckTimer.initWithCallback(scanIsStuck, SCAN_STUCK_WAIT, + Ci.nsITimer.TYPE_ONE_SHOT); + } + } + + function scanIsStuck() { + // Uh-oh, we've waited too long for scan results. Disconnect (which + // guarantees that we leave the SCANNING state and tells wpa_supplicant to + // wait for our next command) ensure that background scanning is on and + // then try again. + debug("Determined that scanning is stuck, turning on background scanning!"); + WifiManager.handlePostWifiScan(); + WifiManager.disconnect(function(ok) {}); + self._turnOnBackgroundScan = true; + } + + // A list of requests to turn wifi on or off. + this._stateRequests = []; + + // Given a connection status network, takes a network from + // self.configuredNetworks and prepares it for the DOM. + netToDOM = function(net) { + if (!net) { + return null; + } + var ssid = dequote(net.ssid); + var mode = net.mode; + var frequency = net.frequency; + var security = (net.key_mgmt === "NONE" && net.wep_key0) ? ["WEP"] : + (net.key_mgmt && net.key_mgmt !== "NONE") ? [net.key_mgmt.split(" ")[0]] : + []; + var password; + if (("psk" in net && net.psk) || + ("password" in net && net.password) || + ("wep_key0" in net && net.wep_key0)) { + password = "*"; + } + + var pub = new Network(ssid, mode, frequency, security, password); + if (net.identity) + pub.identity = dequote(net.identity); + if ("netId" in net) + pub.known = true; + if (net.scan_ssid === 1) + pub.hidden = true; + if ("ca_cert" in net && net.ca_cert && + net.ca_cert.indexOf("keystore://WIFI_SERVERCERT_" === 0)) { + pub.serverCertificate = net.ca_cert.substr(27); + } + if(net.subject_match) { + pub.subjectMatch = net.subject_match; + } + if ("client_cert" in net && net.client_cert && + net.client_cert.indexOf("keystore://WIFI_USERCERT_" === 0)) { + pub.userCertificate = net.client_cert.substr(25); + } + return pub; + }; + + netFromDOM = function(net, configured) { + // Takes a network from the DOM and makes it suitable for insertion into + // self.configuredNetworks (that is calling addNetwork will do the right + // thing). + // NB: Modifies net in place: safe since we don't share objects between + // the dom and the chrome code. + + // Things that are useful for the UI but not to us. + delete net.bssid; + delete net.signalStrength; + delete net.relSignalStrength; + delete net.security; + delete net.capabilities; + + if (!configured) + configured = {}; + + net.ssid = quote(net.ssid); + + let wep = false; + if ("keyManagement" in net) { + if (net.keyManagement === "WEP") { + wep = true; + net.keyManagement = "NONE"; + } else if (net.keyManagement === "WPA-EAP") { + net.keyManagement += " IEEE8021X"; + } + + configured.key_mgmt = net.key_mgmt = net.keyManagement; // WPA2-PSK, WPA-PSK, etc. + delete net.keyManagement; + } else { + configured.key_mgmt = net.key_mgmt = "NONE"; + } + + if (net.hidden) { + configured.scan_ssid = net.scan_ssid = 1; + delete net.hidden; + } + + function checkAssign(name, checkStar) { + if (name in net) { + let value = net[name]; + if (!value || (checkStar && value === '*')) { + if (name in configured) + net[name] = configured[name]; + else + delete net[name]; + } else { + configured[name] = net[name] = quote(value); + } + } + } + + checkAssign("psk", true); + checkAssign("identity", false); + checkAssign("password", true); + if (wep && net.wep && net.wep != '*') { + configured.wep_key0 = net.wep_key0 = isWepHexKey(net.wep) ? net.wep : quote(net.wep); + configured.auth_alg = net.auth_alg = "OPEN SHARED"; + } + + function hasValidProperty(name) { + return ((name in net) && net[name] != null); + } + + if (hasValidProperty("eap")) { + if (hasValidProperty("pin")) { + net.pin = quote(net.pin); + } + + if (hasValidProperty("phase1")) + net.phase1 = quote(net.phase1); + + if (hasValidProperty("phase2")) { + if (net.phase2 === "TLS") { + net.phase2 = quote("autheap=" + net.phase2); + } else { // PAP, MSCHAPV2, etc. + net.phase2 = quote("auth=" + net.phase2); + } + } + + if (hasValidProperty("serverCertificate")) + net.ca_cert = quote("keystore://WIFI_SERVERCERT_" + net.serverCertificate); + + if (hasValidProperty("subjectMatch")) + net.subject_match = quote(net.subjectMatch); + + if (hasValidProperty("userCertificate")) { + let userCertName = "WIFI_USERCERT_" + net.userCertificate; + net.client_cert = quote("keystore://" + userCertName); + + let wifiCertService = Cc["@mozilla.org/wifi/certservice;1"]. + getService(Ci.nsIWifiCertService); + if (wifiCertService.hasPrivateKey(userCertName)) { + if (WifiManager.sdkVersion() >= 19) { + // Use openssol engine instead of keystore protocol after Kitkat. + net.engine = 1; + net.engine_id = quote("keystore"); + net.key_id = quote("WIFI_USERKEY_" + net.userCertificate); + } else { + net.private_key = quote("keystore://WIFI_USERKEY_" + net.userCertificate); + } + } + } + } + + return net; + }; + + WifiManager.onsupplicantconnection = function() { + debug("Connected to supplicant"); + // Give it a state other than UNINITIALIZED, INITIALIZING or DISABLING + // defined in getter function of WifiManager.enabled. It implies that + // we are ready to accept dom request from applications. + WifiManager.state = "DISCONNECTED"; + self._reloadConfiguredNetworks(function(ok) { + // Prime this.networks. + if (!ok) + return; + + // The select network command we used in associate() disables others networks. + // Enable them here to make sure wpa_supplicant helps to connect to known + // network automatically. + self._enableAllNetworks(); + WifiManager.saveConfig(function() {}) + }); + + // Notify everybody, even if they didn't ask us to come up. + WifiManager.getMacAddress(function (mac) { + self.macAddress = mac; + debug("Got mac: " + mac); + self._fireEvent("wifiUp", { macAddress: mac }); + self.requestDone(); + }); + + if (WifiManager.state === "SCANNING") + startScanStuckTimer(); + }; + + WifiManager.onsupplicantlost = function() { + WifiManager.supplicantStarted = false; + WifiManager.state = "UNINITIALIZED"; + debug("Supplicant died!"); + + // Notify everybody, even if they didn't ask us to come up. + self._fireEvent("wifiDown", {}); + self.requestDone(); + }; + + WifiManager.onpasswordmaybeincorrect = function() { + WifiManager.authenticationFailuresCount++; + }; + + WifiManager.ondisconnected = function() { + // We may fail to establish the connection, re-enable the + // rest of our networks. + if (self._needToEnableNetworks) { + self._enableAllNetworks(); + self._needToEnableNetworks = false; + } + + let connectionInfo = this.connectionInfo; + WifiManager.getNetworkId(connectionInfo.ssid, function(netId) { + // Trying to get netId from current network. + if (!netId && + self.currentNetwork && self.currentNetwork.ssid && + dequote(self.currentNetwork.ssid) == connectionInfo.ssid && + typeof self.currentNetwork.netId !== "undefined") { + netId = self.currentNetwork.netId; + } + if (netId) { + WifiManager.disableNetwork(netId, function() {}); + } + }); + self._fireEvent("onconnectingfailed", {network: netToDOM(self.currentNetwork)}); + } + + WifiManager.onstatechange = function() { + debug("State change: " + this.prevState + " -> " + this.state); + + if (self._connectionInfoTimer && + this.state !== "CONNECTED" && + this.state !== "COMPLETED") { + self._stopConnectionInfoTimer(); + } + + if (this.state !== "SCANNING" && + self._scanStuckTimer) { + self._scanStuckTimer.cancel(); + self._scanStuckTimer = null; + } + + switch (this.state) { + case "DORMANT": + // The dormant state is a bad state to be in since we won't + // automatically connect. Try to knock us out of it. We only + // hit this state when we've failed to run DHCP, so trying + // again isn't the worst thing we can do. Eventually, we'll + // need to detect if we're looping in this state and bail out. + WifiManager.reconnect(function(){}); + break; + case "ASSOCIATING": + // id has not yet been filled in, so we can only report the ssid and + // bssid. mode and frequency are simply made up. + self.currentNetwork = + { bssid: WifiManager.connectionInfo.bssid, + ssid: quote(WifiManager.connectionInfo.ssid), + mode: MODE_ESS, + frequency: 0}; + WifiManager.getNetworkConfiguration(self.currentNetwork, function (){ + // Notify again because we get complete network information. + self._fireEvent("onconnecting", { network: netToDOM(self.currentNetwork) }); + }); + break; + case "ASSOCIATED": + // set to full power mode when ready to do 4 way handsharke. + WifiManager.setPowerSavingMode(false); + if (!self.currentNetwork) { + self.currentNetwork = + { bssid: WifiManager.connectionInfo.bssid, + ssid: quote(WifiManager.connectionInfo.ssid) }; + } + self.currentNetwork.netId = this.id; + WifiManager.getNetworkConfiguration(self.currentNetwork, function (){ + // Notify again because we get complete network information. + self._fireEvent("onconnecting", { network: netToDOM(self.currentNetwork) }); + }); + break; + case "COMPLETED": + // Now that we've successfully completed the connection, re-enable the + // rest of our networks. + // XXX Need to do this eventually if the user entered an incorrect + // password. For now, we require user interaction to break the loop and + // select a better network! + if (self._needToEnableNetworks) { + self._enableAllNetworks(); + self._needToEnableNetworks = false; + } + + var _oncompleted = function() { + // The full authentication process is completed, reset the count. + WifiManager.authenticationFailuresCount = 0; + WifiManager.loopDetectionCount = 0; + self._startConnectionInfoTimer(); + self._fireEvent("onassociate", { network: netToDOM(self.currentNetwork) }); + }; + + // We get the ASSOCIATED event when we've associated but not connected, so + // wait until the handshake is complete. + if (this.fromStatus || !self.currentNetwork) { + // In this case, we connected to an already-connected wpa_supplicant, + // because of that we need to gather information about the current + // network here. + self.currentNetwork = { bssid: WifiManager.connectionInfo.bssid, + ssid: quote(WifiManager.connectionInfo.ssid), + netId: WifiManager.connectionInfo.id }; + WifiManager.getNetworkConfiguration(self.currentNetwork, _oncompleted); + } else { + _oncompleted(); + } + break; + case "CONNECTED": + // wifi connection complete, turn on the power saving mode. + WifiManager.setPowerSavingMode(true); + // BSSID is read after connected, update it. + self.currentNetwork.bssid = WifiManager.connectionInfo.bssid; + break; + case "DISCONNECTED": + // wpa_supplicant may give us a "DISCONNECTED" event even if + // we are already in "DISCONNECTED" state. + if ((WifiNetworkInterface.info.state === + Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED) && + (this.prevState === "INITIALIZING" || + this.prevState === "DISCONNECTED" || + this.prevState === "INTERFACE_DISABLED" || + this.prevState === "INACTIVE" || + this.prevState === "UNINITIALIZED")) { + // When in disconnected mode, need to turn on wifi power saving mode. + WifiManager.setPowerSavingMode(true); + return; + } + + self._fireEvent("ondisconnect", {network: netToDOM(self.currentNetwork)}); + + self.currentNetwork = null; + self.ipAddress = ""; + + if (self._turnOnBackgroundScan) { + self._turnOnBackgroundScan = false; + WifiManager.setBackgroundScan("ON", function(did_something, ok) { + WifiManager.reassociate(function() {}); + }); + } + + WifiManager.connectionDropped(function() { + // We've disconnected from a network because of a call to forgetNetwork. + // Reconnect to the next available network (if any). + if (self._reconnectOnDisconnect) { + self._reconnectOnDisconnect = false; + WifiManager.reconnect(function(){}); + } + }); + + WifiNetworkInterface.info.state = + Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED; + + // Update network infterface first then clear properties. + gNetworkManager.updateNetworkInterface(WifiNetworkInterface); + WifiNetworkInterface.info.ips = []; + WifiNetworkInterface.info.prefixLengths = []; + WifiNetworkInterface.info.gateways = []; + WifiNetworkInterface.info.dnses = []; + + + break; + case "WPS_TIMEOUT": + self._fireEvent("onwpstimeout", {}); + break; + case "WPS_FAIL": + self._fireEvent("onwpsfail", {}); + break; + case "WPS_OVERLAP_DETECTED": + self._fireEvent("onwpsoverlap", {}); + break; + case "AUTHENTICATING": + self._fireEvent("onauthenticating", {network: netToDOM(self.currentNetwork)}); + break; + case "SCANNING": + // If we're already scanning in the background, we don't need to worry + // about getting stuck while scanning. + if (!WifiManager.backgroundScanEnabled && WifiManager.enabled) + startScanStuckTimer(); + break; + } + }; + + WifiManager.onnetworkconnected = function() { + if (!this.info || !this.info.ipaddr_str) { + debug("Network information is invalid."); + return; + } + + let maskLength = + netHelpers.getMaskLength(netHelpers.stringToIP(this.info.mask_str)); + if (!maskLength) { + maskLength = 32; // max prefix for IPv4. + } + + let netConnect = WifiManager.getHttpProxyNetwork(self.currentNetwork); + if (netConnect) { + WifiNetworkInterface.httpProxyHost = netConnect.httpProxyHost; + WifiNetworkInterface.httpProxyPort = netConnect.httpProxyPort; + } + + WifiNetworkInterface.info.state = + Ci.nsINetworkInfo.NETWORK_STATE_CONNECTED; + WifiNetworkInterface.info.ips = [this.info.ipaddr_str]; + WifiNetworkInterface.info.prefixLengths = [maskLength]; + WifiNetworkInterface.info.gateways = [this.info.gateway_str]; + if (typeof this.info.dns1_str == "string" && + this.info.dns1_str.length) { + WifiNetworkInterface.info.dnses.push(this.info.dns1_str); + } + if (typeof this.info.dns2_str == "string" && + this.info.dns2_str.length) { + WifiNetworkInterface.info.dnses.push(this.info.dns2_str); + } + gNetworkManager.updateNetworkInterface(WifiNetworkInterface); + + self.ipAddress = this.info.ipaddr_str; + + // We start the connection information timer when we associate, but + // don't have our IP address until here. Make sure that we fire a new + // connectionInformation event with the IP address the next time the + // timer fires. + self._lastConnectionInfo = null; + self._fireEvent("onconnect", { network: netToDOM(self.currentNetwork) }); + }; + + WifiManager.onscanresultsavailable = function() { + if (self._scanStuckTimer) { + // We got scan results! We must not be stuck for now, try again. + self._scanStuckTimer.cancel(); + self._scanStuckTimer.initWithCallback(scanIsStuck, SCAN_STUCK_WAIT, + Ci.nsITimer.TYPE_ONE_SHOT); + } + + if (self.wantScanResults.length === 0) { + debug("Scan results available, but we don't need them"); + return; + } + + debug("Scan results are available! Asking for them."); + WifiManager.getScanResults(function(r) { + // Failure. + if (!r) { + self.wantScanResults.forEach(function(callback) { callback(null) }); + self.wantScanResults = []; + return; + } + + let capabilities = WifiManager.getCapabilities(); + + // Now that we have scan results, there's no more need to continue + // scanning. Ignore any errors from this command. + WifiManager.setScanMode("inactive", function() {}); + let lines = r.split("\n"); + // NB: Skip the header line. + self.networksArray = []; + for (let i = 1; i < lines.length; ++i) { + // bssid / frequency / signal level / flags / ssid + var match = /([\S]+)\s+([\S]+)\s+([\S]+)\s+(\[[\S]+\])?\s(.*)/.exec(lines[i]); + + if (match && match[5]) { + let ssid = match[5], + bssid = match[1], + frequency = match[2], + signalLevel = match[3], + flags = match[4]; + + /* Skip networks with unknown or unsupported modes. */ + if (capabilities.mode.indexOf(getMode(flags)) == -1) + continue; + + // If this is the first time that we've seen this SSID in the scan + // results, add it to the list along with any other information. + // Also, we use the highest signal strength that we see. + let network = new ScanResult(ssid, bssid, frequency, flags, signalLevel); + + let networkKey = getNetworkKey(network); + let eapIndex = -1; + if (networkKey in self.configuredNetworks) { + let known = self.configuredNetworks[networkKey]; + network.known = true; + + if ("identity" in known && known.identity) + network.identity = dequote(known.identity); + + // Note: we don't hand out passwords here! The * marks that there + // is a password that we're hiding. + if (("psk" in known && known.psk) || + ("password" in known && known.password) || + ("wep_key0" in known && known.wep_key0)) { + network.password = "*"; + } + } + + self.networksArray.push(network); + if (network.bssid === WifiManager.connectionInfo.bssid) + network.connected = true; + + let signal = calculateSignal(Number(match[3])); + if (signal > network.relSignalStrength) + network.relSignalStrength = signal; + } else if (!match) { + debug("Match didn't find anything for: " + lines[i]); + } + } + + self.wantScanResults.forEach(function(callback) { callback(self.networksArray) }); + self.wantScanResults = []; + }); + }; + + WifiManager.onstationinfoupdate = function() { + self._fireEvent("stationinfoupdate", { station: this.station }); + }; + + WifiManager.onstopconnectioninfotimer = function() { + self._stopConnectionInfoTimer(); + }; + + // Read the 'wifi.enabled' setting in order to start with a known + // value at boot time. The handle() will be called after reading. + // + // nsISettingsServiceCallback implementation. + var initWifiEnabledCb = { + handle: function handle(aName, aResult) { + if (aName !== SETTINGS_WIFI_ENABLED) + return; + if (aResult === null) + aResult = true; + self.handleWifiEnabled(aResult); + }, + handleError: function handleError(aErrorMessage) { + debug("Error reading the 'wifi.enabled' setting. Default to wifi on."); + self.handleWifiEnabled(true); + } + }; + + var initWifiDebuggingEnabledCb = { + handle: function handle(aName, aResult) { + if (aName !== SETTINGS_WIFI_DEBUG_ENABLED) + return; + if (aResult === null) + aResult = false; + DEBUG = aResult; + updateDebug(); + }, + handleError: function handleError(aErrorMessage) { + debug("Error reading the 'wifi.debugging.enabled' setting. Default to debugging off."); + DEBUG = false; + updateDebug(); + } + }; + + this.initTetheringSettings(); + + let lock = gSettingsService.createLock(); + lock.get(SETTINGS_WIFI_ENABLED, initWifiEnabledCb); + lock.get(SETTINGS_WIFI_DEBUG_ENABLED, initWifiDebuggingEnabledCb); + + lock.get(SETTINGS_WIFI_SSID, this); + lock.get(SETTINGS_WIFI_SECURITY_TYPE, this); + lock.get(SETTINGS_WIFI_SECURITY_PASSWORD, this); + lock.get(SETTINGS_WIFI_IP, this); + lock.get(SETTINGS_WIFI_PREFIX, this); + lock.get(SETTINGS_WIFI_DHCPSERVER_STARTIP, this); + lock.get(SETTINGS_WIFI_DHCPSERVER_ENDIP, this); + lock.get(SETTINGS_WIFI_DNS1, this); + lock.get(SETTINGS_WIFI_DNS2, this); + lock.get(SETTINGS_WIFI_TETHERING_ENABLED, this); + + lock.get(SETTINGS_USB_DHCPSERVER_STARTIP, this); + lock.get(SETTINGS_USB_DHCPSERVER_ENDIP, this); + + this._wifiTetheringSettingsToRead = [SETTINGS_WIFI_SSID, + SETTINGS_WIFI_SECURITY_TYPE, + SETTINGS_WIFI_SECURITY_PASSWORD, + SETTINGS_WIFI_IP, + SETTINGS_WIFI_PREFIX, + SETTINGS_WIFI_DHCPSERVER_STARTIP, + SETTINGS_WIFI_DHCPSERVER_ENDIP, + SETTINGS_WIFI_DNS1, + SETTINGS_WIFI_DNS2, + SETTINGS_WIFI_TETHERING_ENABLED, + SETTINGS_USB_DHCPSERVER_STARTIP, + SETTINGS_USB_DHCPSERVER_ENDIP]; +} + +function translateState(state) { + switch (state) { + case "INTERFACE_DISABLED": + case "INACTIVE": + case "SCANNING": + case "DISCONNECTED": + default: + return "disconnected"; + + case "AUTHENTICATING": + case "ASSOCIATING": + case "ASSOCIATED": + case "FOUR_WAY_HANDSHAKE": + case "GROUP_HANDSHAKE": + return "connecting"; + + case "COMPLETED": + return WifiManager.getDhcpInfo() ? "connected" : "associated"; + } +} + +WifiWorker.prototype = { + classID: WIFIWORKER_CID, + classInfo: XPCOMUtils.generateCI({classID: WIFIWORKER_CID, + contractID: WIFIWORKER_CONTRACTID, + classDescription: "WifiWorker", + interfaces: [Ci.nsIWorkerHolder, + Ci.nsIWifi, + Ci.nsIObserver]}), + + QueryInterface: XPCOMUtils.generateQI([Ci.nsIWorkerHolder, + Ci.nsIWifi, + Ci.nsIObserver, + Ci.nsISettingsServiceCallback]), + + disconnectedByWifi: false, + + disconnectedByWifiTethering: false, + + _wifiTetheringSettingsToRead: [], + + _oldWifiTetheringEnabledState: null, + + tetheringSettings: {}, + + initTetheringSettings: function initTetheringSettings() { + this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] = null; + this.tetheringSettings[SETTINGS_WIFI_SSID] = DEFAULT_WIFI_SSID; + this.tetheringSettings[SETTINGS_WIFI_SECURITY_TYPE] = DEFAULT_WIFI_SECURITY_TYPE; + this.tetheringSettings[SETTINGS_WIFI_SECURITY_PASSWORD] = DEFAULT_WIFI_SECURITY_PASSWORD; + this.tetheringSettings[SETTINGS_WIFI_IP] = DEFAULT_WIFI_IP; + this.tetheringSettings[SETTINGS_WIFI_PREFIX] = DEFAULT_WIFI_PREFIX; + this.tetheringSettings[SETTINGS_WIFI_DHCPSERVER_STARTIP] = DEFAULT_WIFI_DHCPSERVER_STARTIP; + this.tetheringSettings[SETTINGS_WIFI_DHCPSERVER_ENDIP] = DEFAULT_WIFI_DHCPSERVER_ENDIP; + this.tetheringSettings[SETTINGS_WIFI_DNS1] = DEFAULT_DNS1; + this.tetheringSettings[SETTINGS_WIFI_DNS2] = DEFAULT_DNS2; + + this.tetheringSettings[SETTINGS_USB_DHCPSERVER_STARTIP] = DEFAULT_USB_DHCPSERVER_STARTIP; + this.tetheringSettings[SETTINGS_USB_DHCPSERVER_ENDIP] = DEFAULT_USB_DHCPSERVER_ENDIP; + }, + + // Internal methods. + waitForScan: function(callback) { + this.wantScanResults.push(callback); + }, + + // In order to select a specific network, we disable the rest of the + // networks known to us. However, in general, we want the supplicant to + // connect to which ever network it thinks is best, so when we select the + // proper network (or fail to), we need to re-enable the rest. + _enableAllNetworks: function() { + for (let key in this.configuredNetworks) { + let net = this.configuredNetworks[key]; + WifiManager.enableNetwork(net.netId, false, function(ok) { + net.disabled = ok ? 1 : 0; + }); + } + }, + + _startConnectionInfoTimer: function() { + if (this._connectionInfoTimer) + return; + + var self = this; + function getConnectionInformation() { + WifiManager.getConnectionInfo(function(connInfo) { + // See comments in calculateSignal for information about this. + if (!connInfo) { + self._lastConnectionInfo = null; + return; + } + + let { rssi, linkspeed } = connInfo; + if (rssi > 0) + rssi -= 256; + if (rssi <= MIN_RSSI) + rssi = MIN_RSSI; + else if (rssi >= MAX_RSSI) + rssi = MAX_RSSI; + + let info = { signalStrength: rssi, + relSignalStrength: calculateSignal(rssi), + linkSpeed: linkspeed, + ipAddress: self.ipAddress }; + let last = self._lastConnectionInfo; + + // Only fire the event if the link speed changed or the signal + // strength changed by more than 10%. + function tensPlace(percent) { + return (percent / 10) | 0; + } + + if (last && last.linkSpeed === info.linkSpeed && + last.ipAddress === info.ipAddress && + tensPlace(last.relSignalStrength) === tensPlace(info.relSignalStrength)) { + return; + } + + self._lastConnectionInfo = info; + debug("Firing connectioninfoupdate: " + uneval(info)); + self._fireEvent("connectioninfoupdate", info); + }); + } + + // Prime our _lastConnectionInfo immediately and fire the event at the + // same time. + getConnectionInformation(); + + // Now, set up the timer for regular updates. + this._connectionInfoTimer = + Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + this._connectionInfoTimer.init(getConnectionInformation, 5000, + Ci.nsITimer.TYPE_REPEATING_SLACK); + }, + + _stopConnectionInfoTimer: function() { + if (!this._connectionInfoTimer) + return; + + this._connectionInfoTimer.cancel(); + this._connectionInfoTimer = null; + this._lastConnectionInfo = null; + }, + + _reloadConfiguredNetworks: function(callback) { + WifiManager.getConfiguredNetworks((function(networks) { + if (!networks) { + debug("Unable to get configured networks"); + callback(false); + return; + } + + this._highestPriority = -1; + + // Convert between netId-based and ssid-based indexing. + for (let net in networks) { + let network = networks[net]; + delete networks[net]; + + if (!network.ssid) { + WifiManager.removeNetwork(network.netId, function() {}); + continue; + } + + if (network.hasOwnProperty("priority") && + network.priority > this._highestPriority) { + this._highestPriority = network.priority; + } + + let networkKey = getNetworkKey(network); + // Accept latest config of same network(same SSID and same security). + if (networks[networkKey]) { + WifiManager.removeNetwork(networks[networkKey].netId, function() {}); + } + networks[networkKey] = network; + } + + this.configuredNetworks = networks; + callback(true); + }).bind(this)); + }, + + // Important side effect: calls WifiManager.saveConfig. + _reprioritizeNetworks: function(callback) { + // First, sort the networks in orer of their priority. + var ordered = Object.getOwnPropertyNames(this.configuredNetworks); + let self = this; + ordered.sort(function(a, b) { + var neta = self.configuredNetworks[a], + netb = self.configuredNetworks[b]; + + // Sort unsorted networks to the end of the list. + if (isNaN(neta.priority)) + return isNaN(netb.priority) ? 0 : 1; + if (isNaN(netb.priority)) + return -1; + return netb.priority - neta.priority; + }); + + // Skip unsorted networks. + let newPriority = 0, i; + for (i = ordered.length - 1; i >= 0; --i) { + if (!isNaN(this.configuredNetworks[ordered[i]].priority)) + break; + } + + // No networks we care about? + if (i < 0) { + WifiManager.saveConfig(callback); + return; + } + + // Now assign priorities from 0 to length, starting with the smallest + // priority and heading towards the highest (note the dependency between + // total and i here). + let done = 0, errors = 0, total = i + 1; + for (; i >= 0; --i) { + let network = this.configuredNetworks[ordered[i]]; + network.priority = newPriority++; + + // Note: networkUpdated declared below since it happens logically after + // this loop. + WifiManager.updateNetwork(network, networkUpdated); + } + + function networkUpdated(ok) { + if (!ok) + ++errors; + if (++done === total) { + if (errors > 0) { + callback(false); + return; + } + + WifiManager.saveConfig(function(ok) { + if (!ok) { + callback(false); + return; + } + + self._reloadConfiguredNetworks(function(ok) { + callback(ok); + }); + }); + } + } + }, + + // nsIWifi + + _domManagers: [], + _fireEvent: function(message, data) { + this._domManagers.forEach(function(manager) { + // Note: We should never have a dead message manager here because we + // observe our child message managers shutting down, below. + manager.sendAsyncMessage("WifiManager:" + message, data); + }); + }, + + _sendMessage: function(message, success, data, msg) { + try { + msg.manager.sendAsyncMessage(message + (success ? ":OK" : ":NO"), + { data: data, rid: msg.rid, mid: msg.mid }); + } catch (e) { + debug("sendAsyncMessage error : " + e); + } + this._splicePendingRequest(msg); + }, + + _domRequest: [], + + _splicePendingRequest: function(msg) { + for (let i = 0; i < this._domRequest.length; i++) { + if (this._domRequest[i].msg === msg) { + this._domRequest.splice(i, 1); + return; + } + } + }, + + _clearPendingRequest: function() { + if (this._domRequest.length === 0) return; + this._domRequest.forEach((function(req) { + this._sendMessage(req.name + ":Return", false, "Wifi is disabled", req.msg); + }).bind(this)); + }, + + receiveMessage: function MessageManager_receiveMessage(aMessage) { + let msg = aMessage.data || {}; + msg.manager = aMessage.target; + + if (WifiManager.p2pSupported()) { + // If p2pObserver returns something truthy, return it! + // Otherwise, continue to do the rest of tasks. + var p2pRet = this._p2pObserver.onDOMMessage(aMessage); + if (p2pRet) { + return p2pRet; + } + } + + // Note: By the time we receive child-process-shutdown, the child process + // has already forgotten its permissions so we do this before the + // permissions check. + if (aMessage.name === "child-process-shutdown") { + let i; + if ((i = this._domManagers.indexOf(msg.manager)) != -1) { + this._domManagers.splice(i, 1); + } + for (i = this._domRequest.length - 1; i >= 0; i--) { + if (this._domRequest[i].msg.manager === msg.manager) { + this._domRequest.splice(i, 1); + } + } + return; + } + + if (!aMessage.target.assertPermission("wifi-manage")) { + return; + } + + // We are interested in DOMRequests only. + if (aMessage.name != "WifiManager:getState") { + this._domRequest.push({name: aMessage.name, msg:msg}); + } + + switch (aMessage.name) { + case "WifiManager:setWifiEnabled": + this.setWifiEnabled(msg); + break; + case "WifiManager:getNetworks": + this.getNetworks(msg); + break; + case "WifiManager:getKnownNetworks": + this.getKnownNetworks(msg); + break; + case "WifiManager:associate": + this.associate(msg); + break; + case "WifiManager:forget": + this.forget(msg); + break; + case "WifiManager:wps": + this.wps(msg); + break; + case "WifiManager:setPowerSavingMode": + this.setPowerSavingMode(msg); + break; + case "WifiManager:setHttpProxy": + this.setHttpProxy(msg); + break; + case "WifiManager:setStaticIpMode": + this.setStaticIpMode(msg); + break; + case "WifiManager:importCert": + this.importCert(msg); + break; + case "WifiManager:getImportedCerts": + this.getImportedCerts(msg); + break; + case "WifiManager:deleteCert": + this.deleteCert(msg); + break; + case "WifiManager:setWifiTethering": + this.setWifiTethering(msg); + break; + case "WifiManager:getState": { + let i; + if ((i = this._domManagers.indexOf(msg.manager)) === -1) { + this._domManagers.push(msg.manager); + } + + let net = this.currentNetwork ? netToDOM(this.currentNetwork) : null; + return { network: net, + connectionInfo: this._lastConnectionInfo, + enabled: WifiManager.enabled, + status: translateState(WifiManager.state), + macAddress: this.macAddress, + capabilities: WifiManager.getCapabilities()}; + } + } + }, + + getNetworks: function(msg) { + const message = "WifiManager:getNetworks:Return"; + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + let sent = false; + let callback = (function (networks) { + if (sent) + return; + sent = true; + this._sendMessage(message, networks !== null, networks, msg); + }).bind(this); + this.waitForScan(callback); + + WifiManager.scan(true, (function(ok) { + // If the scan command succeeded, we're done. + if (ok) + return; + + // Avoid sending multiple responses. + if (sent) + return; + + // Otherwise, let the client know that it failed, it's responsible for + // trying again in a few seconds. + sent = true; + this._sendMessage(message, false, "ScanFailed", msg); + }).bind(this)); + }, + + getWifiScanResults: function(callback) { + var count = 0; + var timer = null; + var self = this; + + if (!WifiManager.enabled) { + callback.onfailure(); + return; + } + + self.waitForScan(waitForScanCallback); + doScan(); + function doScan() { + WifiManager.scan(true, (function (ok) { + if (!ok) { + if (!timer) { + count = 0; + timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + } + + if (count++ >= 3) { + timer = null; + self.wantScanResults.splice(self.wantScanResults.indexOf(waitForScanCallback), 1); + callback.onfailure(); + return; + } + + // Else it's still running, continue waiting. + timer.initWithCallback(doScan, 10000, Ci.nsITimer.TYPE_ONE_SHOT); + return; + } + }).bind(this)); + } + + function waitForScanCallback(networks) { + if (networks === null) { + callback.onfailure(); + return; + } + + var wifiScanResults = new Array(); + var net; + for (let net in networks) { + let value = networks[net]; + wifiScanResults.push(transformResult(value)); + } + callback.onready(wifiScanResults.length, wifiScanResults); + } + + function transformResult(element) { + var result = new WifiScanResult(); + result.connected = false; + for (let id in element) { + if (id === "__exposedProps__") { + continue; + } + if (id === "security") { + result[id] = 0; + var security = element[id]; + for (let j = 0; j < security.length; j++) { + if (security[j] === "WPA-PSK") { + result[id] |= Ci.nsIWifiScanResult.WPA_PSK; + } else if (security[j] === "WPA-EAP") { + result[id] |= Ci.nsIWifiScanResult.WPA_EAP; + } else if (security[j] === "WEP") { + result[id] |= Ci.nsIWifiScanResult.WEP; + } else { + result[id] = 0; + } + } + } else { + result[id] = element[id]; + } + } + return result; + } + }, + + getKnownNetworks: function(msg) { + const message = "WifiManager:getKnownNetworks:Return"; + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + this._reloadConfiguredNetworks((function(ok) { + if (!ok) { + this._sendMessage(message, false, "Failed", msg); + return; + } + + var networks = []; + for (let networkKey in this.configuredNetworks) { + networks.push(netToDOM(this.configuredNetworks[networkKey])); + } + + this._sendMessage(message, true, networks, msg); + }).bind(this)); + }, + + _setWifiEnabledCallback: function(status) { + if (status !== 0) { + this.requestDone(); + return; + } + + // If we're enabling ourselves, then wait until we've connected to the + // supplicant to notify. If we're disabling, we take care of this in + // supplicantlost. + if (WifiManager.supplicantStarted) + WifiManager.start(); + }, + + /** + * Compatibility flags for detecting if Gaia is controlling wifi by settings + * or API, once API is called, gecko will no longer accept wifi enable + * control from settings. + * This is used to deal with compatibility issue while Gaia adopted to use + * API but gecko doesn't remove the settings code in time. + * TODO: Remove this flag in Bug 1050147 + */ + ignoreWifiEnabledFromSettings: false, + setWifiEnabled: function(msg) { + const message = "WifiManager:setWifiEnabled:Return"; + let self = this; + let enabled = msg.data; + + self.ignoreWifiEnabledFromSettings = true; + // No change. + if (enabled === WifiManager.enabled) { + this._sendMessage(message, true, true, msg); + return; + } + + // Can't enable wifi while hotspot mode is enabled. + if (enabled && (this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] || + WifiManager.isWifiTetheringEnabled(WifiManager.tetheringState))) { + self._sendMessage(message, false, "Can't enable Wifi while hotspot mode is enabled", msg); + return; + } + + WifiManager.setWifiEnabled(enabled, function(ok) { + if (ok === 0 || ok === "no change") { + self._sendMessage(message, true, true, msg); + + // Reply error to pending requests. + if (!enabled) { + self._clearPendingRequest(); + } else { + WifiManager.start(); + } + } else { + self._sendMessage(message, false, "Set wifi enabled failed", msg); + } + }); + }, + + _setWifiEnabled: function(enabled, callback) { + // Reply error to pending requests. + if (!enabled) { + this._clearPendingRequest(); + } + + WifiManager.setWifiEnabled(enabled, callback); + }, + + // requestDone() must be called to before callback complete(or error) + // so next queue in the request quene can be executed. + // TODO: Remove command queue in Bug 1050147 + queueRequest: function(data, callback) { + if (!callback) { + throw "Try to enqueue a request without callback"; + } + + let optimizeCommandList = ["setWifiEnabled", "setWifiApEnabled"]; + if (optimizeCommandList.indexOf(data.command) != -1) { + this._stateRequests = this._stateRequests.filter(function(element) { + return element.data.command !== data.command; + }); + } + + this._stateRequests.push({ + data: data, + callback: callback + }); + + this.nextRequest(); + }, + + getWifiTetheringParameters: function getWifiTetheringParameters(enable) { + if (this.useTetheringAPI) { + return this.getWifiTetheringConfiguration(enable); + } else { + return this.getWifiTetheringParametersBySetting(enable); + } + }, + + getWifiTetheringConfiguration: function getWifiTetheringConfiguration(enable) { + let config = {}; + let params = this.tetheringConfig; + + let check = function(field, _default) { + config[field] = field in params ? params[field] : _default; + }; + + check("ssid", DEFAULT_WIFI_SSID); + check("security", DEFAULT_WIFI_SECURITY_TYPE); + check("key", DEFAULT_WIFI_SECURITY_PASSWORD); + check("ip", DEFAULT_WIFI_IP); + check("prefix", DEFAULT_WIFI_PREFIX); + check("wifiStartIp", DEFAULT_WIFI_DHCPSERVER_STARTIP); + check("wifiEndIp", DEFAULT_WIFI_DHCPSERVER_ENDIP); + check("usbStartIp", DEFAULT_USB_DHCPSERVER_STARTIP); + check("usbEndIp", DEFAULT_USB_DHCPSERVER_ENDIP); + check("dns1", DEFAULT_DNS1); + check("dns2", DEFAULT_DNS2); + + config.enable = enable; + config.mode = enable ? WIFI_FIRMWARE_AP : WIFI_FIRMWARE_STATION; + config.link = enable ? NETWORK_INTERFACE_UP : NETWORK_INTERFACE_DOWN; + + // Check the format to prevent netd from crash. + if (enable && (!config.ssid || config.ssid == "")) { + debug("Invalid SSID value."); + return null; + } + + if (enable && (config.security != WIFI_SECURITY_TYPE_NONE && !config.key)) { + debug("Invalid security password."); + return null; + } + + // Using the default values here until application supports these settings. + if (config.ip == "" || config.prefix == "" || + config.wifiStartIp == "" || config.wifiEndIp == "" || + config.usbStartIp == "" || config.usbEndIp == "") { + debug("Invalid subnet information."); + return null; + } + + return config; + }, + + getWifiTetheringParametersBySetting: function getWifiTetheringParametersBySetting(enable) { + let ssid; + let securityType; + let securityId; + let interfaceIp; + let prefix; + let wifiDhcpStartIp; + let wifiDhcpEndIp; + let usbDhcpStartIp; + let usbDhcpEndIp; + let dns1; + let dns2; + + ssid = this.tetheringSettings[SETTINGS_WIFI_SSID]; + securityType = this.tetheringSettings[SETTINGS_WIFI_SECURITY_TYPE]; + securityId = this.tetheringSettings[SETTINGS_WIFI_SECURITY_PASSWORD]; + interfaceIp = this.tetheringSettings[SETTINGS_WIFI_IP]; + prefix = this.tetheringSettings[SETTINGS_WIFI_PREFIX]; + wifiDhcpStartIp = this.tetheringSettings[SETTINGS_WIFI_DHCPSERVER_STARTIP]; + wifiDhcpEndIp = this.tetheringSettings[SETTINGS_WIFI_DHCPSERVER_ENDIP]; + usbDhcpStartIp = this.tetheringSettings[SETTINGS_USB_DHCPSERVER_STARTIP]; + usbDhcpEndIp = this.tetheringSettings[SETTINGS_USB_DHCPSERVER_ENDIP]; + dns1 = this.tetheringSettings[SETTINGS_WIFI_DNS1]; + dns2 = this.tetheringSettings[SETTINGS_WIFI_DNS2]; + + // Check the format to prevent netd from crash. + if (!ssid || ssid == "") { + debug("Invalid SSID value."); + return null; + } + // Truncate ssid if its length of encoded to utf8 is longer than 32. + while (unescape(encodeURIComponent(ssid)).length > 32) + { + ssid = ssid.substring(0, ssid.length-1); + } + + if (securityType != WIFI_SECURITY_TYPE_NONE && + securityType != WIFI_SECURITY_TYPE_WPA_PSK && + securityType != WIFI_SECURITY_TYPE_WPA2_PSK) { + + debug("Invalid security type."); + return null; + } + if (securityType != WIFI_SECURITY_TYPE_NONE && !securityId) { + debug("Invalid security password."); + return null; + } + // Using the default values here until application supports these settings. + if (interfaceIp == "" || prefix == "" || + wifiDhcpStartIp == "" || wifiDhcpEndIp == "" || + usbDhcpStartIp == "" || usbDhcpEndIp == "") { + debug("Invalid subnet information."); + return null; + } + + return { + ssid: ssid, + security: securityType, + key: securityId, + ip: interfaceIp, + prefix: prefix, + wifiStartIp: wifiDhcpStartIp, + wifiEndIp: wifiDhcpEndIp, + usbStartIp: usbDhcpStartIp, + usbEndIp: usbDhcpEndIp, + dns1: dns1, + dns2: dns2, + enable: enable, + mode: enable ? WIFI_FIRMWARE_AP : WIFI_FIRMWARE_STATION, + link: enable ? NETWORK_INTERFACE_UP : NETWORK_INTERFACE_DOWN + }; + }, + + setWifiApEnabled: function(enabled, callback) { + let configuration = this.getWifiTetheringParameters(enabled); + + if (!configuration) { + this.requestDone(); + debug("Invalid Wifi Tethering configuration."); + return; + } + + WifiManager.setWifiApEnabled(enabled, configuration, callback); + }, + + associate: function(msg) { + const MAX_PRIORITY = 9999; + const message = "WifiManager:associate:Return"; + let network = msg.data; + + let privnet = network; + let dontConnect = privnet.dontConnect; + delete privnet.dontConnect; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + let self = this; + function networkReady() { + // saveConfig now before we disable most of the other networks. + function selectAndConnect() { + WifiManager.enableNetwork(privnet.netId, true, function (ok) { + if (ok) + self._needToEnableNetworks = true; + if (WifiManager.state === "DISCONNECTED" || + WifiManager.state === "SCANNING") { + WifiManager.reconnect(function (ok) { + self._sendMessage(message, ok, ok, msg); + }); + } else { + self._sendMessage(message, ok, ok, msg); + } + }); + } + + var selectAndConnectOrReturn = dontConnect ? + function() { + self._sendMessage(message, true, "Wifi has been recorded", msg); + } : selectAndConnect; + if (self._highestPriority >= MAX_PRIORITY) { + self._reprioritizeNetworks(selectAndConnectOrReturn); + } else { + WifiManager.saveConfig(selectAndConnectOrReturn); + } + } + + function connectToNetwork() { + WifiManager.updateNetwork(privnet, (function(ok) { + if (!ok) { + self._sendMessage(message, false, "Network is misconfigured", msg); + return; + } + + networkReady(); + })); + } + + let ssid = privnet.ssid; + let networkKey = getNetworkKey(privnet); + let configured; + + if (networkKey in this._addingNetworks) { + this._sendMessage(message, false, "Racing associates"); + return; + } + + if (networkKey in this.configuredNetworks) + configured = this.configuredNetworks[networkKey]; + + netFromDOM(privnet, configured); + + privnet.priority = ++this._highestPriority; + if (configured) { + privnet.netId = configured.netId; + // Sync priority back to configured so if priority reaches MAX_PRIORITY, + // it can be sorted correctly in _reprioritizeNetworks() because the + // function sort network based on priority in configure list. + configured.priority = privnet.priority; + + // When investigating Bug 1123680, we observed that gaia may unexpectedly + // request to associate with incorrect password before successfully + // forgetting the network. It would cause the network unable to connect + // subsequently. Aside from preventing the racing forget/associate, we + // also try to disable network prior to updating the network. + WifiManager.getNetworkId(dequote(configured.ssid), function(netId) { + if (netId) { + WifiManager.disableNetwork(netId, function() { + connectToNetwork(); + }); + } + else { + connectToNetwork(); + } + }); + } else { + // networkReady, above, calls saveConfig. We want to remember the new + // network as being enabled, which isn't the default, so we explicitly + // set it to being "enabled" before we add it and save the + // configuration. + privnet.disabled = 0; + this._addingNetworks[networkKey] = privnet; + WifiManager.addNetwork(privnet, (function(ok) { + delete this._addingNetworks[networkKey]; + + if (!ok) { + this._sendMessage(message, false, "Network is misconfigured", msg); + return; + } + + this.configuredNetworks[networkKey] = privnet; + networkReady(); + }).bind(this)); + } + }, + + forget: function(msg) { + const message = "WifiManager:forget:Return"; + let network = msg.data; + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + this._reloadConfiguredNetworks((function(ok) { + // Give it a chance to remove the network even if reload is failed. + if (!ok) { + debug("Warning !!! Failed to reload the configured networks"); + } + + let ssid = network.ssid; + let networkKey = getNetworkKey(network); + if (!(networkKey in this.configuredNetworks)) { + this._sendMessage(message, false, "Trying to forget an unknown network", msg); + return; + } + + let self = this; + let configured = this.configuredNetworks[networkKey]; + this._reconnectOnDisconnect = (this.currentNetwork && + (this.currentNetwork.ssid === ssid)); + WifiManager.removeNetwork(configured.netId, function(ok) { + if (self._needToEnableNetworks) { + self._enableAllNetworks(); + self._needToEnableNetworks = false; + } + + if (!ok) { + self._sendMessage(message, false, "Unable to remove the network", msg); + self._reconnectOnDisconnect = false; + return; + } + + WifiManager.saveConfig(function() { + self._reloadConfiguredNetworks(function() { + self._sendMessage(message, true, true, msg); + }); + }); + }); + }).bind(this)); + }, + + wps: function(msg) { + const message = "WifiManager:wps:Return"; + let self = this; + let detail = msg.data; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + if (detail.method === "pbc") { + WifiManager.wpsPbc(function(ok) { + if (ok) + self._sendMessage(message, true, true, msg); + else + self._sendMessage(message, false, "WPS PBC failed", msg); + }); + } else if (detail.method === "pin") { + WifiManager.wpsPin(detail, function(pin) { + if (pin) + self._sendMessage(message, true, pin, msg); + else + self._sendMessage(message, false, "WPS PIN failed", msg); + }); + } else if (detail.method === "cancel") { + WifiManager.wpsCancel(function(ok) { + if (ok) + self._sendMessage(message, true, true, msg); + else + self._sendMessage(message, false, "WPS Cancel failed", msg); + }); + } else { + self._sendMessage(message, false, "Invalid WPS method=" + detail.method, + msg); + } + }, + + setPowerSavingMode: function(msg) { + const message = "WifiManager:setPowerSavingMode:Return"; + let self = this; + let enabled = msg.data; + let mode = enabled ? "AUTO" : "ACTIVE"; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + // Some wifi drivers may not implement this command. Set power mode + // even if suspend optimization command failed. + WifiManager.setSuspendOptimizations(enabled, function(ok) { + WifiManager.setPowerMode(mode, function(ok) { + if (ok) { + self._sendMessage(message, true, true, msg); + } else { + self._sendMessage(message, false, "Set power saving mode failed", msg); + } + }); + }); + }, + + setHttpProxy: function(msg) { + const message = "WifiManager:setHttpProxy:Return"; + let self = this; + let network = msg.data.network; + let info = msg.data.info; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + WifiManager.configureHttpProxy(network, info, function(ok) { + if (ok) { + // If configured network is current connected network + // need update http proxy immediately. + let setNetworkKey = getNetworkKey(network); + let curNetworkKey = self.currentNetwork ? getNetworkKey(self.currentNetwork) : null; + if (setNetworkKey === curNetworkKey) + WifiManager.setHttpProxy(network); + + self._sendMessage(message, true, true, msg); + } else { + self._sendMessage(message, false, "Set http proxy failed", msg); + } + }); + }, + + setStaticIpMode: function(msg) { + const message = "WifiManager:setStaticIpMode:Return"; + let self = this; + let network = msg.data.network; + let info = msg.data.info; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + // To compatiable with DHCP returned info structure, do translation here + info.ipaddr_str = info.ipaddr; + info.proxy_str = info.proxy; + info.gateway_str = info.gateway; + info.dns1_str = info.dns1; + info.dns2_str = info.dns2; + + WifiManager.setStaticIpMode(network, info, function(ok) { + if (ok) { + self._sendMessage(message, true, true, msg); + } else { + self._sendMessage(message, false, "Set static ip mode failed", msg); + } + }); + }, + + importCert: function importCert(msg) { + const message = "WifiManager:importCert:Return"; + let self = this; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + WifiManager.importCert(msg.data, function(data) { + if (data.status === 0) { + let usageString = ["ServerCert", "UserCert"]; + let usageArray = []; + for (let i = 0; i < usageString.length; i++) { + if (data.usageFlag & (0x01 << i)) { + usageArray.push(usageString[i]); + } + } + + self._sendMessage(message, true, { + nickname: data.nickname, + usage: usageArray + }, msg); + } else { + self._sendMessage(message, false, "Import Cert failed", msg); + } + }); + }, + + getImportedCerts: function getImportedCerts(msg) { + const message = "WifiManager:getImportedCerts:Return"; + let self = this; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + let certDB = Cc["@mozilla.org/security/x509certdb;1"] + .getService(Ci.nsIX509CertDB); + if (!certDB) { + self._sendMessage(message, false, "Failed to query NSS DB service", msg); + } + + let certList = certDB.getCerts(); + if (!certList) { + self._sendMessage(message, false, "Failed to get certificate List", msg); + } + + let certListEnum = certList.getEnumerator(); + if (!certListEnum) { + self._sendMessage(message, false, "Failed to get certificate List enumerator", msg); + } + let importedCerts = { + ServerCert: [], + UserCert: [], + }; + let UsageMapping = { + SERVERCERT: "ServerCert", + USERCERT: "UserCert", + }; + + while (certListEnum.hasMoreElements()) { + let certInfo = certListEnum.getNext().QueryInterface(Ci.nsIX509Cert); + let certNicknameInfo = /WIFI\_([A-Z]*)\_(.*)/.exec(certInfo.nickname); + if (!certNicknameInfo) { + continue; + } + importedCerts[UsageMapping[certNicknameInfo[1]]].push(certNicknameInfo[2]); + } + + self._sendMessage(message, true, importedCerts, msg); + }, + + deleteCert: function deleteCert(msg) { + const message = "WifiManager:deleteCert:Return"; + let self = this; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + WifiManager.deleteCert(msg.data, function(data) { + self._sendMessage(message, data.status === 0, "Delete Cert failed", msg); + }); + }, + + // TODO : These two variables should be removed once GAIA uses tethering API. + useTetheringAPI : false, + tetheringConfig : {}, + + setWifiTethering: function setWifiTethering(msg) { + const message = "WifiManager:setWifiTethering:Return"; + let self = this; + let enabled = msg.data.enabled; + + this.useTetheringAPI = true; + this.tetheringConfig = msg.data.config; + + if (WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is enabled", msg); + return; + } + + this.setWifiApEnabled(enabled, function() { + if ((enabled && WifiManager.tetheringState == "COMPLETED") || + (!enabled && WifiManager.tetheringState == "UNINITIALIZED")) { + self._sendMessage(message, true, msg.data, msg); + } else { + msg.data.reason = enabled ? + "Enable WIFI tethering faild" : "Disable WIFI tethering faild"; + self._sendMessage(message, false, msg.data, msg); + } + }); + }, + + // This is a bit ugly, but works. In particular, this depends on the fact + // that RadioManager never actually tries to get the worker from us. + get worker() { throw "Not implemented"; }, + + shutdown: function() { + debug("shutting down ..."); + this.queueRequest({command: "setWifiEnabled", value: false}, function(data) { + this._setWifiEnabled(false, this._setWifiEnabledCallback.bind(this)); + }.bind(this)); + }, + + // TODO: Remove command queue in Bug 1050147. + requestProcessing: false, // Hold while dequeue and execution a request. + // Released upon the request is fully executed, + // i.e, mostly after callback is done. + requestDone: function requestDone() { + this.requestProcessing = false; + this.nextRequest(); + }, + + nextRequest: function nextRequest() { + // No request to process + if (this._stateRequests.length === 0) { + return; + } + + // Handling request, wait for it. + if (this.requestProcessing) { + return; + } + + // Hold processing lock + this.requestProcessing = true; + + // Find next valid request + let request = this._stateRequests.shift(); + + request.callback(request.data); + }, + + notifyTetheringOn: function notifyTetheringOn() { + // It's really sad that we don't have an API to notify the wifi + // hotspot status. Toggle settings to let gaia know that wifi hotspot + // is enabled. + let self = this; + this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] = true; + this._oldWifiTetheringEnabledState = true; + gSettingsService.createLock().set( + SETTINGS_WIFI_TETHERING_ENABLED, + true, + { + handle: function(aName, aResult) { + self.requestDone(); + }, + handleError: function(aErrorMessage) { + self.requestDone(); + } + }); + }, + + notifyTetheringOff: function notifyTetheringOff() { + // It's really sad that we don't have an API to notify the wifi + // hotspot status. Toggle settings to let gaia know that wifi hotspot + // is disabled. + let self = this; + this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] = false; + this._oldWifiTetheringEnabledState = false; + gSettingsService.createLock().set( + SETTINGS_WIFI_TETHERING_ENABLED, + false, + { + handle: function(aName, aResult) { + self.requestDone(); + }, + handleError: function(aErrorMessage) { + self.requestDone(); + } + }); + }, + + handleWifiEnabled: function(enabled) { + if (this.ignoreWifiEnabledFromSettings) { + return; + } + + // Make sure Wifi hotspot is idle before switching to Wifi mode. + if (enabled) { + this.queueRequest({command: "setWifiApEnabled", value: false}, function(data) { + if (this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] || + WifiManager.isWifiTetheringEnabled(WifiManager.tetheringState)) { + this.disconnectedByWifi = true; + this.setWifiApEnabled(false, this.notifyTetheringOff.bind(this)); + } else { + this.requestDone(); + } + }.bind(this)); + } + + this.queueRequest({command: "setWifiEnabled", value: enabled}, function(data) { + this._setWifiEnabled(enabled, this._setWifiEnabledCallback.bind(this)); + }.bind(this)); + + if (!enabled) { + this.queueRequest({command: "setWifiApEnabled", value: true}, function(data) { + if (this.disconnectedByWifi) { + this.setWifiApEnabled(true, this.notifyTetheringOn.bind(this)); + } else { + this.requestDone(); + } + this.disconnectedByWifi = false; + }.bind(this)); + } + }, + + handleWifiTetheringEnabled: function(enabled) { + // Make sure Wifi is idle before switching to Wifi hotspot mode. + if (enabled) { + this.queueRequest({command: "setWifiEnabled", value: false}, function(data) { + if (WifiManager.isWifiEnabled(WifiManager.state)) { + this.disconnectedByWifiTethering = true; + this._setWifiEnabled(false, this._setWifiEnabledCallback.bind(this)); + } else { + this.requestDone(); + } + }.bind(this)); + } + + this.queueRequest({command: "setWifiApEnabled", value: enabled}, function(data) { + this.setWifiApEnabled(enabled, this.requestDone.bind(this)); + }.bind(this)); + + if (!enabled) { + this.queueRequest({command: "setWifiEnabled", value: true}, function(data) { + if (this.disconnectedByWifiTethering) { + this._setWifiEnabled(true, this._setWifiEnabledCallback.bind(this)); + } else { + this.requestDone(); + } + this.disconnectedByWifiTethering = false; + }.bind(this)); + } + }, + + // nsIObserver implementation + observe: function observe(subject, topic, data) { + switch (topic) { + case kMozSettingsChangedObserverTopic: + // To avoid WifiWorker setting the wifi again, don't need to deal with + // the "mozsettings-changed" event fired from internal setting. + if ("wrappedJSObject" in subject) { + subject = subject.wrappedJSObject; + } + if (subject.isInternalChange) { + return; + } + + this.handle(subject.key, subject.value); + break; + + case "xpcom-shutdown": + // Ensure the supplicant is detached from B2G to avoid XPCOM shutdown + // blocks forever. + WifiManager.ensureSupplicantDetached(() => { + let wifiService = Cc["@mozilla.org/wifi/service;1"].getService(Ci.nsIWifiProxyService); + wifiService.shutdown(); + let wifiCertService = Cc["@mozilla.org/wifi/certservice;1"].getService(Ci.nsIWifiCertService); + wifiCertService.shutdown(); + }); + break; + } + }, + + handle: function handle(aName, aResult) { + switch(aName) { + // TODO: Remove function call in Bug 1050147. + case SETTINGS_WIFI_ENABLED: + this.handleWifiEnabled(aResult) + break; + case SETTINGS_WIFI_DEBUG_ENABLED: + if (aResult === null) + aResult = false; + DEBUG = aResult; + updateDebug(); + break; + case SETTINGS_WIFI_TETHERING_ENABLED: + this._oldWifiTetheringEnabledState = this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED]; + // Fall through! + case SETTINGS_WIFI_SSID: + case SETTINGS_WIFI_SECURITY_TYPE: + case SETTINGS_WIFI_SECURITY_PASSWORD: + case SETTINGS_WIFI_IP: + case SETTINGS_WIFI_PREFIX: + case SETTINGS_WIFI_DHCPSERVER_STARTIP: + case SETTINGS_WIFI_DHCPSERVER_ENDIP: + case SETTINGS_WIFI_DNS1: + case SETTINGS_WIFI_DNS2: + case SETTINGS_USB_DHCPSERVER_STARTIP: + case SETTINGS_USB_DHCPSERVER_ENDIP: + // TODO: code related to wifi-tethering setting should be removed after GAIA + // use tethering API + if (this.useTetheringAPI) { + break; + } + + if (aResult !== null) { + this.tetheringSettings[aName] = aResult; + } + debug("'" + aName + "'" + " is now " + this.tetheringSettings[aName]); + let index = this._wifiTetheringSettingsToRead.indexOf(aName); + + if (index != -1) { + this._wifiTetheringSettingsToRead.splice(index, 1); + } + + if (this._wifiTetheringSettingsToRead.length) { + debug("We haven't read completely the wifi Tethering data from settings db."); + break; + } + + if (this._oldWifiTetheringEnabledState === this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED]) { + debug("No changes for SETTINGS_WIFI_TETHERING_ENABLED flag. Nothing to do."); + break; + } + + if (this._oldWifiTetheringEnabledState === null && + !this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED]) { + debug("Do nothing when initial settings for SETTINGS_WIFI_TETHERING_ENABLED flag is false."); + break; + } + + this._oldWifiTetheringEnabledState = this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED]; + this.handleWifiTetheringEnabled(aResult) + break; + }; + }, + + handleError: function handleError(aErrorMessage) { + debug("There was an error while reading Tethering settings."); + this.tetheringSettings = {}; + this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] = false; + }, +}; + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([WifiWorker]); + +var debug; +function updateDebug() { + if (DEBUG) { + debug = function (s) { + dump("-*- WifiWorker component: " + s + "\n"); + }; + } else { + debug = function (s) {}; + } + WifiManager.syncDebug(); +} +updateDebug(); |