The Tor Browser / file revision

 /* -*- 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;