The Tor Browser: comparison dom/wifi/WifiWorker.js

comparison: dom/wifi/WifiWorker.js

dom/wifi/WifiWorker.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:93e7a61fa5e7
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/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 kNetworkInterfaceStateChangedTopic = "network-interface-state-changed";
+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";
+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");
+// 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",
+ifname: libcutils.property_get("wifi.interface")
+};
+}
+let {sdkVersion, unloadDriverEnabled, schedScanRecovery,
+driverDelay, p2pSupported, eapSimSupported, ifname} = getStartupPrefs();
+let capabilities = {
+eapSim: eapSimSupported
+};
+let wifiListener = {
+onWaitEvent: function(event, iface) {
+if (manager.ifname === iface && handleEvent(event)) {
+waitForEvent(iface);
+} else if (p2pSupported) {
+if (WifiP2pManager.INTERFACE_NAME === iface) {
+// 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);
+// Wifi P2P stuff
+var p2pManager;
+if (p2pSupported) {
+let p2pCommand = WifiCommand(controlMessage, WifiP2pManager.INTERFACE_NAME);
+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 ((networkKey in httpProxyConfig) ? httpProxyConfig : null);
+}
+function setHttpProxy(network) {
+if (!network)
+return;
+gNetworkService.setNetworkProxy(network);
+}
+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 = stringToIp(info.ipaddr_str);
+info.gateway = stringToIp(info.gateway_str);
+info.mask_str = makeMask(info.maskLength);
+// Optional
+info.dns1 = stringToIp("dns1_str" in info ? info.dns1_str : "");
+info.dns2 = stringToIp("dns2_str" in info ? info.dns2_str : "");
+info.proxy = stringToIp("proxy_str" in info ? 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 iterface
+// 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.
+netUtil.disableInterface(manager.ifname, function (ok) {
+netUtil.enableInterface(manager.ifname, function (ok) {
+});
+});
+}
+});
+}
+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
+netUtil.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
+netUtil.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.
+netUtil.resetConnections(manager.ifname, function() {
+netUtil.stopDhcp(manager.ifname, function() {
+callback();
+});
+});
+}
+manager.start = function() {
+debug("detected SDK version " + sdkVersion);
+wifiCommand.connectToSupplicant(connectCallback);
+}
+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, function(data) {
+dhcpInfo = data.info;
+if (!dhcpInfo) {
+if (++manager.dhcpFailuresCount >= MAX_RETRIES_ON_DHCP_FAILURE) {
+manager.dhcpFailuresCount = 0;
+notify("disconnected", {ssid: manager.connectionInfo.ssid});
+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.getCurrentNetworkId = 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. CURRENT network.
+// 2. Trying to associate with SSID 'ssid' event
+if (network.status === "CURRENT" ||
+(ssid && ssid === dequote(network.ssid))) {
+return callback(net);
+}
+}
+callback(null);
+});
+}
+// 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", {ssid: manager.connectionInfo.ssid});
+}
+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 });
+}
+wifiCommand.closeSupplicantConnection(function() {
+manager.connectToSupplicant = false;
+});
+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", {ssid: manager.connectionInfo.ssid});
+}
+manager.connectionInfo.bssid = null;
+manager.connectionInfo.ssid = null;
+manager.connectionInfo.id = -1;
+return true;
+}
+// Association reject is triggered mostly on incorrect WEP key.
+if (eventData.indexOf("CTRL-EVENT-ASSOC-REJECT") === 0) {
+notify("passwordmaybeincorrect");
+if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) {
+manager.authenticationFailuresCount = 0;
+notify("disconnected", {ssid: manager.connectionInfo.ssid});
+}
+return true;
+}
+if (eventData.indexOf("CTRL-EVENT-EAP-FAILURE") === 0) {
+if (event.indexOf("EAP authentication failed") !== -1) {
+notify("passwordmaybeincorrect");
+}
+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("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 didConnectSupplicant(callback) {
+waitForEvent(manager.ifname);
+// Load up the supplicant state.
+getDebugEnabled(function(ok) {
+syncDebug();
+});
+wifiCommand.status(function(status) {
+parseStatus(status);
+notify("supplicantconnection");
+callback();
+});
+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() {
+netUtil.disableInterface(manager.ifname, function (ok) {
+suppressEvents = false;
+callback();
+});
+});
+}
+}
+// Initial state.
+manager.state = "UNINITIALIZED";
+manager.tetheringState = "UNINITIALIZED";
+manager.enabled = false;
+manager.supplicantStarted = false;
+manager.connectionInfo = { ssid: null, bssid: null, id: -1 };
+manager.authenticationFailuresCount = 0;
+manager.loopDetectionCount = 0;
+manager.dhcpFailuresCount = 0;
+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.name = manager.ifname;
+if (!WifiNetworkInterface.registered) {
+gNetworkManager.registerNetworkInterface(WifiNetworkInterface);
+WifiNetworkInterface.registered = true;
+}
+WifiNetworkInterface.state = Ci.nsINetworkInterface.NETWORK_STATE_DISCONNECTED;
+WifiNetworkInterface.ips = [];
+WifiNetworkInterface.prefixLengths = [];
+WifiNetworkInterface.gateways = [];
+WifiNetworkInterface.dnses = [];
+Services.obs.notifyObservers(WifiNetworkInterface,
+kNetworkInterfaceStateChangedTopic,
+null);
+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;
+netUtil.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() {
+wifiCommand.terminateSupplicant(function (ok) {
+manager.connectionDropped(function () {
+wifiCommand.stopSupplicant(function (status) {
+manager.state = "UNINITIALIZED";
+netUtil.disableInterface(manager.ifname, function (ok) {
+unloadDriver(WIFI_FIRMWARE_STATION, callback);
+});
+});
+});
+});
+}
+if (p2pSupported) {
+p2pManager.setEnabled(false, { onDisabled: doDisableWifi });
+} else {
+doDisableWifi();
+}
+}
+}
+// 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";
+return;
+}
+function doStartWifiTethering() {
+cancelWaitForDriverReadyTimer();
+WifiNetworkInterface.name = manager.ifname;
+gNetworkManager.setWifiTethering(enabled, WifiNetworkInterface,
+configuration, function(result) {
+if (result) {
+manager.tetheringState = "UNINITIALIZED";
+} else {
+manager.tetheringState = "COMPLETED";
+}
+// 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 {
+gNetworkManager.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 = [
+"ssid", "bssid", "psk", "wep_key0", "wep_key1", "wep_key2", "wep_key3",
+"wep_tx_keyidx", "priority", "key_mgmt", "scan_ssid", "disabled",
+"identity", "password", "auth_alg", "phase1", "phase2", "eap", "pin",
+"pcsc"
+];
+manager.getNetworkConfiguration = function(config, callback) {
+var netId = config.netId;
+var done = 0;
+for (var n = 0; n < networkConfigurationFields.length; ++n) {
+let fieldName = networkConfigurationFields[n];
+wifiCommand.getNetworkVariable(netId, fieldName, function(value) {
+if (value !== null)
+config[fieldName] = value;
+if (++done == networkConfigurationFields.length)
+callback(config);
+});
+}
+}
+manager.setNetworkConfiguration = function(config, callback) {
+var netId = config.netId;
+var done = 0;
+var errors = 0;
+for (var n = 0; n < networkConfigurationFields.length; ++n) {
+let fieldName = networkConfigurationFields[n];
+if (!(fieldName in config) ||
+// These fields are special: We can't retrieve them from the
+// supplicant, and often we have a star in our config. In that case,
+// we need to avoid overwriting the correct password with a *.
+(fieldName === "password" ||
+fieldName === "wep_key0" ||
+fieldName === "psk") &&
+config[fieldName] === '*') {
+++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 = result[0];
+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);
+}
+function stringToIp(string) {
+let ip = 0;
+let start, end = -1;
+for (let i = 0; i < 4; i++) {
+start = end + 1;
+end = string.indexOf(".", start);
+if (end == -1) {
+end = string.length;
+}
+let num = parseInt(string.slice(start, end), 10);
+if (isNaN(num)) {
+return 0;
+}
+ip |= num << (i * 8);
+}
+return ip;
+}
+function swap32(n) {
+return (((n >> 24) & 0xFF) <<  0) |
+(((n >> 16) & 0xFF) <<  8) |
+(((n >>  8) & 0xFF) << 16) |
+(((n >>  0) & 0xFF) << 24);
+}
+function ntohl(n) {
+return swap32(n);
+}
+function makeMask(len) {
+let mask = 0;
+for (let i = 0; i < len; ++i) {
+mask |= (0x80000000 >> i);
+}
+return ntohl(mask);
+}
+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.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.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", {ssid: manager.connectionInfo.ssid});
+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;
+}
+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 == "WPA-EAP") {
+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 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, security, password, capabilities) {
+this.ssid = ssid;
+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",
+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"
+};
+// Note: We never use ScanResult.prototype, so the fact that it's unrelated to
+// Network.prototype is OK.
+function ScanResult(ssid, bssid, flags, signal) {
+Network.call(this, ssid, 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);
+}
+let WifiNetworkInterface = {
+QueryInterface: XPCOMUtils.generateQI([Ci.nsINetworkInterface]),
+registered: false,
+// nsINetworkInterface
+NETWORK_STATE_UNKNOWN:       Ci.nsINetworkInterface.NETWORK_STATE_UNKNOWN,
+NETWORK_STATE_CONNECTING:    Ci.nsINetworkInterface.CONNECTING,
+NETWORK_STATE_CONNECTED:     Ci.nsINetworkInterface.CONNECTED,
+NETWORK_STATE_DISCONNECTING: Ci.nsINetworkInterface.DISCONNECTING,
+NETWORK_STATE_DISCONNECTED:  Ci.nsINetworkInterface.DISCONNECTED,
+state: Ci.nsINetworkInterface.NETWORK_STATE_UNKNOWN,
+NETWORK_TYPE_WIFI:        Ci.nsINetworkInterface.NETWORK_TYPE_WIFI,
+NETWORK_TYPE_MOBILE:      Ci.nsINetworkInterface.NETWORK_TYPE_MOBILE,
+NETWORK_TYPE_MOBILE_MMS:  Ci.nsINetworkInterface.NETWORK_TYPE_MOBILE_MMS,
+NETWORK_TYPE_MOBILE_SUPL: Ci.nsINetworkInterface.NETWORK_TYPE_MOBILE_SUPL,
+type: Ci.nsINetworkInterface.NETWORK_TYPE_WIFI,
+name: null,
+ips: [],
+prefixLengths: [],
+dnses: [],
+gateways: [],
+httpProxyHost: null,
+httpProxyPort: null,
+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();
+}
+};
+function WifiScanResult() {}
+// TODO Make the difference between a DOM-based network object and our
+// networks objects much clearer.
+let netToDOM;
+let 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",
+"child-process-shutdown"];
+messages.forEach((function(msgName) {
+this._mm.addMessageListener(msgName, this);
+}).bind(this));
+Services.obs.addObserver(this, kMozSettingsChangedObserverTopic, false);
+this.wantScanResults = [];
+this._allowWpaEap = false;
+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) {
+var ssid = dequote(net.ssid);
+var security = (net.key_mgmt === "NONE" && net.wep_key0) ? ["WEP"] :
+(net.key_mgmt && net.key_mgmt !== "NONE") ? [net.key_mgmt] :
+[];
+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, security, password);
+if (net.identity)
+pub.identity = dequote(net.identity);
+if (net.netId)
+pub.known = true;
+if (net.scan_ssid === 1)
+pub.hidden = true;
+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";
+}
+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";
+}
+if ("pin" in net) {
+net.pin = quote(net.pin);
+}
+if ("phase1" in net)
+net.phase1 = quote(net.phase1);
+if ("phase2" in net)
+net.phase2 = quote(net.phase2);
+return net;
+};
+WifiManager.onsupplicantconnection = function() {
+debug("Connected to supplicant");
+WifiManager.enabled = true;
+self._reloadConfiguredNetworks(function(ok) {
+// Prime this.networks.
+if (!ok)
+return;
+self.waitForScan(function firstScan() {});
+// 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() {})
+});
+try {
+self._allowWpaEap = WifiManager.getCapabilities().eapSim;
+} catch (e) {
+self._allowWpaEap = false;
+}
+// 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.enabled = 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;
+}
+WifiManager.getCurrentNetworkId(this.ssid, function(netId) {
+// Trying to get netId from current network.
+if (!netId &&
+self.currentNetwork &&
+typeof self.currentNetwork.netId !== "undefined") {
+netId = self.currentNetwork.netId;
+}
+if (netId) {
+WifiManager.disableNetwork(netId, function() {});
+}
+});
+self._fireEvent("onconnectingfailed", {network: 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.
+self.currentNetwork =
+{ bssid: WifiManager.connectionInfo.bssid,
+ssid: quote(WifiManager.connectionInfo.ssid) };
+self._fireEvent("onconnecting", { network: netToDOM(self.currentNetwork) });
+break;
+case "ASSOCIATED":
+if (!self.currentNetwork) {
+self.currentNetwork =
+{ bssid: WifiManager.connectionInfo.bssid,
+ssid: quote(WifiManager.connectionInfo.ssid) };
+}
+self.currentNetwork.netId = this.id;
+WifiManager.getNetworkConfiguration(self.currentNetwork, function (){});
+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;
+}
+// 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 = { ssid: quote(WifiManager.connectionInfo.ssid),
+netId: WifiManager.connectionInfo.id };
+WifiManager.getNetworkConfiguration(self.currentNetwork, function(){});
+}
+// Update http proxy when connected to network.
+let netConnect = WifiManager.getHttpProxyNetwork(self.currentNetwork);
+if (netConnect)
+WifiManager.setHttpProxy(netConnect);
+// The full authentication process is completed, reset the count.
+WifiManager.authenticationFailuresCount = 0;
+WifiManager.loopDetectionCount = 0;
+self._startConnectionInfoTimer();
+self._fireEvent("onassociate", { network: netToDOM(self.currentNetwork) });
+break;
+case "CONNECTED":
+// 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.state ===
+Ci.nsINetworkInterface.NETWORK_STATE_DISCONNECTED) &&
+(this.prevState === "INITIALIZING" ||
+this.prevState === "DISCONNECTED" ||
+this.prevState === "INTERFACE_DISABLED" ||
+this.prevState === "INACTIVE" ||
+this.prevState === "UNINITIALIZED")) {
+return;
+}
+self._fireEvent("ondisconnect", {});
+// When disconnected, clear the http proxy setting if it exists.
+// Temporarily set http proxy to empty and restore user setting after setHttpProxy.
+let netDisconnect = WifiManager.getHttpProxyNetwork(self.currentNetwork);
+if (netDisconnect) {
+let prehttpProxyHostSetting = netDisconnect.httpProxyHost;
+let prehttpProxyPortSetting = netDisconnect.httpProxyPort;
+netDisconnect.httpProxyHost = "";
+netDisconnect.httpProxyPort = 0;
+WifiManager.setHttpProxy(netDisconnect);
+netDisconnect.httpProxyHost = prehttpProxyHostSetting;
+netDisconnect.httpProxyPort = prehttpProxyPortSetting;
+}
+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.state =
+Ci.nsINetworkInterface.NETWORK_STATE_DISCONNECTED;
+WifiNetworkInterface.ips = [];
+WifiNetworkInterface.prefixLengths = [];
+WifiNetworkInterface.gateways = [];
+WifiNetworkInterface.dnses = [];
+Services.obs.notifyObservers(WifiNetworkInterface,
+kNetworkInterfaceStateChangedTopic,
+null);
+break;
+case "WPS_TIMEOUT":
+self._fireEvent("onwpstimeout", {});
+break;
+case "WPS_FAIL":
+self._fireEvent("onwpsfail", {});
+break;
+case "WPS_OVERLAP_DETECTED":
+self._fireEvent("onwpsoverlap", {});
+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.
+}
+WifiNetworkInterface.state =
+Ci.nsINetworkInterface.NETWORK_STATE_CONNECTED;
+WifiNetworkInterface.ips = [this.info.ipaddr_str];
+WifiNetworkInterface.prefixLengths = [maskLength];
+WifiNetworkInterface.gateways = [this.info.gateway_str];
+if (typeof this.info.dns1_str == "string" &&
+this.info.dns1_str.length) {
+WifiNetworkInterface.dnses.push(this.info.dns1_str);
+}
+if (typeof this.info.dns2_str == "string" &&
+this.info.dns2_str.length) {
+WifiNetworkInterface.dnses.push(this.info.dns2_str);
+}
+Services.obs.notifyObservers(WifiNetworkInterface,
+kNetworkInterfaceStateChangedTopic,
+null);
+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;
+}
+// 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],
+signalLevel = match[3],
+flags = match[4];
+// Skip ad-hoc networks which aren't supported (bug 811635).
+if (flags && flags.indexOf("[IBSS]") >= 0)
+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, 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 = "*";
+}
+} else if (!self._allowWpaEap &&
+(eapIndex = network.security.indexOf("WPA-EAP")) >= 0) {
+// Don't offer to connect to WPA-EAP networks unless one has been
+// configured through other means (e.g. it was added directly to
+// wpa_supplicant.conf). Here, we have an unknown WPA-EAP network,
+// so we ignore it entirely if it only supports WPA-EAP, otherwise
+// we take EAP out of the list and offer the rest of the
+// security.
+if (network.security.length === 1)
+continue;
+network.security.splice(eapIndex, 1);
+}
+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 = [];
+});
+};
+// 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.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 each (let net in this.configuredNetworks) {
+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) ((percent / 10) | 0)
+if (last && last.linkSpeed === info.linkSpeed &&
+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.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: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: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 };
+}
+}
+},
+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;
+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();
+},
+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.
+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) {
+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;
+}
+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);
+}
+}
+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;
+WifiManager.updateNetwork(privnet, (function(ok) {
+if (!ok) {
+this._sendMessage(message, false, "Network is misconfigured", msg);
+return;
+}
+networkReady();
+}).bind(this));
+} 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 (!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 (detail.method === "pbc") {
+WifiManager.wpsPbc(WifiManager.ifname, 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";
+// 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;
+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:setStaticMode:Return";
+let self = this;
+let network = msg.data.network;
+let info = msg.data.info;
+// 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);
+}
+});
+},
+// 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));
+},
+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();
+}
+},
+"fromInternalSetting");
+},
+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();
+}
+},
+"fromInternalSetting");
+},
+handleWifiEnabled: function(enabled) {
+// 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) {
+// Note that this function gets called for any and all settings changes,
+// so we need to carefully check if we have the one we're interested in.
+// The string we're interested in will be a JSON string that looks like:
+// {"key":"wifi.enabled","value":"true"}.
+if (topic !== kMozSettingsChangedObserverTopic) {
+return;
+}
+let setting = JSON.parse(data);
+// To avoid WifiWorker setting the wifi again, don't need to deal with
+// the "mozsettings-changed" event fired from internal setting.
+if (setting.message && setting.message === "fromInternalSetting") {
+return;
+}
+this.handle(setting.key, setting.value);
+},
+handle: function handle(aName, aResult) {
+switch(aName) {
+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:
+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]);
+let debug;
+function updateDebug() {
+if (DEBUG) {
+debug = function (s) {
+dump("-*- WifiWorker component: " + s + "\n");
+};
+} else {
+debug = function (s) {};
+}
+WifiManager.syncDebug();
+}
+updateDebug();