diff options
Diffstat (limited to 'dom/wifi')
42 files changed, 14001 insertions, 0 deletions
diff --git a/dom/wifi/DOMWifiManager.js b/dom/wifi/DOMWifiManager.js new file mode 100644 index 000000000..8bedfc398 --- /dev/null +++ b/dom/wifi/DOMWifiManager.js @@ -0,0 +1,543 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/DOMRequestHelper.jsm"); + +const DEBUG = false; // set to false to suppress debug messages + +const DOMWIFIMANAGER_CONTRACTID = "@mozilla.org/wifimanager;1"; +const DOMWIFIMANAGER_CID = Components.ID("{c9b5f09e-25d2-40ca-aef4-c4d13d93c706}"); + +function MozWifiNetwork() { +} + +MozWifiNetwork.prototype = { + + init: function(aWindow) { + this._window = aWindow; + }, + + __init: function(obj) { + for (let key in obj) { + this[key] = obj[key]; + } + }, + + classID: Components.ID("{c01fd751-43c0-460a-8b64-abf652ec7220}"), + contractID: "@mozilla.org/mozwifinetwork;1", + QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports, + Ci.nsIDOMGlobalPropertyInitializer]) +}; + +function MozWifiConnection(obj) { + this.status = obj.status; + this.network = obj.network; +} + +MozWifiConnection.prototype = { + classID: Components.ID("{23579da4-201b-4319-bd42-9b7f337343ac}"), + contractID: "@mozilla.org/mozwificonnection;1", + QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]) +}; + +function MozWifiConnectionInfo(obj) { + this.signalStrength = obj.signalStrength; + this.relSignalStrength = obj.relSignalStrength; + this.linkSpeed = obj.linkSpeed; + this.ipAddress = obj.ipAddress; +} + +MozWifiConnectionInfo.prototype = { + classID: Components.ID("{83670352-6ed4-4c35-8de9-402296a1959c}"), + contractID: "@mozilla.org/mozwificonnectioninfo;1", + QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]) +} + +function MozWifiCapabilities(obj) { + this.security = obj.security; + this.eapMethod = obj.eapMethod; + this.eapPhase2 = obj.eapPhase2; + this.certificate = obj.certificate; +} + +MozWifiCapabilities.prototype = { + classID: Components.ID("08c88ece-8092-481b-863b-5515a52e411a"), + contractID: "@mozilla.org/mozwificapabilities;1", + QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]) +} + +function DOMWifiManager() { + this.defineEventHandlerGetterSetter("onstatuschange"); + this.defineEventHandlerGetterSetter("onconnectioninfoupdate"); + this.defineEventHandlerGetterSetter("onenabled"); + this.defineEventHandlerGetterSetter("ondisabled"); + this.defineEventHandlerGetterSetter("onstationinfoupdate"); +} + +DOMWifiManager.prototype = { + __proto__: DOMRequestIpcHelper.prototype, + classDescription: "DOMWifiManager", + classID: DOMWIFIMANAGER_CID, + contractID: DOMWIFIMANAGER_CONTRACTID, + QueryInterface: XPCOMUtils.generateQI([Ci.nsIDOMGlobalPropertyInitializer, + Ci.nsISupportsWeakReference, + Ci.nsIObserver]), + + // nsIDOMGlobalPropertyInitializer implementation + init: function(aWindow) { + // Maintain this state for synchronous APIs. + this._currentNetwork = null; + this._connectionStatus = "disconnected"; + this._enabled = false; + this._lastConnectionInfo = null; + this._capabilities = null; + this._stationNumber = 0; + + const messages = ["WifiManager:getNetworks:Return:OK", "WifiManager:getNetworks:Return:NO", + "WifiManager:getKnownNetworks:Return:OK", "WifiManager:getKnownNetworks:Return:NO", + "WifiManager:associate:Return:OK", "WifiManager:associate:Return:NO", + "WifiManager:forget:Return:OK", "WifiManager:forget:Return:NO", + "WifiManager:wps:Return:OK", "WifiManager:wps:Return:NO", + "WifiManager:setPowerSavingMode:Return:OK", "WifiManager:setPowerSavingMode:Return:NO", + "WifiManager:setHttpProxy:Return:OK", "WifiManager:setHttpProxy:Return:NO", + "WifiManager:setStaticIpMode:Return:OK", "WifiManager:setStaticIpMode:Return:NO", + "WifiManager:importCert:Return:OK", "WifiManager:importCert:Return:NO", + "WifiManager:getImportedCerts:Return:OK", "WifiManager:getImportedCerts:Return:NO", + "WifiManager:deleteCert:Return:OK", "WifiManager:deleteCert:Return:NO", + "WifiManager:setWifiEnabled:Return:OK", "WifiManager:setWifiEnabled:Return:NO", + "WifiManager:wifiDown", "WifiManager:wifiUp", + "WifiManager:onconnecting", "WifiManager:onassociate", + "WifiManager:onconnect", "WifiManager:ondisconnect", + "WifiManager:onwpstimeout", "WifiManager:onwpsfail", + "WifiManager:onwpsoverlap", "WifiManager:connectioninfoupdate", + "WifiManager:onauthenticating", "WifiManager:onconnectingfailed", + "WifiManager:stationinfoupdate"]; + this.initDOMRequestHelper(aWindow, messages); + this._mm = Cc["@mozilla.org/childprocessmessagemanager;1"].getService(Ci.nsISyncMessageSender); + + var state = this._mm.sendSyncMessage("WifiManager:getState")[0]; + if (state) { + this._currentNetwork = this._convertWifiNetwork(state.network); + this._lastConnectionInfo = this._convertConnectionInfo(state.connectionInfo); + this._enabled = state.enabled; + this._connectionStatus = state.status; + this._macAddress = state.macAddress; + this._capabilities = this._convertWifiCapabilities(state.capabilities); + } else { + this._currentNetwork = null; + this._lastConnectionInfo = null; + this._enabled = false; + this._connectionStatus = "disconnected"; + this._macAddress = ""; + } + }, + + _convertWifiNetworkToJSON: function(aNetwork) { + let json = {}; + + for (let key in aNetwork) { + // In WifiWorker.js there are lots of check using "key in network". + // So if the value of any property of WifiNetwork is undefined, do not clone it. + if (aNetwork[key] != undefined) { + json[key] = aNetwork[key]; + } + } + return json; + }, + + _convertWifiNetwork: function(aNetwork) { + let network = aNetwork ? new this._window.MozWifiNetwork(aNetwork) : null; + return network; + }, + + _convertWifiNetworks: function(aNetworks) { + let networks = new this._window.Array(); + for (let i in aNetworks) { + networks.push(this._convertWifiNetwork(aNetworks[i])); + } + return networks; + }, + + _convertConnection: function(aConn) { + let conn = aConn ? new MozWifiConnection(aConn) : null; + return conn; + }, + + _convertConnectionInfo: function(aInfo) { + let info = aInfo ? new MozWifiConnectionInfo(aInfo) : null; + return info; + }, + + _convertWifiCapabilities: function(aCapabilities) { + let capabilities = aCapabilities ? + new MozWifiCapabilities(aCapabilities) : null; + return capabilities; + }, + + _sendMessageForRequest: function(name, data, request) { + let id = this.getRequestId(request); + this._mm.sendAsyncMessage(name, { data: data, rid: id, mid: this._id }); + }, + + receiveMessage: function(aMessage) { + let msg = aMessage.json; + if (msg.mid && msg.mid != this._id) + return; + + let request; + if (msg.rid) { + request = this.takeRequest(msg.rid); + if (!request) { + return; + } + } + + switch (aMessage.name) { + case "WifiManager:setWifiEnabled:Return:OK": + Services.DOMRequest.fireSuccess(request, msg.data); + break; + + case "WifiManager:setWifiEnabled:Return:NO": + Services.DOMRequest.fireError(request, "Unable to enable/disable Wifi"); + break; + + case "WifiManager:getNetworks:Return:OK": + Services.DOMRequest.fireSuccess(request, this._convertWifiNetworks(msg.data)); + break; + + case "WifiManager:getNetworks:Return:NO": + Services.DOMRequest.fireError(request, "Unable to scan for networks"); + break; + + case "WifiManager:getKnownNetworks:Return:OK": + Services.DOMRequest.fireSuccess(request, this._convertWifiNetworks(msg.data)); + break; + + case "WifiManager:getKnownNetworks:Return:NO": + Services.DOMRequest.fireError(request, "Unable to get known networks"); + break; + + case "WifiManager:associate:Return:OK": + Services.DOMRequest.fireSuccess(request, true); + break; + + case "WifiManager:associate:Return:NO": + Services.DOMRequest.fireError(request, "Unable to add the network"); + break; + + case "WifiManager:forget:Return:OK": + Services.DOMRequest.fireSuccess(request, true); + break; + + case "WifiManager:forget:Return:NO": + Services.DOMRequest.fireError(request, msg.data); + break; + + case "WifiManager:wps:Return:OK": + Services.DOMRequest.fireSuccess(request, msg.data); + break; + + case "WifiManager:wps:Return:NO": + Services.DOMRequest.fireError(request, msg.data); + break; + + case "WifiManager:setPowerSavingMode:Return:OK": + Services.DOMRequest.fireSuccess(request, msg.data); + break; + + case "WifiManager:setPowerSavingMode:Return:NO": + Services.DOMRequest.fireError(request, msg.data); + break; + + case "WifiManager:setHttpProxy:Return:OK": + Services.DOMRequest.fireSuccess(request, msg.data); + break; + + case "WifiManager:setHttpProxy:Return:NO": + Services.DOMRequest.fireError(request, msg.data); + break; + + case "WifiManager:setStaticIpMode:Return:OK": + Services.DOMRequest.fireSuccess(request, msg.data); + break; + + case "WifiManager:setStaticIpMode:Return:NO": + Services.DOMRequest.fireError(request, msg.data); + break; + + case "WifiManager:importCert:Return:OK": + Services.DOMRequest.fireSuccess(request, Cu.cloneInto(msg.data, this._window)); + break; + + case "WifiManager:importCert:Return:NO": + Services.DOMRequest.fireError(request, msg.data); + break; + + case "WifiManager:getImportedCerts:Return:OK": + Services.DOMRequest.fireSuccess(request, Cu.cloneInto(msg.data, this._window)); + break; + + case "WifiManager:getImportedCerts:Return:NO": + Services.DOMRequest.fireError(request, msg.data); + break; + + case "WifiManager:deleteCert:Return:OK": + Services.DOMRequest.fireSuccess(request, msg.data); + break; + + case "WifiManager:deleteCert:Return:NO": + Services.DOMRequest.fireError(request, msg.data); + break; + + case "WifiManager:wifiDown": + this._enabled = false; + this._currentNetwork = null; + this._fireEnabledOrDisabled(false); + break; + + case "WifiManager:wifiUp": + this._enabled = true; + this._macAddress = msg.macAddress; + this._fireEnabledOrDisabled(true); + break; + + case "WifiManager:onconnecting": + this._currentNetwork = this._convertWifiNetwork(msg.network); + this._connectionStatus = "connecting"; + this._fireStatusChangeEvent(msg.network); + break; + + case "WifiManager:onassociate": + this._currentNetwork = this._convertWifiNetwork(msg.network); + this._connectionStatus = "associated"; + this._fireStatusChangeEvent(msg.network); + break; + + case "WifiManager:onconnect": + this._currentNetwork = this._convertWifiNetwork(msg.network); + this._connectionStatus = "connected"; + this._fireStatusChangeEvent(msg.network); + break; + + case "WifiManager:ondisconnect": + this._currentNetwork = null; + this._connectionStatus = "disconnected"; + this._lastConnectionInfo = null; + this._fireStatusChangeEvent(msg.network); + break; + + case "WifiManager:onwpstimeout": + this._currentNetwork = null; + this._connectionStatus = "wps-timedout"; + this._lastConnectionInfo = null; + this._fireStatusChangeEvent(msg.network); + break; + + case "WifiManager:onwpsfail": + this._currentNetwork = null; + this._connectionStatus = "wps-failed"; + this._lastConnectionInfo = null; + this._fireStatusChangeEvent(msg.network); + break; + + case "WifiManager:onwpsoverlap": + this._currentNetwork = null; + this._connectionStatus = "wps-overlapped"; + this._lastConnectionInfo = null; + this._fireStatusChangeEvent(msg.network); + break; + + case "WifiManager:connectioninfoupdate": + this._lastConnectionInfo = this._convertConnectionInfo(msg); + this._fireConnectionInfoUpdate(msg); + break; + case "WifiManager:onconnectingfailed": + this._currentNetwork = null; + this._connectionStatus = "connectingfailed"; + this._lastConnectionInfo = null; + this._fireStatusChangeEvent(msg.network); + break; + case "WifiManager:onauthenticating": + this._currentNetwork = this._convertWifiNetwork(msg.network); + this._connectionStatus = "authenticating"; + this._fireStatusChangeEvent(msg.network); + break; + case "WifiManager:stationinfoupdate": + this._stationNumber = msg.station; + this._fireStationInfoUpdate(msg); + break; + } + }, + + _fireStatusChangeEvent: function StatusChangeEvent(aNetwork) { + var event = new this._window.MozWifiStatusChangeEvent("statuschange", + { network: this._convertWifiNetwork(aNetwork), + status: this._connectionStatus + }); + this.__DOM_IMPL__.dispatchEvent(event); + }, + + _fireConnectionInfoUpdate: function onConnectionInfoUpdate(info) { + var evt = new this._window.MozWifiConnectionInfoEvent("connectioninfoupdate", + { network: this._currentNetwork, + signalStrength: info.signalStrength, + relSignalStrength: info.relSignalStrength, + linkSpeed: info.linkSpeed, + ipAddress: info.ipAddress, + }); + this.__DOM_IMPL__.dispatchEvent(evt); + }, + + _fireEnabledOrDisabled: function enabledDisabled(enabled) { + var evt = new this._window.Event(enabled ? "enabled" : "disabled"); + this.__DOM_IMPL__.dispatchEvent(evt); + }, + + _fireStationInfoUpdate: function onStationInfoUpdate(info) { + var evt = new this._window.MozWifiStationInfoEvent("stationinfoupdate", + { station: this._stationNumber} + ); + this.__DOM_IMPL__.dispatchEvent(evt); + }, + + setWifiEnabled: function setWifiEnabled(enabled) { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:setWifiEnabled", enabled, request); + return request; + }, + + getNetworks: function getNetworks() { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:getNetworks", null, request); + return request; + }, + + getKnownNetworks: function getKnownNetworks() { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:getKnownNetworks", null, request); + return request; + }, + + associate: function associate(network) { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:associate", + this._convertWifiNetworkToJSON(network), request); + return request; + }, + + forget: function forget(network) { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:forget", + this._convertWifiNetworkToJSON(network), request); + return request; + }, + + wps: function wps(detail) { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:wps", detail, request); + return request; + }, + + setPowerSavingMode: function setPowerSavingMode(enabled) { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:setPowerSavingMode", enabled, request); + return request; + }, + + setHttpProxy: function setHttpProxy(network, info) { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:setHttpProxy", + { network: this._convertWifiNetworkToJSON(network), info:info}, request); + return request; + }, + + setStaticIpMode: function setStaticIpMode(network, info) { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:setStaticIpMode", + { network: this._convertWifiNetworkToJSON(network), info: info}, request); + return request; + }, + + importCert: function nsIDOMWifiManager_importCert(certBlob, certPassword, certNickname) { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:importCert", + { + certBlob: certBlob, + certPassword: certPassword, + certNickname: certNickname + }, request); + return request; + }, + + getImportedCerts: function nsIDOMWifiManager_getImportedCerts() { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:getImportedCerts", null, request); + return request; + }, + + deleteCert: function nsIDOMWifiManager_deleteCert(certNickname) { + var request = this.createRequest(); + this._sendMessageForRequest("WifiManager:deleteCert", + { + certNickname: certNickname + }, request); + return request; + }, + + get enabled() { + return this._enabled; + }, + + get macAddress() { + return this._macAddress; + }, + + get connection() { + let _connection = this._convertConnection({ status: this._connectionStatus, + network: this._currentNetwork, + }); + return _connection; + }, + + get connectionInformation() { + return this._lastConnectionInfo; + }, + + get capabilities() { + return this._capabilities; + }, + + defineEventHandlerGetterSetter: function(name) { + Object.defineProperty(this, name, { + get: function() { + return this.__DOM_IMPL__.getEventHandler(name); + }, + set: function(handler) { + this.__DOM_IMPL__.setEventHandler(name, handler); + } + }); + }, +}; + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([ + DOMWifiManager, MozWifiNetwork, MozWifiConnection, MozWifiCapabilities, + MozWifiConnectionInfo +]); + +var debug; +if (DEBUG) { + debug = function (s) { + dump("-*- DOMWifiManager component: " + s + "\n"); + }; +} else { + debug = function (s) {}; +} diff --git a/dom/wifi/DOMWifiManager.manifest b/dom/wifi/DOMWifiManager.manifest new file mode 100644 index 000000000..3ba83c1b2 --- /dev/null +++ b/dom/wifi/DOMWifiManager.manifest @@ -0,0 +1,18 @@ +# DOMWifiManager.js +component {c9b5f09e-25d2-40ca-aef4-c4d13d93c706} DOMWifiManager.js +contract @mozilla.org/wifimanager;1 {c9b5f09e-25d2-40ca-aef4-c4d13d93c706} + +component {c01fd751-43c0-460a-8b64-abf652ec7220} DOMWifiManager.js +contract @mozilla.org/mozwifinetwork;1 {c01fd751-43c0-460a-8b64-abf652ec7220} + +component {23579da4-201b-4319-bd42-9b7f337343ac} DOMWifiManager.js +contract @mozilla.org/mozwificonnection;1 {23579da4-201b-4319-bd42-9b7f337343ac} + +component {83670352-6ed4-4c35-8de9-402296a1959c} DOMWifiManager.js +contract @mozilla.org/mozwificonnectioninfo;1 {83670352-6ed4-4c35-8de9-402296a1959c} + +component {ad5c5295-85fb-4460-8e0c-e130d3f029ab} DOMWifiManager.js +contract @mozilla.org/mozwificertificateinfo;1 {ad5c5295-85fb-4460-8e0c-e130d3f029ab} + +component {08c88ece-8092-481b-863b-5515a52e411a} DOMWifiManager.js +contract @mozilla.org/mozwificapabilities;1 {08c88ece-8092-481b-863b-5515a52e411a} diff --git a/dom/wifi/DOMWifiP2pManager.js b/dom/wifi/DOMWifiP2pManager.js new file mode 100644 index 000000000..3a5637521 --- /dev/null +++ b/dom/wifi/DOMWifiP2pManager.js @@ -0,0 +1,328 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/DOMRequestHelper.jsm"); + +const DEBUG = false; + +// interface MozWifiP2pGroupOwner implementation. + +function MozWifiP2pGroupOwner(aGo) { + this.groupName = aGo.groupName; + this.macAddress = aGo.macAddress; + this.ipAddress = aGo.ipAddress; + this.passphrase = aGo.passphrase; + this.ssid = aGo.ssid; + this.wpsCapabilities = aGo.wpsCapabilities; + this.freq = aGo.freq; + this.isLocal = aGo.isLocal; +} + +MozWifiP2pGroupOwner.prototype = { + classID: Components.ID("{a9b81450-349d-11e3-aa6e-0800200c9a66}"), + contractID: "@mozilla.org/wifip2pgroupowner;1", + QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports]) +}; + +// interface MozWifiP2pManager implementation. + +const MOZ_WIFIP2PMANAGER_CONTRACTID = "@mozilla.org/wifip2pmanager;1"; +const MOZ_WIFIP2PMANAGER_CID = Components.ID("{8d9125a0-3498-11e3-aa6e-0800200c9a66}"); + +function MozWifiP2pManager() { + this.defineEventHandlerGetterSetter("onstatuschange"); + this.defineEventHandlerGetterSetter("onpeerinfoupdate"); + this.defineEventHandlerGetterSetter("onenabled"); + this.defineEventHandlerGetterSetter("ondisabled"); + + this.currentPeer = null; + this.enabled = false; + this.groupOwner = null; +} + +// For smaller, read-only APIs, we expose any property that doesn't begin with +// an underscore. +function exposeReadOnly(obj) { + let exposedProps = {}; + for (let i in obj) { + if (i[0] === "_") { + continue; + } + exposedProps[i] = "r"; + } + + obj.__exposedProps__ = exposedProps; + return obj; +} + +function debug(msg) { + if (DEBUG) { + dump('-------------- MozWifiP2pManager: ' + msg); + } +} + +MozWifiP2pManager.prototype = { + __proto__: DOMRequestIpcHelper.prototype, + + classID: MOZ_WIFIP2PMANAGER_CID, + contractID: MOZ_WIFIP2PMANAGER_CONTRACTID, + QueryInterface: XPCOMUtils.generateQI([Ci.nsIDOMGlobalPropertyInitializer, + Ci.nsISupportsWeakReference, + Ci.nsIObserver, + Ci.nsISupports]), + + // + // nsIDOMGlobalPropertyInitializer implementation. + // + + init: function(aWindow) { + const messages = ["WifiP2pManager:setScanEnabled:Return:OK", + "WifiP2pManager:setScanEnabled:Return:NO", + "WifiP2pManager:getPeerList:Return:OK", + "WifiP2pManager:getPeerList:Return:NO", + "WifiP2pManager:connect:Return:OK", + "WifiP2pManager:connect:Return:NO", + "WifiP2pManager:disconnect:Return:OK", + "WifiP2pManager:disconnect:Return:NO", + "WifiP2pManager:setPairingConfirmation:Return", + "WifiP2pManager:setDeviceName:Return:OK", + "WifiP2pManager:setDeviceName:Return:NO", + + "WifiP2pManager:p2pDown", + "WifiP2pManager:p2pUp", + "WifiP2pManager:onconnecting", + "WifiP2pManager:onconnected", + "WifiP2pManager:ondisconnected", + "WifiP2pManager:ongroupnstop", + "WifiP2pManager:onconnectingfailed", + "WifiP2pManager:onwpstimeout", + "WifiP2pManager:onwpsfail", + "WifiP2pManager:onpeerinfoupdate", + ]; + + this.initDOMRequestHelper(aWindow, messages); + this._mm = Cc["@mozilla.org/childprocessmessagemanager;1"].getService(Ci.nsISyncMessageSender); + + // Notify the internal a new DOM mananger is created. + let state = this._mm.sendSyncMessage("WifiP2pManager:getState")[0]; + if (state) { + debug('State: ' + JSON.stringify(state)); + this.enabled = state.enabled; + this.currentPeer = state.currentPeer; + if (state.groupOwner) { + this.groupOwner = new MozWifiP2pGroupOwner(state.groupOwner); + } + } else { + debug('Failed to get state'); + } + }, + + uninit: function() { + }, + + _sendMessageForRequest: function(name, data, request) { + let id = this.getRequestId(request); + this._mm.sendAsyncMessage(name, { data: data, rid: id, mid: this._id }); + }, + + receiveMessage: function(aMessage) { + let msg = aMessage.json; + if (msg.mid && msg.mid !== this._id) { + return; + } + + let request; + switch (aMessage.name) { + case "WifiP2pManager:setScanEnabled:Return:OK": + request = this.takeRequest(msg.rid); + Services.DOMRequest.fireSuccess(request, exposeReadOnly(msg.data)); + break; + + case "WifiP2pManager:setScanEnabled:Return:NO": + request = this.takeRequest(msg.rid); + Services.DOMRequest.fireError(request, "Unable to enable/disable Wifi P2P peer discovery."); + break; + + case "WifiP2pManager:getPeerList:Return:OK": + request = this.takeRequest(msg.rid); + Services.DOMRequest.fireSuccess(request, Cu.cloneInto(msg.data, this._window)); + break; + + case "WifiP2pManager:getPeerList:Return:NO": + request = this.takeRequest(msg.rid); + Services.DOMRequest.fireError(request, "Unable to disable Wifi P2P peer discovery."); + break; + + case "WifiP2pManager:connect:Return:OK": + request = this.takeRequest(msg.rid); + Services.DOMRequest.fireSuccess(request, exposeReadOnly(msg.data)); + break; + + case "WifiP2pManager:connect:Return:NO": + request = this.takeRequest(msg.rid); + Services.DOMRequest.fireError(request, "Unable to connect to Wifi P2P peer."); + break; + + case "WifiP2pManager:disconnect:Return:OK": + request = this.takeRequest(msg.rid); + Services.DOMRequest.fireSuccess(request, exposeReadOnly(msg.data)); + break; + + case "WifiP2pManager:disconnect:Return:NO": + request = this.takeRequest(msg.rid); + Services.DOMRequest.fireError(request, "Unable to disconnect to Wifi P2P peer."); + break; + + case "WifiP2pManager:setDeviceName:Return:OK": + request = this.takeRequest(msg.rid); + Services.DOMRequest.fireSuccess(request, exposeReadOnly(msg.data)); + break; + + case "WifiP2pManager:setDeviceName:Return:NO": + request = this.takeRequest(msg.rid); + Services.DOMRequest.fireError(request, "Unable to set device name."); + break; + + case "WifiP2pManager:p2pDown": + this.enabled = false; + this.currentPeer = null; + this._fireEnabledOrDisabled(false); + break; + + case "WifiP2pManager:p2pUp": + this.enabled = true; + this._fireEnabledOrDisabled(true); + break; + + case "WifiP2pManager:onconnecting": + debug('onconnecting with peer: ' + JSON.stringify(msg.peer)); + this.currentPeer = msg.peer; + this._fireStatusChangeEvent(msg.peer.address); + break; + + case "WifiP2pManager:onconnected": + debug('onconnected with peer: ' + JSON.stringify(msg.peer)); + this.currentPeer = msg.peer; + this.groupOwner = new MozWifiP2pGroupOwner(msg.groupOwner); + this._fireStatusChangeEvent(msg.peer.address); + break; + + case "WifiP2pManager:ondisconnected": + debug('ondisconnected with peer: ' + JSON.stringify(msg.peer)); + this.currentPeer = null; + this.groupOwner = null; + this._fireStatusChangeEvent(msg.peer.address); + break; + + case "WifiP2pManager:onconnectingfailed": + this._fireStatusChangeEvent(null); + break; + + case "WifiP2pManager:onwpstimeout": + this._fireStatusChangeEvent(null); + break; + + case "WifiP2pManager:onwpsfail": + this._fireStatusChangeEvent(null); + break; + + case "WifiP2pManager:onpeerinfoupdate": + this._firePeerInfoUpdateEvent(); + break; + } + }, + + _firePeerInfoUpdateEvent: function PeerInfoUpdate() { + let evt = new this._window.Event("peerinfoupdate"); + this.__DOM_IMPL__.dispatchEvent(evt); + }, + + _fireStatusChangeEvent: function WifiP2pStatusChange(peerAddress) { + let evt = new this._window.MozWifiP2pStatusChangeEvent("statuschange", + { peerAddress: peerAddress }); + this.__DOM_IMPL__.dispatchEvent(evt); + }, + + _fireEnabledOrDisabled: function enabledDisabled(enabled) { + let evt = new this._window.Event(enabled ? "enabled" : "disabled"); + this.__DOM_IMPL__.dispatchEvent(evt); + }, + + // + // WifiP2pManager.webidl implementation. + // + + enableScan: function () { + let request = this.createRequest(); + this._sendMessageForRequest("WifiP2pManager:enableScan", null, request); + return request; + }, + + disableScan: function () { + let request = this.createRequest(); + this._sendMessageForRequest("WifiP2pManager:disableScan", null, request); + return request; + }, + + setScanEnabled: function(enabled) { + let request = this.createRequest(); + this._sendMessageForRequest("WifiP2pManager:setScanEnabled", enabled, request); + return request; + }, + + connect: function (address, wpsMethod, goIntent) { + let request = this.createRequest(); + let connectionInfo = { address: address, wpsMethod: wpsMethod, goIntent: goIntent }; + this._sendMessageForRequest("WifiP2pManager:connect", connectionInfo, request); + return request; + }, + + disconnect: function (address) { + let request = this.createRequest(); + this._sendMessageForRequest("WifiP2pManager:disconnect", address, request); + return request; + }, + + getPeerList: function () { + let request = this.createRequest(); + this._sendMessageForRequest("WifiP2pManager:getPeerList", null, request); + return request; + }, + + setPairingConfirmation: function (accepted, pin) { + let request = this.createRequest(); + let result = { accepted: accepted, pin: pin }; + this._sendMessageForRequest("WifiP2pManager:setPairingConfirmation", result, request); + return request; + }, + + setDeviceName: function(newDeviceName) { + let request = this.createRequest(); + this._sendMessageForRequest("WifiP2pManager:setDeviceName", newDeviceName, request); + return request; + }, + + // Helpers. + defineEventHandlerGetterSetter: function(event) { + Object.defineProperty(this, event, { + get: function() { + return this.__DOM_IMPL__.getEventHandler(event); + }, + + set: function(handler) { + this.__DOM_IMPL__.setEventHandler(event, handler); + } + }); + }, +}; + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([MozWifiP2pManager, MozWifiP2pGroupOwner]); diff --git a/dom/wifi/DOMWifiP2pManager.manifest b/dom/wifi/DOMWifiP2pManager.manifest new file mode 100644 index 000000000..bc80efa48 --- /dev/null +++ b/dom/wifi/DOMWifiP2pManager.manifest @@ -0,0 +1,6 @@ +# DOMWifiP2pManager.js +component {8d9125a0-3498-11e3-aa6e-0800200c9a66} DOMWifiP2pManager.js +contract @mozilla.org/wifip2pmanager;1 {8d9125a0-3498-11e3-aa6e-0800200c9a66} + +component {a9b81450-349d-11e3-aa6e-0800200c9a66} DOMWifiP2pManager.js +contract @mozilla.org/wifip2pgroupowner;1 {a9b81450-349d-11e3-aa6e-0800200c9a66}
\ No newline at end of file diff --git a/dom/wifi/StateMachine.jsm b/dom/wifi/StateMachine.jsm new file mode 100644 index 000000000..94b876f82 --- /dev/null +++ b/dom/wifi/StateMachine.jsm @@ -0,0 +1,205 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +Cu.import("resource://gre/modules/Services.jsm"); + +this.EXPORTED_SYMBOLS = ["StateMachine"]; + +const DEBUG = false; + +this.StateMachine = function(aDebugTag) { + function debug(aMsg) { + dump('-------------- StateMachine:' + aDebugTag + ': ' + aMsg); + } + + var sm = {}; + + var _initialState; + var _curState; + var _prevState; + var _paused; + var _eventQueue = []; + var _deferredEventQueue = []; + var _defaultEventHandler; + + // Public interfaces. + + sm.setDefaultEventHandler = function(aDefaultEventHandler) { + _defaultEventHandler = aDefaultEventHandler; + }; + + sm.start = function(aInitialState) { + _initialState = aInitialState; + sm.gotoState(_initialState); + }; + + sm.sendEvent = function (aEvent) { + if (!_initialState) { + if (DEBUG) { + debug('StateMachine is not running. Call StateMachine.start() first.'); + } + return; + } + _eventQueue.push(aEvent); + asyncCall(handleFirstEvent); + }; + + sm.getPreviousState = function() { + return _prevState; + }; + + sm.getCurrentState = function() { + return _curState; + }; + + // State object maker. + // @param aName string for this state's name. + // @param aDelegate object: + // .handleEvent: required. + // .enter: called before entering this state (optional). + // .exit: called before exiting this state (optional). + sm.makeState = function (aName, aDelegate) { + if (!aDelegate.handleEvent) { + throw "handleEvent is a required delegate function."; + } + var nop = function() {}; + return { + name: aName, + enter: (aDelegate.enter || nop), + exit: (aDelegate.exit || nop), + handleEvent: aDelegate.handleEvent + }; + }; + + sm.deferEvent = function (aEvent) { + // The definition of a 'deferred event' is: + // We are not able to handle this event now but after receiving + // certain event or entering a new state, we might be able to handle + // it. For example, we couldn't handle CONNECT_EVENT in the + // diconnecting state. But once we finish doing "disconnecting", we + // could then handle CONNECT_EVENT! + // + // So, the deferred event may be handled in the following cases: + // 1. Once we entered a new state. + // 2. Once we handled a regular event. + if (DEBUG) { + debug('Deferring event: ' + JSON.stringify(aEvent)); + } + _deferredEventQueue.push(aEvent); + }; + + // Goto the new state. If the current state is null, the exit + // function won't be called. + sm.gotoState = function (aNewState) { + if (_curState) { + if (DEBUG) { + debug("exiting state: " + _curState.name); + } + _curState.exit(); + } + + _prevState = _curState; + _curState = aNewState; + + if (DEBUG) { + debug("entering state: " + _curState.name); + } + _curState.enter(); + + // We are in the new state now. We got a chance to handle the + // deferred events. + handleDeferredEvents(); + + sm.resume(); + }; + + // No incoming event will be handled after you call pause(). + // (But they will be queued.) + sm.pause = function() { + _paused = true; + }; + + // Continue to handle incoming events. + sm.resume = function() { + _paused = false; + asyncCall(handleFirstEvent); + }; + + //---------------------------------------------------------- + // Private stuff + //---------------------------------------------------------- + + function asyncCall(f) { + Services.tm.currentThread.dispatch(f, Ci.nsIThread.DISPATCH_NORMAL); + } + + function handleFirstEvent() { + var hadDeferredEvents; + + if (0 === _eventQueue.length) { + return; + } + + if (_paused) { + return; // The state machine is paused now. + } + + hadDeferredEvents = _deferredEventQueue.length > 0; + + handleOneEvent(_eventQueue.shift()); // The handler may defer this event. + + // We've handled one event. If we had deferred events before, now is + // a good chance to handle them. + if (hadDeferredEvents) { + handleDeferredEvents(); + } + + // Continue to handle the next regular event. + handleFirstEvent(); + } + + function handleDeferredEvents() { + if (_deferredEventQueue.length && DEBUG) { + debug('Handle deferred events: ' + _deferredEventQueue.length); + } + for (let i = 0; i < _deferredEventQueue.length; i++) { + handleOneEvent(_deferredEventQueue.shift()); + } + } + + function handleOneEvent(aEvent) + { + if (DEBUG) { + debug('Handling event: ' + JSON.stringify(aEvent)); + } + + var handled = _curState.handleEvent(aEvent); + + if (undefined === handled) { + throw "handleEvent returns undefined: " + _curState.name; + } + if (!handled) { + // Event is not handled in the current state. Try handleEventCommon(). + handled = (_defaultEventHandler ? _defaultEventHandler(aEvent) : handled); + } + if (undefined === handled) { + throw "handleEventCommon returns undefined: " + _curState.name; + } + if (!handled) { + if (DEBUG) { + debug('!!!!!!!!! FIXME !!!!!!!!! Event not handled: ' + JSON.stringify(aEvent)); + } + } + + return handled; + } + + return sm; +}; diff --git a/dom/wifi/WifiCertService.cpp b/dom/wifi/WifiCertService.cpp new file mode 100644 index 000000000..85e0d2f5b --- /dev/null +++ b/dom/wifi/WifiCertService.cpp @@ -0,0 +1,536 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#include "WifiCertService.h" + +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/EndianUtils.h" +#include "mozilla/ModuleUtils.h" +#include "mozilla/RefPtr.h" +#include "mozilla/dom/File.h" +#include "mozilla/dom/ToJSValue.h" +#include "cert.h" +#include "certdb.h" +#include "CryptoTask.h" +#include "nsIDOMBlob.h" +#include "nsIWifiService.h" +#include "nsNetUtil.h" +#include "nsIInputStream.h" +#include "nsServiceManagerUtils.h" +#include "nsXULAppAPI.h" +#include "ScopedNSSTypes.h" + +#define NS_WIFICERTSERVICE_CID \ + { 0x83585afd, 0x0e11, 0x43aa, {0x83, 0x46, 0xf3, 0x4d, 0x97, 0x5e, 0x46, 0x77} } + +using namespace mozilla; +using namespace mozilla::dom; + +namespace mozilla { + +// The singleton Wifi Cert service, to be used on the main thread. +StaticRefPtr<WifiCertService> gWifiCertService; + +class ImportCertTask final: public CryptoTask +{ +public: + ImportCertTask(int32_t aId, Blob* aCertBlob, + const nsAString& aCertPassword, + const nsAString& aCertNickname) + : mBlob(aCertBlob) + , mPassword(aCertPassword) + { + MOZ_ASSERT(NS_IsMainThread()); + + mResult.mId = aId; + mResult.mStatus = 0; + mResult.mUsageFlag = 0; + mResult.mNickname = aCertNickname; + } + +private: + virtual void ReleaseNSSResources() {} + + virtual nsresult CalculateResult() override + { + MOZ_ASSERT(!NS_IsMainThread()); + + // read data from blob. + nsCString blobBuf; + nsresult rv = ReadBlob(blobBuf); + if (NS_FAILED(rv)) { + return rv; + } + + char* buf; + uint32_t size = blobBuf.GetMutableData(&buf); + if (size == 0) { + return NS_ERROR_OUT_OF_MEMORY; + } + + // Try import as DER format first. + rv = ImportDERBlob(buf, size); + if (NS_SUCCEEDED(rv)) { + return rv; + } + + // Try import as PKCS#12 format. + return ImportPKCS12Blob(buf, size, mPassword); + } + + virtual void CallCallback(nsresult rv) + { + if (NS_FAILED(rv)) { + mResult.mStatus = -1; + } + gWifiCertService->DispatchResult(mResult); + } + + nsresult ImportDERBlob(char* buf, uint32_t size) + { + // Create certificate object. + ScopedCERTCertificate cert(CERT_DecodeCertFromPackage(buf, size)); + if (!cert) { + return MapSECStatus(SECFailure); + } + + // Import certificate. + return ImportCert(cert); + } + + static SECItem* + HandleNicknameCollision(SECItem* aOldNickname, PRBool* aCancel, void* aWincx) + { + const char* dummyName = "Imported User Cert"; + const size_t dummyNameLen = strlen(dummyName); + SECItem* newNick = ::SECITEM_AllocItem(nullptr, nullptr, dummyNameLen + 1); + if (!newNick) { + return nullptr; + } + + newNick->type = siAsciiString; + // Dummy name, will be renamed later. + memcpy(newNick->data, dummyName, dummyNameLen + 1); + newNick->len = dummyNameLen; + + return newNick; + } + + static SECStatus + HandleNicknameUpdate(const CERTCertificate *aCert, + const SECItem *default_nickname, + SECItem **new_nickname, + void *arg) + { + WifiCertServiceResultOptions *result = (WifiCertServiceResultOptions *)arg; + + nsCString userNickname; + CopyUTF16toUTF8(result->mNickname, userNickname); + + nsCString fullNickname; + if (aCert->isRoot && (aCert->nsCertType & NS_CERT_TYPE_SSL_CA)) { + // Accept self-signed SSL CA as server certificate. + fullNickname.AssignLiteral("WIFI_SERVERCERT_"); + fullNickname += userNickname; + result->mUsageFlag |= nsIWifiCertService::WIFI_CERT_USAGE_FLAG_SERVER; + } else if (aCert->nsCertType & NS_CERT_TYPE_SSL_CLIENT) { + // User Certificate + fullNickname.AssignLiteral("WIFI_USERCERT_"); + fullNickname += userNickname; + result->mUsageFlag |= nsIWifiCertService::WIFI_CERT_USAGE_FLAG_USER; + } + char* nickname; + uint32_t length = fullNickname.GetMutableData(&nickname); + + SECItem* newNick = ::SECITEM_AllocItem(nullptr, nullptr, length + 1); + if (!newNick) { + return SECFailure; + } + + newNick->type = siAsciiString; + memcpy(newNick->data, nickname, length + 1); + newNick->len = length; + + *new_nickname = newNick; + return SECSuccess; + } + + nsresult ImportPKCS12Blob(char* buf, uint32_t size, const nsAString& aPassword) + { + nsString password(aPassword); + + // password is null-terminated wide-char string. + // passwordItem is required to be big-endian form of password, stored in char + // array, including the null-termination. + uint32_t length = password.Length() + 1; + ScopedSECItem passwordItem( + ::SECITEM_AllocItem(nullptr, nullptr, length * sizeof(nsString::char_type))); + + if (!passwordItem) { + return NS_ERROR_FAILURE; + } + + mozilla::NativeEndian::copyAndSwapToBigEndian(passwordItem->data, + password.BeginReading(), + length); + // Create a decoder. + ScopedSEC_PKCS12DecoderContext p12dcx(SEC_PKCS12DecoderStart( + passwordItem, nullptr, nullptr, + nullptr, nullptr, nullptr, nullptr, + nullptr)); + + if (!p12dcx) { + return NS_ERROR_FAILURE; + } + + // Assign data to decorder. + SECStatus srv = SEC_PKCS12DecoderUpdate(p12dcx, + reinterpret_cast<unsigned char*>(buf), + size); + if (srv != SECSuccess) { + return MapSECStatus(srv); + } + + // Verify certificates. + srv = SEC_PKCS12DecoderVerify(p12dcx); + if (srv != SECSuccess) { + return MapSECStatus(srv); + } + + // Set certificate nickname and usage flag. + srv = SEC_PKCS12DecoderRenameCertNicknames(p12dcx, HandleNicknameUpdate, + &mResult); + + // Validate certificates. + srv = SEC_PKCS12DecoderValidateBags(p12dcx, HandleNicknameCollision); + if (srv != SECSuccess) { + return MapSECStatus(srv); + } + + // Initialize slot. + ScopedPK11SlotInfo slot(PK11_GetInternalKeySlot()); + if (!slot) { + return NS_ERROR_FAILURE; + } + if (PK11_NeedLogin(slot) && PK11_NeedUserInit(slot)) { + srv = PK11_InitPin(slot, "", ""); + if (srv != SECSuccess) { + return MapSECStatus(srv); + } + } + + // Import cert and key. + srv = SEC_PKCS12DecoderImportBags(p12dcx); + if (srv != SECSuccess) { + return MapSECStatus(srv); + } + + // User certificate must be imported from PKCS#12. + return (mResult.mUsageFlag & nsIWifiCertService::WIFI_CERT_USAGE_FLAG_USER) + ? NS_OK : NS_ERROR_FAILURE; + } + + nsresult ReadBlob(/*out*/ nsCString& aBuf) + { + NS_ENSURE_ARG_POINTER(mBlob); + + static const uint64_t MAX_FILE_SIZE = 16384; + + ErrorResult rv; + uint64_t size = mBlob->GetSize(rv); + if (NS_WARN_IF(rv.Failed())) { + return rv.StealNSResult(); + } + + if (size > MAX_FILE_SIZE) { + return NS_ERROR_FILE_TOO_BIG; + } + + nsCOMPtr<nsIInputStream> inputStream; + mBlob->GetInternalStream(getter_AddRefs(inputStream), rv); + if (NS_WARN_IF(rv.Failed())) { + return rv.StealNSResult(); + } + + rv = NS_ReadInputStreamToString(inputStream, aBuf, (uint32_t)size); + if (NS_WARN_IF(rv.Failed())) { + return rv.StealNSResult(); + } + + return NS_OK; + } + + nsresult ImportCert(CERTCertificate* aCert) + { + nsCString userNickname, fullNickname; + + CopyUTF16toUTF8(mResult.mNickname, userNickname); + // Determine certificate nickname by adding prefix according to its type. + if (aCert->isRoot && (aCert->nsCertType & NS_CERT_TYPE_SSL_CA)) { + // Accept self-signed SSL CA as server certificate. + fullNickname.AssignLiteral("WIFI_SERVERCERT_"); + fullNickname += userNickname; + mResult.mUsageFlag |= nsIWifiCertService::WIFI_CERT_USAGE_FLAG_SERVER; + } else if (aCert->nsCertType & NS_CERT_TYPE_SSL_CLIENT) { + // User Certificate + fullNickname.AssignLiteral("WIFI_USERCERT_"); + fullNickname += userNickname; + mResult.mUsageFlag |= nsIWifiCertService::WIFI_CERT_USAGE_FLAG_USER; + } else { + return NS_ERROR_ABORT; + } + + char* nickname; + uint32_t length; + length = fullNickname.GetMutableData(&nickname); + if (length == 0) { + return NS_ERROR_UNEXPECTED; + } + + // Import certificate, duplicated nickname will cause error. + SECStatus srv = CERT_AddTempCertToPerm(aCert, nickname, nullptr); + if (srv != SECSuccess) { + return MapSECStatus(srv); + } + + return NS_OK; + } + + RefPtr<Blob> mBlob; + nsString mPassword; + WifiCertServiceResultOptions mResult; +}; + +class DeleteCertTask final: public CryptoTask +{ +public: + DeleteCertTask(int32_t aId, const nsAString& aCertNickname) + { + MOZ_ASSERT(NS_IsMainThread()); + + mResult.mId = aId; + mResult.mStatus = 0; + mResult.mUsageFlag = 0; + mResult.mNickname = aCertNickname; + } + +private: + virtual void ReleaseNSSResources() {} + + virtual nsresult CalculateResult() override + { + MOZ_ASSERT(!NS_IsMainThread()); + + nsCString userNickname; + CopyUTF16toUTF8(mResult.mNickname, userNickname); + + // Delete server certificate. + nsCString serverCertName("WIFI_SERVERCERT_", 16); + serverCertName += userNickname; + nsresult rv = deleteCert(serverCertName); + if (NS_FAILED(rv)) { + return rv; + } + + // Delete user certificate and private key. + nsCString userCertName("WIFI_USERCERT_", 14); + userCertName += userNickname; + rv = deleteCert(userCertName); + if (NS_FAILED(rv)) { + return rv; + } + + return NS_OK; + } + + nsresult deleteCert(const nsCString &aCertNickname) + { + ScopedCERTCertificate cert( + CERT_FindCertByNickname(CERT_GetDefaultCertDB(), aCertNickname.get()) + ); + // Because we delete certificates in blind, so it's acceptable to delete + // a non-exist certificate. + if (!cert) { + return NS_OK; + } + + ScopedPK11SlotInfo slot( + PK11_KeyForCertExists(cert, nullptr, nullptr) + ); + + SECStatus srv; + if (slot) { + // Delete private key along with certificate. + srv = PK11_DeleteTokenCertAndKey(cert, nullptr); + } else { + srv = SEC_DeletePermCertificate(cert); + } + + if (srv != SECSuccess) { + return MapSECStatus(srv); + } + + return NS_OK; + } + + virtual void CallCallback(nsresult rv) + { + if (NS_FAILED(rv)) { + mResult.mStatus = -1; + } + gWifiCertService->DispatchResult(mResult); + } + + WifiCertServiceResultOptions mResult; +}; + +NS_IMPL_ISUPPORTS(WifiCertService, nsIWifiCertService) + +NS_IMETHODIMP +WifiCertService::Start(nsIWifiEventListener* aListener) +{ + MOZ_ASSERT(aListener); + + mListener = aListener; + + return NS_OK; +} + +NS_IMETHODIMP +WifiCertService::Shutdown() +{ + MOZ_ASSERT(NS_IsMainThread()); + + mListener = nullptr; + + return NS_OK; +} + +void +WifiCertService::DispatchResult(const WifiCertServiceResultOptions& aOptions) +{ + MOZ_ASSERT(NS_IsMainThread()); + + mozilla::AutoSafeJSContext cx; + JS::RootedValue val(cx); + nsCString dummyInterface; + + if (!ToJSValue(cx, aOptions, &val)) { + return; + } + + // Certll the listener with a JS value. + mListener->OnCommand(val, dummyInterface); +} + +WifiCertService::WifiCertService() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!gWifiCertService); +} + +WifiCertService::~WifiCertService() +{ + MOZ_ASSERT(!gWifiCertService); + + nsNSSShutDownPreventionLock locker; + if (isAlreadyShutDown()) { + return; + } + shutdown(ShutdownCalledFrom::Object); +} + +already_AddRefed<WifiCertService> +WifiCertService::FactoryCreate() +{ + if (!XRE_IsParentProcess()) { + return nullptr; + } + + MOZ_ASSERT(NS_IsMainThread()); + + if (!gWifiCertService) { + gWifiCertService = new WifiCertService(); + ClearOnShutdown(&gWifiCertService); + } + + RefPtr<WifiCertService> service = gWifiCertService.get(); + return service.forget(); +} + +NS_IMETHODIMP +WifiCertService::ImportCert(int32_t aId, nsIDOMBlob* aCertBlob, + const nsAString& aCertPassword, + const nsAString& aCertNickname) +{ + RefPtr<Blob> blob = static_cast<Blob*>(aCertBlob); + RefPtr<CryptoTask> task = new ImportCertTask(aId, blob, aCertPassword, + aCertNickname); + return task->Dispatch("WifiImportCert"); +} + +NS_IMETHODIMP +WifiCertService::DeleteCert(int32_t aId, const nsAString& aCertNickname) +{ + RefPtr<CryptoTask> task = new DeleteCertTask(aId, aCertNickname); + return task->Dispatch("WifiDeleteCert"); +} + +NS_IMETHODIMP +WifiCertService::HasPrivateKey(const nsAString& aCertNickname, bool *aHasKey) +{ + *aHasKey = false; + + nsNSSShutDownPreventionLock locker; + if (isAlreadyShutDown()) { + return NS_ERROR_NOT_AVAILABLE; + } + + nsCString certNickname; + CopyUTF16toUTF8(aCertNickname, certNickname); + + ScopedCERTCertificate cert( + CERT_FindCertByNickname(CERT_GetDefaultCertDB(), certNickname.get()) + ); + if (!cert) { + return NS_OK; + } + + ScopedPK11SlotInfo slot( + PK11_KeyForCertExists(cert, nullptr, nullptr) + ); + if (slot) { + *aHasKey = true; + } + + return NS_OK; +} + +NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(WifiCertService, + WifiCertService::FactoryCreate) + +NS_DEFINE_NAMED_CID(NS_WIFICERTSERVICE_CID); + +static const mozilla::Module::CIDEntry kWifiCertServiceCIDs[] = { + { &kNS_WIFICERTSERVICE_CID, false, nullptr, WifiCertServiceConstructor }, + { nullptr } +}; + +static const mozilla::Module::ContractIDEntry kWifiCertServiceContracts[] = { + { "@mozilla.org/wifi/certservice;1", &kNS_WIFICERTSERVICE_CID }, + { nullptr } +}; + +static const mozilla::Module kWifiCertServiceModule = { + mozilla::Module::kVersion, + kWifiCertServiceCIDs, + kWifiCertServiceContracts, + nullptr +}; + +} // namespace mozilla + +NSMODULE_DEFN(WifiCertServiceModule) = &kWifiCertServiceModule; diff --git a/dom/wifi/WifiCertService.h b/dom/wifi/WifiCertService.h new file mode 100644 index 000000000..f542bb0c8 --- /dev/null +++ b/dom/wifi/WifiCertService.h @@ -0,0 +1,40 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef WifiCertService_h +#define WifiCertService_h + +#include "nsIWifiCertService.h" +#include "nsCOMPtr.h" +#include "nsNSSShutDown.h" +#include "nsThread.h" +#include "mozilla/dom/WifiOptionsBinding.h" + +namespace mozilla { +namespace dom { + +class WifiCertService final : public nsIWifiCertService, + public nsNSSShutDownObject +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIWIFICERTSERVICE + + static already_AddRefed<WifiCertService> + FactoryCreate(); + void DispatchResult(const mozilla::dom::WifiCertServiceResultOptions& aOptions); + +private: + WifiCertService(); + ~WifiCertService(); + virtual void virtualDestroyNSSReference() {}; + nsCOMPtr<nsIWifiEventListener> mListener; +}; + +} // namespce dom +} // namespace mozilla + +#endif // WifiCertService_h diff --git a/dom/wifi/WifiCommand.jsm b/dom/wifi/WifiCommand.jsm new file mode 100644 index 000000000..93b0f1a1e --- /dev/null +++ b/dom/wifi/WifiCommand.jsm @@ -0,0 +1,594 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +this.EXPORTED_SYMBOLS = ["WifiCommand"]; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +Cu.import("resource://gre/modules/systemlibs.js"); + +const SUPP_PROP = "init.svc.wpa_supplicant"; +const WPA_SUPPLICANT = "wpa_supplicant"; +const DEBUG = false; + +this.WifiCommand = function(aControlMessage, aInterface, aSdkVersion) { + function debug(msg) { + if (DEBUG) { + dump('-------------- WifiCommand: ' + msg); + } + } + + var command = {}; + + //------------------------------------------------- + // Utilities. + //------------------------------------------------- + command.getSdkVersion = function() { + return aSdkVersion; + }; + + //------------------------------------------------- + // General commands. + //------------------------------------------------- + + command.loadDriver = function (callback) { + voidControlMessage("load_driver", function(status) { + callback(status); + }); + }; + + command.unloadDriver = function (callback) { + voidControlMessage("unload_driver", function(status) { + callback(status); + }); + }; + + command.startSupplicant = function (callback) { + voidControlMessage("start_supplicant", callback); + }; + + command.killSupplicant = function (callback) { + // It is interesting to note that this function does exactly what + // wifi_stop_supplicant does. Unforunately, on the Galaxy S2, Samsung + // changed that function in a way that means that it doesn't recognize + // wpa_supplicant as already running. Therefore, we have to roll our own + // version here. + stopProcess(SUPP_PROP, WPA_SUPPLICANT, callback); + }; + + command.terminateSupplicant = function (callback) { + doBooleanCommand("TERMINATE", "OK", callback); + }; + + command.stopSupplicant = function (callback) { + voidControlMessage("stop_supplicant", callback); + }; + + command.listNetworks = function (callback) { + doStringCommand("LIST_NETWORKS", callback); + }; + + command.addNetwork = function (callback) { + doIntCommand("ADD_NETWORK", callback); + }; + + command.setNetworkVariable = function (netId, name, value, callback) { + doBooleanCommand("SET_NETWORK " + netId + " " + name + " " + + value, "OK", callback); + }; + + command.getNetworkVariable = function (netId, name, callback) { + doStringCommand("GET_NETWORK " + netId + " " + name, callback); + }; + + command.removeNetwork = function (netId, callback) { + doBooleanCommand("REMOVE_NETWORK " + netId, "OK", callback); + }; + + command.enableNetwork = function (netId, disableOthers, callback) { + doBooleanCommand((disableOthers ? "SELECT_NETWORK " : "ENABLE_NETWORK ") + + netId, "OK", callback); + }; + + command.disableNetwork = function (netId, callback) { + doBooleanCommand("DISABLE_NETWORK " + netId, "OK", callback); + }; + + command.status = function (callback) { + doStringCommand("STATUS", callback); + }; + + command.ping = function (callback) { + doBooleanCommand("PING", "PONG", callback); + }; + + command.scanResults = function (callback) { + doStringCommand("SCAN_RESULTS", callback); + }; + + command.disconnect = function (callback) { + doBooleanCommand("DISCONNECT", "OK", callback); + }; + + command.reconnect = function (callback) { + doBooleanCommand("RECONNECT", "OK", callback); + }; + + command.reassociate = function (callback) { + doBooleanCommand("REASSOCIATE", "OK", callback); + }; + + command.setBackgroundScan = function (enable, callback) { + doBooleanCommand("SET pno " + (enable ? "1" : "0"), + "OK", + function(ok) { + callback(true, ok); + }); + }; + + command.doSetScanMode = function (setActive, callback) { + doBooleanCommand(setActive ? + "DRIVER SCAN-ACTIVE" : + "DRIVER SCAN-PASSIVE", "OK", callback); + }; + + command.scan = function (callback) { + doBooleanCommand("SCAN", "OK", callback); + }; + + command.setLogLevel = function (level, callback) { + doBooleanCommand("LOG_LEVEL " + level, "OK", callback); + }; + + command.getLogLevel = function (callback) { + doStringCommand("LOG_LEVEL", callback); + }; + + command.wpsPbc = function (callback, iface) { + let cmd = 'WPS_PBC'; + + // If the network interface is specified and we are based on JB, + // append the argument 'interface=[iface]' to the supplicant command. + // + // Note: The argument "interface" is only required for wifi p2p on JB. + // For other cases, the argument is useless and even leads error. + // Check the evil work here: + // http://androidxref.com/4.2.2_r1/xref/external/wpa_supplicant_8/wpa_supplicant/ctrl_iface_unix.c#172 + // + if (iface && isJellybean()) { + cmd += (' inferface=' + iface); + } + + doBooleanCommand(cmd, "OK", callback); + }; + + command.wpsPin = function (detail, callback) { + let cmd = 'WPS_PIN '; + + // See the comment above in wpsPbc(). + if (detail.iface && isJellybean()) { + cmd += ('inferface=' + iface + ' '); + } + + cmd += (detail.bssid === undefined ? "any" : detail.bssid); + cmd += (detail.pin === undefined ? "" : (" " + detail.pin)); + + doStringCommand(cmd, callback); + }; + + command.wpsCancel = function (callback) { + doBooleanCommand("WPS_CANCEL", "OK", callback); + }; + + command.startDriver = function (callback) { + doBooleanCommand("DRIVER START", "OK"); + }; + + command.stopDriver = function (callback) { + doBooleanCommand("DRIVER STOP", "OK"); + }; + + command.startPacketFiltering = function (callback) { + var commandChain = ["DRIVER RXFILTER-ADD 0", + "DRIVER RXFILTER-ADD 1", + "DRIVER RXFILTER-ADD 3", + "DRIVER RXFILTER-START"]; + + doBooleanCommandChain(commandChain, callback); + }; + + command.stopPacketFiltering = function (callback) { + var commandChain = ["DRIVER RXFILTER-STOP", + "DRIVER RXFILTER-REMOVE 3", + "DRIVER RXFILTER-REMOVE 1", + "DRIVER RXFILTER-REMOVE 0"]; + + doBooleanCommandChain(commandChain, callback); + }; + + command.doGetRssi = function (cmd, callback) { + doCommand(cmd, function(data) { + var rssi = -200; + + if (!data.status) { + // If we are associating, the reply is "OK". + var reply = data.reply; + if (reply !== "OK") { + // Format is: <SSID> rssi XX". SSID can contain spaces. + var offset = reply.lastIndexOf("rssi "); + if (offset !== -1) { + rssi = reply.substr(offset + 5) | 0; + } + } + } + callback(rssi); + }); + }; + + command.getRssi = function (callback) { + command.doGetRssi("DRIVER RSSI", callback); + }; + + command.getRssiApprox = function (callback) { + command.doGetRssi("DRIVER RSSI-APPROX", callback); + }; + + command.getLinkSpeed = function (callback) { + doStringCommand("DRIVER LINKSPEED", function(reply) { + if (reply) { + reply = reply.split(" ")[1] | 0; // Format: LinkSpeed XX + } + callback(reply); + }); + }; + + let infoKeys = [{regexp: /RSSI=/i, prop: 'rssi'}, + {regexp: /LINKSPEED=/i, prop: 'linkspeed'}]; + + command.getConnectionInfoICS = function (callback) { + doStringCommand("SIGNAL_POLL", function(reply) { + if (!reply) { + callback(null); + return; + } + + // Find any values matching |infoKeys|. This gets executed frequently + // enough that we want to avoid creating intermediate strings as much as + // possible. + let rval = {}; + for (let i = 0; i < infoKeys.length; i++) { + let re = infoKeys[i].regexp; + let iKeyStart = reply.search(re); + if (iKeyStart !== -1) { + let prop = infoKeys[i].prop; + let iValueStart = reply.indexOf('=', iKeyStart) + 1; + let iNewlineAfterValue = reply.indexOf('\n', iValueStart); + let iValueEnd = iNewlineAfterValue !== -1 + ? iNewlineAfterValue + : reply.length; + rval[prop] = reply.substring(iValueStart, iValueEnd) | 0; + } + } + + callback(rval); + }); + }; + + command.getMacAddress = function (callback) { + doStringCommand("DRIVER MACADDR", function(reply) { + if (reply) { + reply = reply.split(" ")[2]; // Format: Macaddr = XX.XX.XX.XX.XX.XX + } + callback(reply); + }); + }; + + command.connectToHostapd = function(callback) { + voidControlMessage("connect_to_hostapd", callback); + }; + + command.closeHostapdConnection = function(callback) { + voidControlMessage("close_hostapd_connection", callback); + }; + + command.hostapdCommand = function (callback, request) { + var msg = { cmd: "hostapd_command", + request: request, + iface: aInterface }; + + aControlMessage(msg, function(data) { + callback(data.status ? null : data.reply); + }); + }; + + command.hostapdGetStations = function (callback) { + var msg = { cmd: "hostapd_get_stations", + iface: aInterface }; + + aControlMessage(msg, function(data) { + callback(data.status); + }); + }; + + command.setPowerModeICS = function (mode, callback) { + doBooleanCommand("DRIVER POWERMODE " + (mode === "AUTO" ? 0 : 1), "OK", callback); + }; + + command.setPowerModeJB = function (mode, callback) { + doBooleanCommand("SET ps " + (mode === "AUTO" ? 1 : 0), "OK", callback); + }; + + command.getPowerMode = function (callback) { + doStringCommand("DRIVER GETPOWER", function(reply) { + if (reply) { + reply = (reply.split()[2]|0); // Format: powermode = XX + } + callback(reply); + }); + }; + + command.setNumAllowedChannels = function (numChannels, callback) { + doBooleanCommand("DRIVER SCAN-CHANNELS " + numChannels, "OK", callback); + }; + + command.getNumAllowedChannels = function (callback) { + doStringCommand("DRIVER SCAN-CHANNELS", function(reply) { + if (reply) { + reply = (reply.split()[2]|0); // Format: Scan-Channels = X + } + callback(reply); + }); + }; + + command.setBluetoothCoexistenceMode = function (mode, callback) { + doBooleanCommand("DRIVER BTCOEXMODE " + mode, "OK", callback); + }; + + command.setBluetoothCoexistenceScanMode = function (mode, callback) { + doBooleanCommand("DRIVER BTCOEXSCAN-" + (mode ? "START" : "STOP"), + "OK", callback); + }; + + command.saveConfig = function (callback) { + // Make sure we never write out a value for AP_SCAN other than 1. + doBooleanCommand("AP_SCAN 1", "OK", function(ok) { + doBooleanCommand("SAVE_CONFIG", "OK", callback); + }); + }; + + command.reloadConfig = function (callback) { + doBooleanCommand("RECONFIGURE", "OK", callback); + }; + + command.setScanResultHandling = function (mode, callback) { + doBooleanCommand("AP_SCAN " + mode, "OK", callback); + }; + + command.addToBlacklist = function (bssid, callback) { + doBooleanCommand("BLACKLIST " + bssid, "OK", callback); + }; + + command.clearBlacklist = function (callback) { + doBooleanCommand("BLACKLIST clear", "OK", callback); + }; + + command.setSuspendOptimizationsICS = function (enabled, callback) { + doBooleanCommand("DRIVER SETSUSPENDOPT " + (enabled ? 0 : 1), + "OK", callback); + }; + + command.setSuspendOptimizationsJB = function (enabled, callback) { + doBooleanCommand("DRIVER SETSUSPENDMODE " + (enabled ? 1 : 0), + "OK", callback); + }; + + command.connectToSupplicant = function(callback) { + voidControlMessage("connect_to_supplicant", callback); + }; + + command.closeSupplicantConnection = function(callback) { + voidControlMessage("close_supplicant_connection", callback); + }; + + command.getMacAddress = function(callback) { + doStringCommand("DRIVER MACADDR", function(reply) { + if (reply) { + reply = reply.split(" ")[2]; // Format: Macaddr = XX.XX.XX.XX.XX.XX + } + callback(reply); + }); + }; + + command.setDeviceName = function(deviceName, callback) { + doBooleanCommand("SET device_name " + deviceName, "OK", callback); + }; + + //------------------------------------------------- + // P2P commands. + //------------------------------------------------- + + command.p2pProvDiscovery = function(address, wpsMethod, callback) { + var command = "P2P_PROV_DISC " + address + " " + wpsMethod; + doBooleanCommand(command, "OK", callback); + }; + + command.p2pConnect = function(config, callback) { + var command = "P2P_CONNECT " + config.address + " " + config.wpsMethodWithPin + " "; + if (config.joinExistingGroup) { + command += "join"; + } else { + command += "go_intent=" + config.goIntent; + } + + debug('P2P connect command: ' + command); + doBooleanCommand(command, "OK", callback); + }; + + command.p2pGroupRemove = function(iface, callback) { + debug("groupRemove()"); + doBooleanCommand("P2P_GROUP_REMOVE " + iface, "OK", callback); + }; + + command.p2pEnable = function(detail, callback) { + var commandChain = ["SET device_name " + detail.deviceName, + "SET device_type " + detail.deviceType, + "SET config_methods " + detail.wpsMethods, + "P2P_SET conc_pref sta", + "P2P_FLUSH"]; + + doBooleanCommandChain(commandChain, callback); + }; + + command.p2pDisable = function(callback) { + doBooleanCommand("P2P_SET disabled 1", "OK", callback); + }; + + command.p2pEnableScan = function(timeout, callback) { + doBooleanCommand("P2P_FIND " + timeout, "OK", callback); + }; + + command.p2pDisableScan = function(callback) { + doBooleanCommand("P2P_STOP_FIND", "OK", callback); + }; + + command.p2pGetGroupCapab = function(address, callback) { + command.p2pPeer(address, function(reply) { + debug('p2p_peer reply: ' + reply); + if (!reply) { + callback(0); + return; + } + var capab = /group_capab=0x([0-9a-fA-F]+)/.exec(reply)[1]; + if (!capab) { + callback(0); + } else { + callback(parseInt(capab, 16)); + } + }); + }; + + command.p2pPeer = function(address, callback) { + doStringCommand("P2P_PEER " + address, callback); + }; + + command.p2pGroupAdd = function(netId, callback) { + doBooleanCommand("P2P_GROUP_ADD persistent=" + netId, callback); + }; + + command.p2pReinvoke = function(netId, address, callback) { + doBooleanCommand("P2P_INVITE persistent=" + netId + " peer=" + address, "OK", callback); + }; + + //---------------------------------------------------------- + // Private stuff. + //---------------------------------------------------------- + + function voidControlMessage(cmd, callback) { + aControlMessage({ cmd: cmd, iface: aInterface }, function (data) { + callback(data.status); + }); + } + + function doCommand(request, callback) { + var msg = { cmd: "command", + request: request, + iface: aInterface }; + + aControlMessage(msg, callback); + } + + function doIntCommand(request, callback) { + doCommand(request, function(data) { + callback(data.status ? -1 : (data.reply|0)); + }); + } + + function doBooleanCommand(request, expected, callback) { + doCommand(request, function(data) { + callback(data.status ? false : (data.reply === expected)); + }); + } + + function doStringCommand(request, callback) { + doCommand(request, function(data) { + callback(data.status ? null : data.reply); + }); + } + + function doBooleanCommandChain(commandChain, callback, i) { + if (undefined === i) { + i = 0; + } + + doBooleanCommand(commandChain[i], "OK", function(ok) { + if (!ok) { + return callback(false); + } + i++; + if (i === commandChain.length || !commandChain[i]) { + // Reach the end or empty command. + return callback(true); + } + doBooleanCommandChain(commandChain, callback, i); + }); + } + + //-------------------------------------------------- + // Helper functions. + //-------------------------------------------------- + + function stopProcess(service, process, callback) { + var count = 0; + var timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + function tick() { + let result = libcutils.property_get(service); + if (result === null) { + callback(); + return; + } + if (result === "stopped" || ++count >= 5) { + // Either we succeeded or ran out of time. + timer = null; + callback(); + return; + } + + // Else it's still running, continue waiting. + timer.initWithCallback(tick, 1000, Ci.nsITimer.TYPE_ONE_SHOT); + } + + setProperty("ctl.stop", process, tick); + } + + // Wrapper around libcutils.property_set that returns true if setting the + // value was successful. + // Note that the callback is not called asynchronously. + function setProperty(key, value, callback) { + let ok = true; + try { + libcutils.property_set(key, value); + } catch(e) { + ok = false; + } + callback(ok); + } + + function isJellybean() { + // According to http://developer.android.com/guide/topics/manifest/uses-sdk-element.html + // ---------------------------------------------------- + // | Platform Version | API Level | VERSION_CODE | + // ---------------------------------------------------- + // | Android 4.1, 4.1.1 | 16 | JELLY_BEAN_MR2 | + // | Android 4.2, 4.2.2 | 17 | JELLY_BEAN_MR1 | + // | Android 4.3 | 18 | JELLY_BEAN | + // ---------------------------------------------------- + return aSdkVersion === 16 || aSdkVersion === 17 || aSdkVersion === 18; + } + + return command; +}; diff --git a/dom/wifi/WifiHotspotUtils.cpp b/dom/wifi/WifiHotspotUtils.cpp new file mode 100644 index 000000000..5fdb9b76e --- /dev/null +++ b/dom/wifi/WifiHotspotUtils.cpp @@ -0,0 +1,188 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#include "WifiHotspotUtils.h" +#include <dlfcn.h> +#include <errno.h> +#include <string.h> +#include <dirent.h> +#include <stdlib.h> +#include <cutils/properties.h> + +#include "prinit.h" +#include "mozilla/Assertions.h" +#include "mozilla/Sprintf.h" +#include "nsDebug.h" +#include "nsPrintfCString.h" + +static void* sWifiHotspotUtilsLib; +static PRCallOnceType sInitWifiHotspotUtilsLib; +// Socket pair used to exit from a blocking read. +static struct wpa_ctrl* ctrl_conn; +static const char *ctrl_iface_dir = "/data/misc/wifi/hostapd"; +static char *ctrl_ifname = nullptr; + +DEFINE_DLFUNC(wpa_ctrl_open, struct wpa_ctrl*, const char*) +DEFINE_DLFUNC(wpa_ctrl_close, void, struct wpa_ctrl*) +DEFINE_DLFUNC(wpa_ctrl_attach, int32_t, struct wpa_ctrl*) +DEFINE_DLFUNC(wpa_ctrl_detach, int32_t, struct wpa_ctrl*) +DEFINE_DLFUNC(wpa_ctrl_request, int32_t, struct wpa_ctrl*, + const char*, size_t cmd_len, char *reply, + size_t *reply_len, void (*msg_cb)(char *msg, size_t len)) + + +static PRStatus +InitWifiHotspotUtilsLib() +{ + sWifiHotspotUtilsLib = dlopen("/system/lib/libwpa_client.so", RTLD_LAZY); + // We might fail to open the hardware lib. That's OK. + return PR_SUCCESS; +} + +static void* +GetWifiHotspotLibHandle() +{ + PR_CallOnce(&sInitWifiHotspotUtilsLib, InitWifiHotspotUtilsLib); + return sWifiHotspotUtilsLib; +} + +struct wpa_ctrl * +WifiHotspotUtils::openConnection(const char *ifname) +{ + if (!ifname) { + return nullptr; + } + + USE_DLFUNC(wpa_ctrl_open) + ctrl_conn = wpa_ctrl_open(nsPrintfCString("%s/%s", ctrl_iface_dir, ifname).get()); + return ctrl_conn; +} + +int32_t +WifiHotspotUtils::sendCommand(struct wpa_ctrl *ctrl, const char *cmd, + char *reply, size_t *reply_len) +{ + int32_t ret; + + if (!ctrl_conn) { + NS_WARNING(nsPrintfCString("Not connected to hostapd - \"%s\" command dropped.\n", cmd).get()); + return -1; + } + + USE_DLFUNC(wpa_ctrl_request) + ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), reply, reply_len, nullptr); + if (ret == -2) { + NS_WARNING(nsPrintfCString("'%s' command timed out.\n", cmd).get()); + return -2; + } else if (ret < 0 || strncmp(reply, "FAIL", 4) == 0) { + return -1; + } + + // Make the reply printable. + reply[*reply_len] = '\0'; + if (strncmp(cmd, "STA-FIRST", 9) == 0 || + strncmp(cmd, "STA-NEXT", 8) == 0) { + char *pos = reply; + + while (*pos && *pos != '\n') + pos++; + *pos = '\0'; + } + + return 0; +} + + +// static +void* +WifiHotspotUtils::GetSharedLibrary() +{ + void* wpaClientLib = GetWifiHotspotLibHandle(); + if (!wpaClientLib) { + NS_WARNING("No /system/lib/libwpa_client.so"); + } + return wpaClientLib; +} + +int32_t WifiHotspotUtils::do_wifi_connect_to_hostapd() +{ + struct dirent *dent; + + DIR *dir = opendir(ctrl_iface_dir); + if (dir) { + while ((dent = readdir(dir))) { + if (strcmp(dent->d_name, ".") == 0 || + strcmp(dent->d_name, "..") == 0) { + continue; + } + ctrl_ifname = strdup(dent->d_name); + break; + } + closedir(dir); + } + + ctrl_conn = openConnection(ctrl_ifname); + if (!ctrl_conn) { + NS_WARNING(nsPrintfCString("Unable to open connection to hostapd on \"%s\": %s", + ctrl_ifname, strerror(errno)).get()); + return -1; + } + + USE_DLFUNC(wpa_ctrl_attach) + if (wpa_ctrl_attach(ctrl_conn) != 0) { + USE_DLFUNC(wpa_ctrl_close) + wpa_ctrl_close(ctrl_conn); + ctrl_conn = nullptr; + return -1; + } + + return 0; +} + +int32_t WifiHotspotUtils::do_wifi_close_hostapd_connection() +{ + if (!ctrl_conn) { + NS_WARNING("Invalid ctrl_conn."); + return -1; + } + + USE_DLFUNC(wpa_ctrl_detach) + if (wpa_ctrl_detach(ctrl_conn) < 0) { + NS_WARNING("Failed to detach wpa_ctrl."); + } + + USE_DLFUNC(wpa_ctrl_close) + wpa_ctrl_close(ctrl_conn); + ctrl_conn = nullptr; + return 0; +} + +int32_t WifiHotspotUtils::do_wifi_hostapd_command(const char *command, + char *reply, + size_t *reply_len) +{ + return sendCommand(ctrl_conn, command, reply, reply_len); +} + +int32_t WifiHotspotUtils::do_wifi_hostapd_get_stations() +{ + char addr[32], cmd[64]; + int stations = 0; + size_t addrLen = sizeof(addr); + + if (sendCommand(ctrl_conn, "STA-FIRST", addr, &addrLen)) { + return 0; + } + stations++; + + SprintfLiteral(cmd, "STA-NEXT %s", addr); + while (sendCommand(ctrl_conn, cmd, addr, &addrLen) == 0) { + stations++; + SprintfLiteral(cmd, "STA-NEXT %s", addr); + } + + return stations; +} diff --git a/dom/wifi/WifiHotspotUtils.h b/dom/wifi/WifiHotspotUtils.h new file mode 100644 index 000000000..7afdec7da --- /dev/null +++ b/dom/wifi/WifiHotspotUtils.h @@ -0,0 +1,46 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +/** + * Abstraction on top of the network support from libnetutils that we + * use to set up network connections. + */ + +#ifndef WifiHotspotUtils_h +#define WifiHotspotUtils_h + +// Forward declaration. +struct wpa_ctrl; + +class WifiHotspotUtils +{ +public: + static void* GetSharedLibrary(); + + int32_t do_wifi_connect_to_hostapd(); + int32_t do_wifi_close_hostapd_connection(); + int32_t do_wifi_hostapd_command(const char *command, + char *reply, + size_t *reply_len); + int32_t do_wifi_hostapd_get_stations(); + +private: + struct wpa_ctrl * openConnection(const char *ifname); + int32_t sendCommand(struct wpa_ctrl *ctrl, const char *cmd, + char *reply, size_t *reply_len); +}; + +// Defines a function type with the right arguments and return type. +#define DEFINE_DLFUNC(name, ret, args...) typedef ret (*FUNC##name)(args); + +// Set up a dlsymed function ready to use. +#define USE_DLFUNC(name) \ + FUNC##name name = (FUNC##name) dlsym(GetSharedLibrary(), #name); \ + if (!name) { \ + MOZ_CRASH("Symbol not found in shared library : " #name); \ + } + +#endif // WifiHotspotUtils_h diff --git a/dom/wifi/WifiNetUtil.jsm b/dom/wifi/WifiNetUtil.jsm new file mode 100644 index 000000000..2a1866515 --- /dev/null +++ b/dom/wifi/WifiNetUtil.jsm @@ -0,0 +1,154 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/systemlibs.js"); + +XPCOMUtils.defineLazyServiceGetter(this, "gNetworkService", + "@mozilla.org/network/service;1", + "nsINetworkService"); + +this.EXPORTED_SYMBOLS = ["WifiNetUtil"]; + +const DHCP_PROP = "init.svc.dhcpcd"; +const DHCP = "dhcpcd"; +const DEBUG = false; + +this.WifiNetUtil = function(controlMessage) { + function debug(msg) { + if (DEBUG) { + dump('-------------- NetUtil: ' + msg); + } + } + + var util = {}; + + util.runDhcp = function (ifname, gen, callback) { + util.stopDhcp(ifname, function() { + gNetworkService.dhcpRequest(ifname, function(success, dhcpInfo) { + util.runIpConfig(ifname, dhcpInfo, function(data) { + callback(data, gen); + }); + }); + }); + }; + + util.stopDhcp = function (ifname, callback) { + // This function does exactly what dhcp_stop does. Unforunately, if we call + // this function twice before the previous callback is returned. We may block + // our self waiting for the callback. It slows down the wifi startup procedure. + // Therefore, we have to roll our own version here. + let dhcpService = DHCP_PROP + "_" + ifname; + let suffix = (ifname.substr(0, 3) === "p2p") ? "p2p" : ifname; + let processName = DHCP + "_" + suffix; + + // The implementation of |dhcp_do_request| would wait until the + // |result_prop_name| (e.g. dhcp.wlan0.result) to be non-null + // or 30 second timeout. So we manually change the result property + // to 'ko' to avoid timeout. + // + // http://androidxref.com/4.4.4_r1/xref/system/core/libnetutils/dhcp_utils.c#234 + setProperty('dhcp.' + suffix + '.result', 'ko', function() { + stopProcess(dhcpService, processName, callback); + }); + }; + + util.startDhcpServer = function (config, callback) { + gNetworkService.setDhcpServer(true, config, function (error) { + callback(!error); + }); + }; + + util.stopDhcpServer = function (callback) { + gNetworkService.setDhcpServer(false, null, function (error) { + callback(!error); + }); + }; + + util.runIpConfig = function (name, data, callback) { + if (!data) { + debug("IP config failed to run"); + callback({ info: data }); + return; + } + + setProperty("net." + name + ".dns1", ipToString(data.dns1), + function(ok) { + if (!ok) { + debug("Unable to set net.<ifname>.dns1"); + return; + } + setProperty("net." + name + ".dns2", ipToString(data.dns2), + function(ok) { + if (!ok) { + debug("Unable to set net.<ifname>.dns2"); + return; + } + setProperty("net." + name + ".gw", ipToString(data.gateway), + function(ok) { + if (!ok) { + debug("Unable to set net.<ifname>.gw"); + return; + } + callback({ info: data }); + }); + }); + }); + }; + + //-------------------------------------------------- + // Helper functions. + //-------------------------------------------------- + + function stopProcess(service, process, callback) { + var count = 0; + var timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + function tick() { + let result = libcutils.property_get(service); + if (result === null) { + callback(); + return; + } + if (result === "stopped" || ++count >= 5) { + // Either we succeeded or ran out of time. + timer = null; + callback(); + return; + } + + // Else it's still running, continue waiting. + timer.initWithCallback(tick, 1000, Ci.nsITimer.TYPE_ONE_SHOT); + } + + setProperty("ctl.stop", process, tick); + } + + // Wrapper around libcutils.property_set that returns true if setting the + // value was successful. + // Note that the callback is not called asynchronously. + function setProperty(key, value, callback) { + let ok = true; + try { + libcutils.property_set(key, value); + } catch(e) { + ok = false; + } + callback(ok); + } + + function ipToString(n) { + return String((n >> 0) & 0xFF) + "." + + ((n >> 8) & 0xFF) + "." + + ((n >> 16) & 0xFF) + "." + + ((n >> 24) & 0xFF); + } + + return util; +}; diff --git a/dom/wifi/WifiP2pManager.jsm b/dom/wifi/WifiP2pManager.jsm new file mode 100644 index 000000000..c1b687438 --- /dev/null +++ b/dom/wifi/WifiP2pManager.jsm @@ -0,0 +1,1649 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/StateMachine.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/systemlibs.js"); + +XPCOMUtils.defineLazyServiceGetter(this, "gSysMsgr", + "@mozilla.org/system-message-internal;1", + "nsISystemMessagesInternal"); + +XPCOMUtils.defineLazyServiceGetter(this, "gNetworkManager", + "@mozilla.org/network/manager;1", + "nsINetworkManager"); + +XPCOMUtils.defineLazyServiceGetter(this, "gNetworkService", + "@mozilla.org/network/service;1", + "nsINetworkService"); + +this.EXPORTED_SYMBOLS = ["WifiP2pManager"]; + +const EVENT_IGNORED = -1; +const EVENT_UNKNOWN = -2; + +// Events from supplicant for p2p. +const EVENT_P2P_DEVICE_FOUND = 0; +const EVENT_P2P_DEVICE_LOST = 1; +const EVENT_P2P_GROUP_STARTED = 2; +const EVENT_P2P_GROUP_REMOVED = 3; +const EVENT_P2P_PROV_DISC_PBC_REQ = 4; +const EVENT_P2P_PROV_DISC_PBC_RESP = 5; +const EVENT_P2P_PROV_DISC_SHOW_PIN = 6; +const EVENT_P2P_PROV_DISC_ENTER_PIN = 7; +const EVENT_P2P_GO_NEG_REQUEST = 8; +const EVENT_P2P_GO_NEG_SUCCESS = 9; +const EVENT_P2P_GO_NEG_FAILURE = 10; +const EVENT_P2P_GROUP_FORMATION_SUCCESS = 11; +const EVENT_P2P_GROUP_FORMATION_FAILURE = 12; +const EVENT_P2P_FIND_STOPPED = 13; +const EVENT_P2P_INVITATION_RESULT = 14; +const EVENT_P2P_INVITATION_RECEIVED = 15; +const EVENT_P2P_PROV_DISC_FAILURE = 16; + +// Events from supplicant but not p2p specific. +const EVENT_AP_STA_DISCONNECTED = 100; +const EVENT_AP_STA_CONNECTED = 101; + +// Events from DOM. +const EVENT_P2P_SET_PAIRING_CONFIRMATION = 1000; +const EVENT_P2P_CMD_CONNECT = 1001; +const EVENT_P2P_CMD_DISCONNECT = 1002; +const EVENT_P2P_CMD_ENABLE = 1003; +const EVENT_P2P_CMD_DISABLE = 1004; +const EVENT_P2P_CMD_ENABLE_SCAN = 1005; +const EVENT_P2P_CMD_DISABLE_SCAN = 1006; +const EVENT_P2P_CMD_BLOCK_SCAN = 1007; +const EVENT_P2P_CMD_UNBLOCK_SCAN = 1008; + +// Internal events. +const EVENT_TIMEOUT_PAIRING_CONFIRMATION = 10000; +const EVENT_TIMEOUT_NEG_REQ = 10001; +const EVENT_TIMEOUT_CONNECTING = 10002; +const EVENT_P2P_ENABLE_SUCCESS = 10003; +const EVENT_P2P_ENABLE_FAILED = 10004; +const EVENT_P2P_DISABLE_SUCCESS = 10005; + +// WPS method string. +const WPS_METHOD_PBC = "pbc"; +const WPS_METHOD_DISPLAY = "display"; +const WPS_METHOD_KEYPAD = "keypad"; + +// Role string. +const P2P_ROLE_GO = "GO"; +const P2P_ROLE_CLIENT = "client"; + +// System message for pairing request. +const PAIRING_REQUEST_SYS_MSG = "wifip2p-pairing-request"; + +// Configuration. +const P2P_INTERFACE_NAME = "p2p0"; +const DEFAULT_GO_INTENT = 15; +const DEFAULT_P2P_DEVICE_NAME = "FirefoxPhone"; +const P2P_SCAN_TIMEOUT_SEC = 120; +const DEFAULT_P2P_WPS_METHODS = "virtual_push_button physical_display keypad"; // For wpa_supplicant. +const DEFAULT_P2P_DEVICE_TYPE = "10-0050F204-5"; // For wpa_supplicant. + +const GO_NETWORK_INTERFACE = { + ip: "192.168.2.1", + maskLength: 24, + gateway: "192.168.2.1", + dns1: "0.0.0.0", + dns2: "0.0.0.0", + dhcpServer: "192.168.2.1" +}; + +const GO_DHCP_SERVER_IP_RANGE = { + startIp: "192.168.2.10", + endIp: "192.168.2.30" +}; + +var gDebug = false; + +// Device Capability bitmap +const DEVICE_CAPAB_SERVICE_DISCOVERY = 1; +const DEVICE_CAPAB_CLIENT_DISCOVERABILITY = 1<<1; +const DEVICE_CAPAB_CONCURRENT_OPER = 1<<2; +const DEVICE_CAPAB_INFRA_MANAGED = 1<<3; +const DEVICE_CAPAB_DEVICE_LIMIT = 1<<4; +const DEVICE_CAPAB_INVITATION_PROCEDURE = 1<<5; + +// Group Capability bitmap +const GROUP_CAPAB_GROUP_OWNER = 1; +const GROUP_CAPAB_PERSISTENT_GROUP = 1<<1; +const GROUP_CAPAB_GROUP_LIMIT = 1<<2; +const GROUP_CAPAB_INTRA_BSS_DIST = 1<<3; +const GROUP_CAPAB_CROSS_CONN = 1<<4; +const GROUP_CAPAB_PERSISTENT_RECONN = 1<<5; +const GROUP_CAPAB_GROUP_FORMATION = 1<<6; + +// Constants defined in wpa_supplicants. +const DEV_PW_REGISTRAR_SPECIFIED = 5; +const DEV_PW_USER_SPECIFIED = 1; +const DEV_PW_PUSHBUTTON = 4; + +this.WifiP2pManager = function (aP2pCommand, aNetUtil) { + function debug(aMsg) { + if (gDebug) { + dump('-------------- WifiP2pManager: ' + aMsg); + } + } + + let manager = {}; + + let _stateMachine = P2pStateMachine(aP2pCommand, aNetUtil); + + // Set debug flag to true or false. + // + // @param aDebug Boolean to indicate enabling or disabling the debug flag. + manager.setDebug = function(aDebug) { + gDebug = aDebug; + }; + + // Set observer of observing internal state machine events. + // + // @param aObserver Used to notify WifiWorker what's happening + // in the internal p2p state machine. + manager.setObserver = function(aObserver) { + _stateMachine.setObserver(aObserver); + }; + + // Handle wpa_supplicant events. + // + // @param aEventString string from wpa_supplicant. + manager.handleEvent = function(aEventString) { + let event = parseEventString(aEventString); + if (EVENT_UNKNOWN === event.id || EVENT_IGNORED === event.id) { + debug('Unknow or ignored event: ' + aEventString); + return false; + } + return _stateMachine.sendEvent(event); + }; + + // Set the confirmation of pairing request. + // + // @param aResult Object of confirmation result which contains: + // .accepted: user granted. + // .pin: pin code which is displaying or input by user. + // .wpsMethod: string of "pbc" or "display" or "keypad". + manager.setPairingConfirmation = function(aResult) { + let event = { + id: EVENT_P2P_SET_PAIRING_CONFIRMATION, + info: { + accepted: aResult.accepted, + pin: aResult.pin + } + }; + _stateMachine.sendEvent(event); + }; + + // Connect to a known peer. + // + // @param aAddress MAC address of the peer to connect. + // @param aWpsMethod String of "pbc" or "display" or "keypad". + // @param aGoIntent Number from 0 to 15. + // @param aCallback Callback |true| on attempting to connect. + // |false| on failed to connect. + manager.connect = function(aAddress, aWpsMethod, aGoIntent, aCallback) { + let event = { + id: EVENT_P2P_CMD_CONNECT, + info: { + wpsMethod: aWpsMethod, + address: aAddress, + goIntent: aGoIntent, + onDoConnect: aCallback + } + }; + _stateMachine.sendEvent(event); + }; + + // Disconnect with a known peer. + // + // @param aAddress The address the user desires to disconect. + // @param aCallback Callback |true| on "attempting" to disconnect. + // |false| on failed to disconnect. + manager.disconnect = function(aAddress, aCallback) { + let event = { + id: EVENT_P2P_CMD_DISCONNECT, + info: { + address: aAddress, + onDoDisconnect: aCallback + } + }; + _stateMachine.sendEvent(event); + }; + + // Enable/disable wifi p2p. + // + // @param aEnabled |true| to enable, |false| to disable. + // @param aCallbacks object for callbacks: + // .onEnabled + // .onDisabled + // .onSupplicantConnected + manager.setEnabled = function(aEnabled, aCallbacks) { + let event = { + id: (aEnabled ? EVENT_P2P_CMD_ENABLE : EVENT_P2P_CMD_DISABLE), + info: { + onEnabled: aCallbacks.onEnabled, + onDisabled: aCallbacks.onDisabled, + onSupplicantConnected: aCallbacks.onSupplicantConnected + } + }; + _stateMachine.sendEvent(event); + }; + + // Enable/disable the wifi p2p scan. + // + // @param aEnabled |true| to enable scan, |false| to disable scan. + // @param aCallback Callback |true| on success to enable/disable scan. + // |false| on failed to enable/disable scan. + manager.setScanEnabled = function(aEnabled, aCallback) { + let event = { + id: (aEnabled ? EVENT_P2P_CMD_ENABLE_SCAN : EVENT_P2P_CMD_DISABLE_SCAN), + info: { callback: aCallback } + }; + _stateMachine.sendEvent(event); + }; + + // Block wifi p2p scan. + manager.blockScan = function() { + _stateMachine.sendEvent({ id: EVENT_P2P_CMD_BLOCK_SCAN }); + }; + + // Un-block and do the pending scan if any. + manager.unblockScan = function() { + _stateMachine.sendEvent({ id: EVENT_P2P_CMD_UNBLOCK_SCAN }); + }; + + // Set the p2p device name. + manager.setDeviceName = function(newDeivceName, callback) { + aP2pCommand.setDeviceName(newDeivceName, callback); + }; + + // Parse wps_supplicant event string. + // + // @param aEventString The raw event string from wpa_supplicant. + // + // @return Object: + // .id: a number to represent an event. + // .info: the additional information carried by this event string. + function parseEventString(aEventString) { + if (isIgnoredEvent(aEventString)) { + return { id: EVENT_IGNORED }; + } + + let match = RegExp("p2p_dev_addr=([0-9a-fA-F:]+) " + + "pri_dev_type=([0-9a-zA-Z-]+) " + + "name='(.*)' " + + "config_methods=0x([0-9a-fA-F]+) " + + "dev_capab=0x([0-9a-fA-F]+) " + + "group_capab=0x([0-9a-fA-F]+) ").exec(aEventString + ' '); + + let tokens = aEventString.split(" "); + + let id = EVENT_UNKNOWN; + + // general info. + let info = {}; + + if (match) { + info = { + address: match[1] ? match[1] : null, + type: match[2] ? match[2] : null, + name: match[3] ? match[3] : null, + wpsFlag: match[4] ? parseInt(match[4], 16) : null, + devFlag: match[5] ? parseInt(match[5], 16) : null, + groupFlag: match[6] ? parseInt(match[6], 16) : null + }; + } + + if (0 === aEventString.indexOf("P2P-DEVICE-FOUND")) { + id = EVENT_P2P_DEVICE_FOUND; + info.wpsCapabilities = wpsFlagToCapabilities(info.wpsFlag); + info.isGroupOwner = isPeerGroupOwner(info.groupFlag); + } else if (0 === aEventString.indexOf("P2P-DEVICE-LOST")) { + // e.g. "P2P-DEVICE-LOST p2p_dev_addr=5e:0a:5b:15:1f:80". + id = EVENT_P2P_DEVICE_LOST; + info.address = /p2p_dev_addr=([0-9a-f:]+)/.exec(aEventString)[1]; + } else if (0 === aEventString.indexOf("P2P-GROUP-STARTED")) { + // e.g. "P2P-GROUP-STARTED wlan0-p2p-0 GO ssid="DIRECT-3F Testing + // passphrase="12345678" go_dev_addr=02:40:61:c2:f3:b7 [PERSISTENT]". + + id = EVENT_P2P_GROUP_STARTED; + let groupMatch = RegExp('ssid="(.*)" ' + + 'freq=([0-9]*) ' + + '(passphrase|psk)=([^ ]+) ' + + 'go_dev_addr=([0-9a-f:]+)').exec(aEventString); + info.ssid = groupMatch[1]; + info.freq = groupMatch[2]; + if ('passphrase' === groupMatch[3]) { + let s = groupMatch[4]; // e.g. "G7jHkkz9". + info.passphrase = s.substring(1, s.length-1); // Trim the double quote. + } else { // psk + info.psk = groupMatch[4]; + } + info.goAddress = groupMatch[5]; + info.ifname = tokens[1]; + info.role = tokens[2]; + } else if (0 === aEventString.indexOf("P2P-GROUP-REMOVED")) { + id = EVENT_P2P_GROUP_REMOVED; + // e.g. "P2P-GROUP-REMOVED wlan0-p2p-0 GO". + info.ifname = tokens[1]; + info.role = tokens[2]; + } else if (0 === aEventString.indexOf("P2P-PROV-DISC-PBC-REQ")) { + id = EVENT_P2P_PROV_DISC_PBC_REQ; + info.wpsMethod = WPS_METHOD_PBC; + } else if (0 === aEventString.indexOf("P2P-PROV-DISC-PBC-RESP")) { + id = EVENT_P2P_PROV_DISC_PBC_RESP; + // The address is different from the general pattern. + info.address = aEventString.split(" ")[1]; + info.wpsMethod = WPS_METHOD_PBC; + } else if (0 === aEventString.indexOf("P2P-PROV-DISC-SHOW-PIN")) { + id = EVENT_P2P_PROV_DISC_SHOW_PIN; + // Obtain peer address and pin from tokens. + info.address = tokens[1]; + info.pin = tokens[2]; + info.wpsMethod = WPS_METHOD_DISPLAY; + } else if (0 === aEventString.indexOf("P2P-PROV-DISC-ENTER-PIN")) { + id = EVENT_P2P_PROV_DISC_ENTER_PIN; + // Obtain peer address from tokens. + info.address = tokens[1]; + info.wpsMethod = WPS_METHOD_KEYPAD; + } else if (0 === aEventString.indexOf("P2P-GO-NEG-REQUEST")) { + id = EVENT_P2P_GO_NEG_REQUEST; + info.address = tokens[1]; + switch (parseInt(tokens[2].split("=")[1], 10)) { + case DEV_PW_REGISTRAR_SPECIFIED: // (5) Peer is display. + info.wpsMethod = WPS_METHOD_KEYPAD; + break; + case DEV_PW_USER_SPECIFIED: // (1) Peer is keypad. + info.wpsMethod = WPS_METHOD_DISPLAY; + break; + case DEV_PW_PUSHBUTTON: // (4) Peer is pbc. + info.wpsMethod = WPS_METHOD_PBC; + break; + default: + debug('Unknown wps method from event P2P-GO-NEG-REQUEST'); + break; + } + } else if (0 === aEventString.indexOf("P2P-GO-NEG-SUCCESS")) { + id = EVENT_P2P_GO_NEG_SUCCESS; + } else if (0 === aEventString.indexOf("P2P-GO-NEG-FAILURE")) { + id = EVENT_P2P_GO_NEG_FAILURE; + } else if (0 === aEventString.indexOf("P2P-GROUP-FORMATION-FAILURE")) { + id = EVENT_P2P_GROUP_FORMATION_FAILURE; + } else if (0 === aEventString.indexOf("P2P-GROUP-FORMATION-SUCCESS")) { + id = EVENT_P2P_GROUP_FORMATION_SUCCESS; + } else if (0 === aEventString.indexOf("P2P-FIND-STOPPED")) { + id = EVENT_P2P_FIND_STOPPED; + } else if (0 === aEventString.indexOf("P2P-INVITATION-RESULT")) { + id = EVENT_P2P_INVITATION_RESULT; + info.status = /status=([0-9]+)/.exec(aEventString)[1]; + } else if (0 === aEventString.indexOf("P2P-INVITATION-RECEIVED")) { + // e.g. "P2P-INVITATION-RECEIVED sa=32:85:a9:da:e6:1f persistent=7". + id = EVENT_P2P_INVITATION_RECEIVED; + info.address = /sa=([0-9a-f:]+)/.exec(aEventString)[1]; + info.netId = /persistent=([0-9]+)/.exec(aEventString)[1]; + } else if (0 === aEventString.indexOf("P2P-PROV-DISC-FAILURE")) { + id = EVENT_P2P_PROV_DISC_FAILURE; + } else { + // Not P2P event but we do receive it. Try to recognize it. + if (0 === aEventString.indexOf("AP-STA-DISCONNECTED")) { + id = EVENT_AP_STA_DISCONNECTED; + info.address = tokens[1]; + } else if (0 === aEventString.indexOf("AP-STA-CONNECTED")) { + id = EVENT_AP_STA_CONNECTED; + info.address = tokens[1]; + } else { + // Neither P2P event nor recognized supplicant event. + debug('Unknwon event string: ' + aEventString); + } + } + + let event = {id: id, info: info}; + debug('Event parsing result: ' + aEventString + ": " + JSON.stringify(event)); + + return event; + } + + function isIgnoredEvent(aEventString) { + const IGNORED_EVENTS = [ + "CTRL-EVENT-BSS-ADDED", + "CTRL-EVENT-BSS-REMOVED", + "CTRL-EVENT-SCAN-RESULTS", + "CTRL-EVENT-STATE-CHANGE", + "WPS-AP-AVAILABLE", + "WPS-ENROLLEE-SEEN" + ]; + for(let i = 0; i < IGNORED_EVENTS.length; i++) { + if (0 === aEventString.indexOf(IGNORED_EVENTS[i])) { + return true; + } + } + return false; + } + + function isPeerGroupOwner(aGroupFlag) { + return (aGroupFlag & GROUP_CAPAB_GROUP_OWNER) !== 0; + } + + // Convert flag to a wps capability array. + // + // @param aWpsFlag Number that represents the wps capabilities. + // @return Array of WPS flag. + function wpsFlagToCapabilities(aWpsFlag) { + let wpsCapabilities = []; + if (aWpsFlag & 0x8) { + wpsCapabilities.push(WPS_METHOD_DISPLAY); + } + if (aWpsFlag & 0x80) { + wpsCapabilities.push(WPS_METHOD_PBC); + } + if (aWpsFlag & 0x100) { + wpsCapabilities.push(WPS_METHOD_KEYPAD); + } + return wpsCapabilities; + } + + _stateMachine.start(); + return manager; +}; + +function P2pStateMachine(aP2pCommand, aNetUtil) { + function debug(aMsg) { + if (gDebug) { + dump('-------------- WifiP2pStateMachine: ' + aMsg); + } + } + + let p2pSm = {}; // The state machine to return. + + let _sm = StateMachine('WIFIP2P'); // The general purpose state machine. + + // Information we need to keep track across states. + let _observer; + + let _onEnabled; + let _onDisabled; + let _onSupplicantConnected; + let _savedConfig = {}; // Configuration used to do P2P_CONNECT. + let _groupInfo = {}; // The information of the group we have formed. + let _removedGroupInfo = {}; // Used to store the group info we are going to remove. + + let _scanBlocked = false; + let _scanPostponded = false; + + let _localDevice = { + address: "", + deviceName: DEFAULT_P2P_DEVICE_NAME + "_" + libcutils.property_get("ro.build.product"), + wpsCapabilities: [WPS_METHOD_PBC, WPS_METHOD_KEYPAD, WPS_METHOD_DISPLAY] + }; + + let _p2pNetworkInterface = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsINetworkInterface]), + + info: { + QueryInterface: XPCOMUtils.generateQI([Ci.nsINetworkInfo]), + + state: Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED, + type: Ci.nsINetworkInfo.NETWORK_TYPE_WIFI_P2P, + name: P2P_INTERFACE_NAME, + ips: [], + prefixLengths: [], + dnses: [], + gateways: [], + + getAddresses: function (ips, prefixLengths) { + ips.value = this.ips.slice(); + prefixLengths.value = this.prefixLengths.slice(); + + return this.ips.length; + }, + + getGateways: function (count) { + if (count) { + count.value = this.gateways.length; + } + return this.gateways.slice(); + }, + + getDnses: function (count) { + if (count) { + count.value = this.dnses.length; + } + return this.dnses.slice(); + } + }, + + httpProxyHost: null, + httpProxyPort: null, + + // help + registered: false + }; + + //--------------------------------------------------------- + // State machine APIs. + //--------------------------------------------------------- + + // Register the observer which is implemented in WifiP2pWorkerObserver.jsm. + // + // @param aObserver: + // .onEnabled + // .onDisbaled + // .onPeerFound + // .onPeerLost + // .onConnecting + // .onConnected + // .onDisconnected + // .onLocalDeviceChanged + p2pSm.setObserver = function(aObserver) { + _observer = aObserver; + }; + + p2pSm.start = function() { + _sm.start(stateDisabled); + }; + + p2pSm.sendEvent = function(aEvent) { + let willBeHandled = isInP2pManagedState(_sm.getCurrentState()); + _sm.sendEvent(aEvent); + return willBeHandled; + }; + + // Initialize internal state machine _sm. + _sm.setDefaultEventHandler(handleEventCommon); + + //---------------------------------------------------------- + // State definition. + //---------------------------------------------------------- + + // The initial state. + var stateDisabled = _sm.makeState("DISABLED", { + enter: function() { + _onEnabled = null; + _onSupplicantConnected = null; + _savedConfig = null; + _groupInfo = null; + _removedGroupInfo = null; + _scanBlocked = false; + _scanPostponded = false; + + unregisterP2pNetworkInteface(); + }, + + handleEvent: function(aEvent) { + switch (aEvent.id) { + case EVENT_P2P_CMD_ENABLE: + _onEnabled = aEvent.info.onEnabled; + _onSupplicantConnected = aEvent.info.onSupplicantConnected; + _sm.gotoState(stateEnabling); + break; + + default: + return false; + } // End of switch. + return true; + } + }); + + // The state where we are trying to enable wifi p2p. + var stateEnabling = _sm.makeState("ENABLING", { + enter: function() { + + function onFailure() + { + _onEnabled(false); + _observer.onDisabled(); + _sm.gotoState(stateDisabled); + } + + function onSuccess() + { + _onEnabled(true); + _observer.onEnabled(); + _sm.gotoState(stateInactive); + } + + _sm.pause(); + + // This function will only call back on success. + function connectToSupplicantIfNeeded(callback) { + if (aP2pCommand.getSdkVersion() >= 19) { + // No need to connect to supplicant on KK. Call back directly. + callback(); + return; + } + aP2pCommand.connectToSupplicant(function (status) { + if (0 !== status) { + debug('Failed to connect to p2p0'); + onFailure(); + return; + } + debug('wpa_supplicant p2p0 connected!'); + _onSupplicantConnected(); + callback(); + }); + } + + // Step 1: Connect to p2p0 if needed. + connectToSupplicantIfNeeded(function callback () { + let detail; + + // Step 2: Get MAC address. + if (!_localDevice.address) { + aP2pCommand.getMacAddress(function (address) { + if (!address) { + debug('Failed to get MAC address....'); + onFailure(); + return; + } + debug('Got mac address: ' + address); + _localDevice.address = address; + _observer.onLocalDeviceChanged(_localDevice); + }); + } + + // Step 3: Enable p2p with the device name and wps methods. + detail = { deviceName: _localDevice.deviceName, + deviceType: libcutils.property_get("ro.moz.wifi.p2p_device_type") || DEFAULT_P2P_DEVICE_TYPE, + wpsMethods: libcutils.property_get("ro.moz.wifi.p2p_wps_methods") || DEFAULT_P2P_WPS_METHODS }; + + aP2pCommand.p2pEnable(detail, function (success) { + if (!success) { + debug('Failed to enable p2p'); + onFailure(); + return; + } + + debug('P2P is enabled! Enabling net interface...'); + + // Step 4: Enable p2p0 net interface. wpa_supplicant may have + // already done it for us. + gNetworkService.enableInterface(P2P_INTERFACE_NAME, function (success) { + onSuccess(); + }); + }); + }); + }, + + handleEvent: function(aEvent) { + // We won't receive any event since all of them will be blocked. + return true; + } + }); + + // The state just after enabling wifi direct. + var stateInactive = _sm.makeState("INACTIVE", { + enter: function() { + registerP2pNetworkInteface(); + + if (_sm.getPreviousState() !== stateEnabling) { + _observer.onDisconnected(_savedConfig); + } + + _savedConfig = null; // Used to connect p2p peer. + _groupInfo = null; // The information of the formed group. + }, + + handleEvent: function(aEvent) { + switch (aEvent.id) { + // Receiving the following 3 states implies someone is trying to + // connect to me. + case EVENT_P2P_PROV_DISC_PBC_REQ: + case EVENT_P2P_PROV_DISC_SHOW_PIN: + case EVENT_P2P_PROV_DISC_ENTER_PIN: + debug('Someone is trying to connect to me: ' + JSON.stringify(aEvent.info)); + + _savedConfig = { + name: aEvent.info.name, + address: aEvent.info.address, + wpsMethod: aEvent.info.wpsMethod, + goIntent: DEFAULT_GO_INTENT, + pin: aEvent.info.pin // EVENT_P2P_PROV_DISC_SHOW_PIN only. + }; + + _sm.gotoState(stateWaitingForConfirmation); + break; + + // Connect to a peer. + case EVENT_P2P_CMD_CONNECT: + debug('Trying to connect to peer: ' + JSON.stringify(aEvent.info)); + + _savedConfig = { + address: aEvent.info.address, + wpsMethod: aEvent.info.wpsMethod, + goIntent: aEvent.info.goIntent + }; + + _sm.gotoState(stateProvisionDiscovery); + aEvent.info.onDoConnect(true); + break; + + case EVENT_P2P_INVITATION_RECEIVED: + _savedConfig = { + address: aEvent.info.address, + wpsMethod: WPS_METHOD_PBC, + goIntent: DEFAULT_GO_INTENT, + netId: aEvent.info.netId + }; + _sm.gotoState(stateWaitingForInvitationConfirmation); + break; + + case EVENT_P2P_GROUP_STARTED: + // Most likely the peer just reinvoked a peristen group and succeeeded. + + _savedConfig = { address: aEvent.info.goAddress }; + + _sm.pause(); + handleGroupStarted(aEvent.info, function (success) { + _sm.resume(); + }); + break; + + case EVENT_AP_STA_DISCONNECTED: + // We will hit this case when we used to be a group owner and + // requested to remove the group we owned. + break; + + default: + return false; + } // End of switch. + return true; + }, + }); + + // Waiting for user's confirmation. + var stateWaitingForConfirmation = _sm.makeState("WAITING_FOR_CONFIRMATION", { + timeoutTimer: null, + + enter: function() { + gSysMsgr.broadcastMessage(PAIRING_REQUEST_SYS_MSG, _savedConfig); + this.timeoutTimer = initTimeoutTimer(30000, EVENT_TIMEOUT_PAIRING_CONFIRMATION); + }, + + handleEvent: function(aEvent) { + switch (aEvent.id) { + case EVENT_P2P_SET_PAIRING_CONFIRMATION: + if (!aEvent.info.accepted) { + debug('User rejected this request'); + _sm.gotoState(stateInactive); // Reset to inactive state. + break; + } + + debug('User accepted this request'); + + // The only information we may have to grab from user. + _savedConfig.pin = aEvent.info.pin; + + // The case that user requested to form a group ealier on. + // Just go to connecting state and do p2p_connect. + if (_sm.getPreviousState() === stateProvisionDiscovery) { + _sm.gotoState(stateConnecting); + break; + } + + // Otherwise, wait for EVENT_P2P_GO_NEG_REQUEST. + _sm.gotoState(stateWaitingForNegReq); + break; + + case EVENT_TIMEOUT_PAIRING_CONFIRMATION: + debug('Confirmation timeout!'); + _sm.gotoState(stateInactive); + break; + + case EVENT_P2P_GO_NEG_REQUEST: + _sm.deferEvent(aEvent); + break; + + default: + return false; + } // End of switch. + + return true; + }, + + exit: function() { + this.timeoutTimer.cancel(); + this.timeoutTimer = null; + } + }); + + var stateWaitingForNegReq = _sm.makeState("WAITING_FOR_NEG_REQ", { + timeoutTimer: null, + + enter: function() { + debug('Wait for EVENT_P2P_GO_NEG_REQUEST'); + this.timeoutTimer = initTimeoutTimer(30000, EVENT_TIMEOUT_NEG_REQ); + }, + + handleEvent: function(aEvent) { + switch (aEvent.id) { + case EVENT_P2P_GO_NEG_REQUEST: + if (aEvent.info.wpsMethod !== _savedConfig.wpsMethod) { + debug('Unmatched wps method: ' + aEvent.info.wpsMethod + ", " + _savedConfig.wpsMetho); + } + _sm.gotoState(stateConnecting); + break; + + case EVENT_TIMEOUT_NEG_REQ: + debug("Waiting for NEG-REQ timeout"); + _sm.gotoState(stateInactive); + break; + + default: + return false; + } // End of switch. + return true; + }, + + exit: function() { + this.timeoutTimer.cancel(); + this.timeoutTimer = null; + } + }); + + // Waiting for user's confirmation for invitation. + var stateWaitingForInvitationConfirmation = _sm.makeState("WAITING_FOR_INV_CONFIRMATION", { + timeoutTimer: null, + + enter: function() { + gSysMsgr.broadcastMessage(PAIRING_REQUEST_SYS_MSG, _savedConfig); + this.timeoutTimer = initTimeoutTimer(30000, EVENT_TIMEOUT_PAIRING_CONFIRMATION); + }, + + handleEvent: function(aEvent) { + switch (aEvent.id) { + case EVENT_P2P_SET_PAIRING_CONFIRMATION: + if (!aEvent.info.accepted) { + debug('User rejected this request'); + _sm.gotoState(stateInactive); // Reset to inactive state. + break; + } + + debug('User accepted this request'); + _sm.pause(); + aP2pCommand.p2pGetGroupCapab(_savedConfig.address, function (gc) { + let isPeeGroupOwner = gc & GROUP_CAPAB_GROUP_OWNER; + _sm.gotoState(isPeeGroupOwner ? stateGroupAdding : stateReinvoking); + }); + + break; + + case EVENT_TIMEOUT_PAIRING_CONFIRMATION: + debug('Confirmation timeout!'); + _sm.gotoState(stateInactive); + break; + + default: + return false; + } // End of switch. + + return true; + }, + + exit: function() { + this.timeoutTimer.cancel(); + this.timeoutTimer = null; + } + }); + + var stateGroupAdding = _sm.makeState("GROUP_ADDING", { + timeoutTimer: null, + + enter: function() { + let self = this; + + _observer.onConnecting(_savedConfig); + + _sm.pause(); + aP2pCommand.p2pGroupAdd(_savedConfig.netId, function (success) { + if (!success) { + _sm.gotoState(stateInactive); + return; + } + // Waiting for EVENT_P2P_GROUP_STARTED. + self.timeoutTimer = initTimeoutTimer(60000, EVENT_TIMEOUT_CONNECTING); + _sm.resume(); + }); + }, + + handleEvent: function(aEvent) { + switch (aEvent.id) { + case EVENT_P2P_GROUP_STARTED: + _sm.pause(); + handleGroupStarted(aEvent.info, function (success) { + _sm.resume(); + }); + break; + + case EVENT_P2P_GO_NEG_FAILURE: + debug('Negotiation failure. Go back to inactive state'); + _sm.gotoState(stateInactive); + break; + + case EVENT_TIMEOUT_CONNECTING: + debug('Connecting timeout! Go back to inactive state'); + _sm.gotoState(stateInactive); + break; + + case EVENT_P2P_GROUP_FORMATION_SUCCESS: + case EVENT_P2P_GO_NEG_SUCCESS: + break; + + case EVENT_P2P_GROUP_FORMATION_FAILURE: + debug('Group formation failure'); + _sm.gotoState(stateInactive); + break; + + case EVENT_P2P_GROUP_REMOVED: + debug('Received P2P-GROUP-REMOVED due to previous failed handleGroupdStarted()'); + _removedGroupInfo = { + role: aEvent.info.role, + ifname: aEvent.info.ifname + }; + _sm.gotoState(stateDisconnecting); + break; + + default: + return false; + } // End of switch. + + return true; + }, + + exit: function() { + this.timeoutTimer.cancel(); + this.timeoutTimer = null; + } + }); + + var stateReinvoking = _sm.makeState("REINVOKING", { + timeoutTimer: null, + + enter: function() { + let self = this; + + _observer.onConnecting(_savedConfig); + _sm.pause(); + aP2pCommand.p2pReinvoke(_savedConfig.netId, _savedConfig.address, function(success) { + if (!success) { + _sm.gotoState(stateInactive); + return; + } + // Waiting for EVENT_P2P_GROUP_STARTED. + self.timeoutTimer = initTimeoutTimer(60000, EVENT_TIMEOUT_CONNECTING); + _sm.resume(); + }); + }, + + handleEvent: function(aEvent) { + switch (aEvent.id) { + case EVENT_P2P_GROUP_STARTED: + _sm.pause(); + handleGroupStarted(aEvent.info, function(success) { + _sm.resume(); + }); + break; + + case EVENT_P2P_GO_NEG_FAILURE: + debug('Negotiation failure. Go back to inactive state'); + _sm.gotoState(stateInactive); + break; + + case EVENT_TIMEOUT_CONNECTING: + debug('Connecting timeout! Go back to inactive state'); + _sm.gotoState(stateInactive); + break; + + case EVENT_P2P_GROUP_FORMATION_SUCCESS: + case EVENT_P2P_GO_NEG_SUCCESS: + break; + + case EVENT_P2P_GROUP_FORMATION_FAILURE: + debug('Group formation failure'); + _sm.gotoState(stateInactive); + break; + + case EVENT_P2P_GROUP_REMOVED: + debug('Received P2P-GROUP-REMOVED due to previous failed handleGroupdStarted()'); + _removedGroupInfo = { + role: aEvent.info.role, + ifname: aEvent.info.ifname + }; + _sm.gotoState(stateDisconnecting); + break; + + default: + return false; + } // End of switch. + + return true; + }, + + exit: function() { + this.timeoutTimer.cancel(); + } + }); + + var stateProvisionDiscovery = _sm.makeState("PROVISION_DISCOVERY", { + enter: function() { + function onDiscoveryCommandSent(success) { + if (!success) { + _sm.gotoState(stateInactive); + debug('Failed to send p2p_prov_disc. Go back to inactive state.'); + return; + } + + debug('p2p_prov_disc has been sent.'); + + _sm.resume(); + // Waiting for EVENT_P2P_PROV_DISC_PBC_RESP or + // EVENT_P2P_PROV_DISC_SHOW_PIN or + // EVENT_P2P_PROV_DISC_ENTER_PIN. + } + + _sm.pause(); + aP2pCommand.p2pProvDiscovery(_savedConfig.address, + toPeerWpsMethod(_savedConfig.wpsMethod), + onDiscoveryCommandSent); + }, + + handleEvent: function(aEvent) { + switch (aEvent.id) { + case EVENT_P2P_PROV_DISC_PBC_RESP: + _sm.gotoState(stateConnecting); // No need for local user grant. + break; + case EVENT_P2P_PROV_DISC_SHOW_PIN: + case EVENT_P2P_PROV_DISC_ENTER_PIN: + if (aEvent.info.wpsMethod !== _savedConfig.wpsMethod) { + debug('Unmatched wps method: ' + aEvent.info.wpsMethod + ":" + _savedConfig.wpsMethod); + } + if (EVENT_P2P_PROV_DISC_SHOW_PIN === aEvent.id) { + _savedConfig.pin = aEvent.info.pin; + } + _sm.gotoState(stateWaitingForConfirmation); + break; + + case EVENT_P2P_PROV_DISC_FAILURE: + _sm.gotoState(stateInactive); + break; + + default: + return false; + } // End of switch. + return true; + } + }); + + // We are going to connect to the peer. + // |_savedConfig| is supposed to have been filled properly. + var stateConnecting = _sm.makeState("CONNECTING", { + timeoutTimer: null, + + enter: function() { + let self = this; + + if (null === _savedConfig.goIntent) { + _savedConfig.goIntent = DEFAULT_GO_INTENT; + } + + _observer.onConnecting(_savedConfig); + + let wpsMethodWithPin; + if (WPS_METHOD_KEYPAD === _savedConfig.wpsMethod || + WPS_METHOD_DISPLAY === _savedConfig.wpsMethod) { + // e.g. '12345678 display or '12345678 keypad'. + wpsMethodWithPin = (_savedConfig.pin + ' ' + _savedConfig.wpsMethod); + } else { + // e.g. 'pbc'. + wpsMethodWithPin = _savedConfig.wpsMethod; + } + + _sm.pause(); + + aP2pCommand.p2pGetGroupCapab(_savedConfig.address, function(gc) { + debug('group capabilities of ' + _savedConfig.address + ': ' + gc); + + let isPeerGroupOwner = gc & GROUP_CAPAB_GROUP_OWNER; + let config = { address: _savedConfig.address, + wpsMethodWithPin: wpsMethodWithPin, + goIntent: _savedConfig.goIntent, + joinExistingGroup: isPeerGroupOwner }; + + aP2pCommand.p2pConnect(config, function (success) { + if (!success) { + debug('Failed to send p2p_connect'); + _sm.gotoState(stateInactive); + return; + } + debug('Waiting for EVENT_P2P_GROUP_STARTED.'); + self.timeoutTimer = initTimeoutTimer(60000, EVENT_TIMEOUT_CONNECTING); + _sm.resume(); + }); + }); + }, + + handleEvent: function(aEvent) { + switch (aEvent.id) { + case EVENT_P2P_GROUP_STARTED: + _sm.pause(); + handleGroupStarted(aEvent.info, function (success) { + _sm.resume(); + }); + break; + + case EVENT_P2P_GO_NEG_FAILURE: + debug('Negotiation failure. Go back to inactive state'); + _sm.gotoState(stateInactive); + break; + + case EVENT_TIMEOUT_CONNECTING: + debug('Connecting timeout! Go back to inactive state'); + _sm.gotoState(stateInactive); + break; + + case EVENT_P2P_GROUP_FORMATION_SUCCESS: + case EVENT_P2P_GO_NEG_SUCCESS: + break; + + case EVENT_P2P_GROUP_FORMATION_FAILURE: + debug('Group formation failure'); + _sm.gotoState(stateInactive); + break; + + case EVENT_P2P_GROUP_REMOVED: + debug('Received P2P-GROUP-REMOVED due to previous failed ' + + 'handleGroupdStarted()'); + _removedGroupInfo = { + role: aEvent.info.role, + ifname: aEvent.info.ifname + }; + _sm.gotoState(stateDisconnecting); + break; + + default: + return false; + } // End of switch. + + return true; + }, + + exit: function() { + this.timeoutTimer.cancel(); + } + }); + + var stateConnected = _sm.makeState("CONNECTED", { + groupOwner: null, + + enter: function() { + this.groupOwner = { + macAddress: _groupInfo.goAddress, + ipAddress: _groupInfo.networkInterface.info.gateways[0], + passphrase: _groupInfo.passphrase, + ssid: _groupInfo.ssid, + freq: _groupInfo.freq, + isLocal: _groupInfo.isGroupOwner + }; + + if (!_groupInfo.isGroupOwner) { + _observer.onConnected(this.groupOwner, _savedConfig); + } else { + // If I am a group owner, notify onConnected until EVENT_AP_STA_CONNECTED + // is received. + } + + _removedGroupInfo = null; + }, + + handleEvent: function(aEvent) { + switch (aEvent.id) { + case EVENT_AP_STA_CONNECTED: + if (_groupInfo.isGroupOwner) { + _observer.onConnected(this.groupOwner, _savedConfig); + } + break; + + case EVENT_P2P_GROUP_REMOVED: + _removedGroupInfo = { + role: aEvent.info.role, + ifname: aEvent.info.ifname + }; + _sm.gotoState(stateDisconnecting); + break; + + case EVENT_AP_STA_DISCONNECTED: + debug('Client disconnected: ' + aEvent.info.address); + + // Now we suppose it's the only client. Remove my group. + _sm.pause(); + aP2pCommand.p2pGroupRemove(_groupInfo.ifname, function (success) { + debug('Requested to remove p2p group. Wait for EVENT_P2P_GROUP_REMOVED.'); + _sm.resume(); + }); + break; + + case EVENT_P2P_CMD_DISCONNECT: + // Since we only support single connection, we can ignore + // the given peer address. + _sm.pause(); + aP2pCommand.p2pGroupRemove(_groupInfo.ifname, function(success) { + aEvent.info.onDoDisconnect(true); + _sm.resume(); + }); + + debug('Sent disconnect command. Wait for EVENT_P2P_GROUP_REMOVED.'); + break; + + case EVENT_P2P_PROV_DISC_PBC_REQ: + case EVENT_P2P_PROV_DISC_SHOW_PIN: + case EVENT_P2P_PROV_DISC_ENTER_PIN: + debug('Someone is trying to connect to me: ' + JSON.stringify(aEvent.info)); + + _savedConfig = { + name: aEvent.info.name, + address: aEvent.info.address, + wpsMethod: aEvent.info.wpsMethod, + pin: aEvent.info.pin + }; + + _sm.gotoState(stateWaitingForJoiningConfirmation); + break; + + default: + return false; + } // end of switch + return true; + } + }); + + var stateWaitingForJoiningConfirmation = _sm.makeState("WAITING_FOR_JOINING_CONFIRMATION", { + timeoutTimer: null, + + enter: function() { + gSysMsgr.broadcastMessage(PAIRING_REQUEST_SYS_MSG, _savedConfig); + this.timeoutTimer = initTimeoutTimer(30000, EVENT_TIMEOUT_PAIRING_CONFIRMATION); + }, + + handleEvent: function (aEvent) { + switch (aEvent.id) { + case EVENT_P2P_SET_PAIRING_CONFIRMATION: + if (!aEvent.info.accepted) { + debug('User rejected invitation!'); + _sm.gotoState(stateConnected); + break; + } + + let onWpsCommandSent = function(success) { + _observer.onConnecting(_savedConfig); + _sm.gotoState(stateConnected); + }; + + _sm.pause(); + if (WPS_METHOD_PBC === _savedConfig.wpsMethod) { + aP2pCommand.wpsPbc(onWpsCommandSent, _groupInfo.ifname); + } else { + let detail = { pin: _savedConfig.pin, iface: _groupInfo.ifname }; + aP2pCommand.wpsPin(detail, onWpsCommandSent); + } + break; + + case EVENT_TIMEOUT_PAIRING_CONFIRMATION: + debug('WAITING_FOR_JOINING_CONFIRMATION timeout!'); + _sm.gotoState(stateConnected); + break; + + default: + return false; + } // End of switch. + return true; + }, + + exit: function() { + this.timeoutTimer.cancel(); + this.timeoutTimer = null; + } + }); + + var stateDisconnecting = _sm.makeState("DISCONNECTING", { + enter: function() { + _sm.pause(); + handleGroupRemoved(_removedGroupInfo, function (success) { + if (!success) { + debug('Failed to handle group removed event. What can I do?'); + } + _sm.gotoState(stateInactive); + }); + }, + + handleEvent: function(aEvent) { + return false; // We will not receive any event in this state. + } + }); + + var stateDisabling = _sm.makeState("DISABLING", { + enter: function() { + _sm.pause(); + aNetUtil.stopDhcpServer(function (success) { // Stopping DHCP server is harmless. + debug('Stop DHCP server result: ' + success); + aP2pCommand.p2pDisable(function(success) { + debug('P2P function disabled'); + closeSupplicantConnectionIfNeeded(function() { + debug('Supplicant connection closed'); + gNetworkService.disableInterface(P2P_INTERFACE_NAME, function (success){ + debug('Disabled interface: ' + P2P_INTERFACE_NAME); + _onDisabled(true); + _observer.onDisabled(); + _sm.gotoState(stateDisabled); + }); + }); + }); + }); + + function closeSupplicantConnectionIfNeeded(callback) { + // No need to connect to supplicant on KK. Call back directly. + if (aP2pCommand.getSdkVersion() >= 19) { + callback(); + return; + } + aP2pCommand.closeSupplicantConnection(callback); + } + }, + + handleEvent: function(aEvent) { + return false; // We will not receive any event in this state. + } + }); + + //---------------------------------------------------------- + // Helper functions. + //---------------------------------------------------------- + + // Handle 'P2P_GROUP_STARTED' event. Note that this function + // will also do the state transitioning and error handling. + // + // @param aInfo Information carried by "P2P_GROUP_STARTED" event: + // .role: P2P_ROLE_GO or P2P_ROLE_CLIENT + // .ssid: + // .freq: + // .passphrase: Used to connect to GO for legacy device. + // .goAddress: + // .ifname: e.g. p2p-p2p0 + // + // @param aCallback Callback function. + function handleGroupStarted(aInfo, aCallback) { + debug('handleGroupStarted: ' + JSON.stringify(aInfo)); + + function onSuccess() + { + _sm.gotoState(stateConnected); + aCallback(true); + } + + function onFailure() + { + debug('Failed to handleGroupdStarted(). Remove the group...'); + aP2pCommand.p2pGroupRemove(aInfo.ifname, function (success) { + aCallback(false); + + if (success) { + return; // Stay in current state and wait for EVENT_P2P_GROUP_REMOVED. + } + + debug('p2pGroupRemove command error!'); + _sm.gotoState(stateInactive); + }); + } + + // Save this group information. + _groupInfo = aInfo; + _groupInfo.isGroupOwner = (P2P_ROLE_GO === aInfo.role); + + if (_groupInfo.isGroupOwner) { + debug('Group owner. Start DHCP server'); + let dhcpServerConfig = { ifname: aInfo.ifname, + startIp: GO_DHCP_SERVER_IP_RANGE.startIp, + endIp: GO_DHCP_SERVER_IP_RANGE.endIp, + serverIp: GO_NETWORK_INTERFACE.ip, + maskLength: GO_NETWORK_INTERFACE.maskLength }; + + aNetUtil.startDhcpServer(dhcpServerConfig, function (success) { + if (!success) { + debug('Failed to start DHCP server'); + onFailure(); + return; + } + + // Update p2p network interface. + _p2pNetworkInterface.info.state = Ci.nsINetworkInfo.NETWORK_STATE_CONNECTED; + _p2pNetworkInterface.info.ips = [GO_NETWORK_INTERFACE.ip]; + _p2pNetworkInterface.info.prefixLengths = [GO_NETWORK_INTERFACE.maskLength]; + _p2pNetworkInterface.info.gateways = [GO_NETWORK_INTERFACE.ip]; + handleP2pNetworkInterfaceStateChanged(); + + _groupInfo.networkInterface = _p2pNetworkInterface; + + debug('Everything is done. Happy p2p GO~'); + onSuccess(); + }); + + return; + } + + // We are the client. + + debug("Client. Request IP from DHCP server on interface: " + _groupInfo.ifname); + + aNetUtil.runDhcp(aInfo.ifname, 0, function(dhcpData) { + if(!dhcpData || !dhcpData.info) { + debug('Failed to run DHCP client'); + onFailure(); + return; + } + + // Save network interface. + debug("DHCP request success: " + JSON.stringify(dhcpData.info)); + + // Update p2p network interface. + let maskLength = + netHelpers.getMaskLength(netHelpers.stringToIP(dhcpData.info.mask_str)); + if (!maskLength) { + maskLength = 32; // max prefix for IPv4. + } + _p2pNetworkInterface.info.state = Ci.nsINetworkInfo.NETWORK_STATE_CONNECTED; + _p2pNetworkInterface.info.ips = [dhcpData.info.ipaddr_str]; + _p2pNetworkInterface.info.prefixLengths = [maskLength]; + if (typeof dhcpData.info.dns1_str == "string" && + dhcpData.info.dns1_str.length) { + _p2pNetworkInterface.info.dnses.push(dhcpData.info.dns1_str); + } + if (typeof dhcpData.info.dns2_str == "string" && + dhcpData.info.dns2_str.length) { + _p2pNetworkInterface.info.dnses.push(dhcpData.info.dns2_str); + } + _p2pNetworkInterface.info.gateways = [dhcpData.info.gateway_str]; + handleP2pNetworkInterfaceStateChanged(); + + _groupInfo.networkInterface = _p2pNetworkInterface; + + debug('Happy p2p client~'); + onSuccess(); + }); + } + + function resetP2pNetworkInterface() { + _p2pNetworkInterface.info.state = Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED; + _p2pNetworkInterface.info.ips = []; + _p2pNetworkInterface.info.prefixLengths = []; + _p2pNetworkInterface.info.dnses = []; + _p2pNetworkInterface.info.gateways = []; + } + + function registerP2pNetworkInteface() { + if (!_p2pNetworkInterface.registered) { + resetP2pNetworkInterface(); + gNetworkManager.registerNetworkInterface(_p2pNetworkInterface); + _p2pNetworkInterface.registered = true; + } + } + + function unregisterP2pNetworkInteface() { + if (_p2pNetworkInterface.registered) { + resetP2pNetworkInterface(); + gNetworkManager.unregisterNetworkInterface(_p2pNetworkInterface); + _p2pNetworkInterface.registered = false; + } + } + + function handleP2pNetworkInterfaceStateChanged() { + gNetworkManager.updateNetworkInterface(_p2pNetworkInterface); + } + + // Handle 'P2P_GROUP_STARTED' event. + // + // @param aInfo information carried by "P2P_GROUP_REMOVED" event: + // .ifname + // .role: "GO" or "client". + // + // @param aCallback Callback function. + function handleGroupRemoved(aInfo, aCallback) { + if (!_groupInfo) { + debug('No group info. Why?'); + aCallback(true); + return; + } + if (_groupInfo.ifname !== aInfo.ifname || + _groupInfo.role !== aInfo.role) { + debug('Unmatched group info: ' + JSON.stringify(_groupInfo) + + ' v.s. ' + JSON.stringify(aInfo)); + } + + // Update p2p network interface. + _p2pNetworkInterface.info.state = Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED; + handleP2pNetworkInterfaceStateChanged(); + + if (P2P_ROLE_GO === aInfo.role) { + aNetUtil.stopDhcpServer(function(success) { + debug('Stop DHCP server result: ' + success); + aCallback(true); + }); + } else { + aNetUtil.stopDhcp(aInfo.ifname, function() { + aCallback(true); + }); + } + } + + // Non state-specific event handler. + function handleEventCommon(aEvent) { + switch (aEvent.id) { + case EVENT_P2P_DEVICE_FOUND: + _observer.onPeerFound(aEvent.info); + break; + + case EVENT_P2P_DEVICE_LOST: + _observer.onPeerLost(aEvent.info); + break; + + case EVENT_P2P_CMD_DISABLE: + _onDisabled = aEvent.info.onDisabled; + _sm.gotoState(stateDisabling); + break; + + case EVENT_P2P_CMD_ENABLE_SCAN: + if (_scanBlocked) { + _scanPostponded = true; + aEvent.info.callback(true); + break; + } + aP2pCommand.p2pEnableScan(P2P_SCAN_TIMEOUT_SEC, aEvent.info.callback); + break; + + case EVENT_P2P_CMD_DISABLE_SCAN: + aP2pCommand.p2pDisableScan(aEvent.info.callback); + break; + + case EVENT_P2P_FIND_STOPPED: + break; + + case EVENT_P2P_CMD_BLOCK_SCAN: + _scanBlocked = true; + aP2pCommand.p2pDisableScan(function(success) {}); + break; + + case EVENT_P2P_CMD_UNBLOCK_SCAN: + _scanBlocked = false; + if (_scanPostponded) { + aP2pCommand.p2pEnableScan(P2P_SCAN_TIMEOUT_SEC, function(success) {}); + } + break; + + case EVENT_P2P_CMD_CONNECT: + case EVENT_P2P_CMD_DISCONNECT: + debug("The current state couldn't handle connect/disconnect request. Ignore it."); + break; + + default: + return false; + } // End of switch. + return true; + } + + function isInP2pManagedState(aState) { + let p2pManagedStates = [stateWaitingForConfirmation, + stateWaitingForNegReq, + stateProvisionDiscovery, + stateWaitingForInvitationConfirmation, + stateGroupAdding, + stateReinvoking, + stateConnecting, + stateConnected, + stateDisconnecting]; + + for (let i = 0; i < p2pManagedStates.length; i++) { + if (aState === p2pManagedStates[i]) { + return true; + } + } + + return false; + } + + function initTimeoutTimer(aTimeoutMs, aTimeoutEvent) { + let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + function onTimerFired() { + _sm.sendEvent({ id: aTimeoutEvent }); + timer = null; + } + timer.initWithCallback(onTimerFired.bind(this), aTimeoutMs, + Ci.nsITimer.TYPE_ONE_SHOT); + return timer; + } + + // Converts local WPS method to peer WPS method. + function toPeerWpsMethod(aLocalWpsMethod) { + switch (aLocalWpsMethod) { + case WPS_METHOD_DISPLAY: + return WPS_METHOD_KEYPAD; + case WPS_METHOD_KEYPAD: + return WPS_METHOD_DISPLAY; + case WPS_METHOD_PBC: + return WPS_METHOD_PBC; + default: + return WPS_METHOD_PBC; // Use "push button" as the default method. + } + } + + return p2pSm; +} + +this.WifiP2pManager.INTERFACE_NAME = P2P_INTERFACE_NAME; diff --git a/dom/wifi/WifiP2pWorkerObserver.jsm b/dom/wifi/WifiP2pWorkerObserver.jsm new file mode 100644 index 000000000..d04e8db5e --- /dev/null +++ b/dom/wifi/WifiP2pWorkerObserver.jsm @@ -0,0 +1,319 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +const CONNECTION_STATUS_DISCONNECTED = "disconnected"; +const CONNECTION_STATUS_CONNECTING = "connecting"; +const CONNECTION_STATUS_CONNECTED = "connected"; +const CONNECTION_STATUS_DISCONNECTING = "disconnecting"; + +const DEBUG = false; + +this.EXPORTED_SYMBOLS = ["WifiP2pWorkerObserver"]; + +// WifiP2pWorkerObserver resides in WifiWorker to handle DOM message +// by either 1) returning internally maintained information or +// 2) delegating to aDomMsgResponder. It is also responsible +// for observing events from WifiP2pManager and dispatch to DOM. +// +// @param aDomMsgResponder handles DOM messages, including +// - setScanEnabled +// - connect +// - disconnect +// - setPairingConfirmation +// The instance is actually WifiP2pManager. +this.WifiP2pWorkerObserver = function(aDomMsgResponder) { + function debug(aMsg) { + if (DEBUG) { + dump('-------------- WifiP2pWorkerObserver: ' + aMsg); + } + } + + // Private member variables. + let _localDevice; + let _peerList = {}; // List of P2pDevice. + let _domManagers = []; + let _enabled = false; + let _groupOwner = null; + let _currentPeer = null; + + // Constructor of P2pDevice. It will be exposed to DOM. + // + // @param aPeer object representing a P2P device: + // .name: string for the device name. + // .address: Mac address. + // .isGroupOwner: boolean to indicate if this device is the group owner. + // .wpsCapabilities: array of string of {"pbc", "display", "keypad"}. + function P2pDevice(aPeer) { + this.address = aPeer.address; + this.name = (aPeer.name ? aPeer.name : aPeer.address); + this.isGroupOwner = aPeer.isGroupOwner; + this.wpsCapabilities = aPeer.wpsCapabilities; + this.connectionStatus = CONNECTION_STATUS_DISCONNECTED; + + // Since this object will be exposed to web, defined the exposed + // properties here. + this.__exposedProps__ = { + address: "r", + name: "r", + isGroupOwner: "r", + wpsCapabilities: "r", + connectionStatus: "r" + }; + } + + // Constructor of P2pGroupOwner. + // + // @param aGroupOwner: + // .macAddress + // .ipAddress + // .passphrase + // .ssid + // .freq + // .isLocal + function P2pGroupOwner(aGroupOwner) { + this.macAddress = aGroupOwner.macAddress; // The identifier to get further information. + this.ipAddress = aGroupOwner.ipAddress; + this.passphrase = aGroupOwner.passphrase; + this.ssid = aGroupOwner.ssid; // e.g. DIRECT-xy. + this.freq = aGroupOwner.freq; + this.isLocal = aGroupOwner.isLocal; + + let detail = _peerList[aGroupOwner.macAddress]; + if (detail) { + this.name = detail.name; + this.wpsCapabilities = detail.wpsCapabilities; + } else if (_localDevice.address === this.macAddress) { + this.name = _localDevice.name; + this.wpsCapabilities = _localDevice.wpsCapabilities; + } else { + debug("We don't know this group owner: " + aGroupOwner.macAddress); + this.name = aGroupOwner.macAddress; + this.wpsCapabilities = []; + } + } + + function fireEvent(aMessage, aData) { + debug('domManager: ' + JSON.stringify(_domManagers)); + _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("WifiP2pManager:" + aMessage, aData); + }); + } + + function addDomManager(aMsg) { + if (-1 === _domManagers.indexOf(aMsg.manager)) { + _domManagers.push(aMsg.manager); + } + } + + function returnMessage(aMessage, aSuccess, aData, aMsg) { + let rMsg = aMessage + ":Return:" + (aSuccess ? "OK" : "NO"); + aMsg.manager.sendAsyncMessage(rMsg, + { data: aData, rid: aMsg.rid, mid: aMsg.mid }); + } + + function handlePeerListUpdated() { + fireEvent("onpeerinfoupdate", {}); + } + + // Return a literal object as the constructed object. + return { + onLocalDeviceChanged: function(aDevice) { + _localDevice = aDevice; + debug('Local device updated to: ' + JSON.stringify(_localDevice)); + }, + + onEnabled: function() { + _peerList = []; + _enabled = true; + fireEvent("p2pUp", {}); + }, + + onDisbaled: function() { + _enabled = false; + fireEvent("p2pDown", {}); + }, + + onPeerFound: function(aPeer) { + let newFoundPeer = new P2pDevice(aPeer); + let origianlPeer = _peerList[aPeer.address]; + _peerList[aPeer.address] = newFoundPeer; + if (origianlPeer) { + newFoundPeer.connectionStatus = origianlPeer.connectionStatus; + } + handlePeerListUpdated(); + }, + + onPeerLost: function(aPeer) { + let lostPeer = _peerList[aPeer.address]; + if (!lostPeer) { + debug('Unknown peer lost: ' + aPeer.address); + return; + } + delete _peerList[aPeer.address]; + handlePeerListUpdated(); + }, + + onConnecting: function(aPeer) { + let peer = _peerList[aPeer.address]; + if (!peer) { + debug('Unknown peer connecting: ' + aPeer.address); + peer = new P2pDevice(aPeer); + _peerList[aPeer.address] = peer; + handlePeerListUpdated(); + } + peer.connectionStatus = CONNECTION_STATUS_CONNECTING; + + fireEvent('onconnecting', { peer: peer }); + }, + + onConnected: function(aGroupOwner, aPeer) { + let go = new P2pGroupOwner(aGroupOwner); + let peer = _peerList[aPeer.address]; + if (!peer) { + debug('Unknown peer connected: ' + aPeer.address); + peer = new P2pDevice(aPeer); + _peerList[aPeer.address] = peer; + handlePeerListUpdated(); + } + peer.connectionStatus = CONNECTION_STATUS_CONNECTED; + peer.isGroupOwner = (aPeer.address === aGroupOwner.address); + + _groupOwner = go; + _currentPeer = peer; + + fireEvent('onconnected', { groupOwner: go, peer: peer }); + }, + + onDisconnected: function(aPeer) { + let peer = _peerList[aPeer.address]; + if (!peer) { + debug('Unknown peer disconnected: ' + aPeer.address); + return; + } + + peer.connectionStatus = CONNECTION_STATUS_DISCONNECTED; + + _groupOwner = null; + _currentPeer = null; + + fireEvent('ondisconnected', { peer: peer }); + }, + + getObservedDOMMessages: function() { + return [ + "WifiP2pManager:getState", + "WifiP2pManager:getPeerList", + "WifiP2pManager:setScanEnabled", + "WifiP2pManager:connect", + "WifiP2pManager:disconnect", + "WifiP2pManager:setPairingConfirmation", + "WifiP2pManager:setDeviceName" + ]; + }, + + onDOMMessage: function(aMessage) { + let msg = aMessage.data || {}; + msg.manager = aMessage.target; + + if ("child-process-shutdown" === aMessage.name) { + let i; + if (-1 !== (i = _domManagers.indexOf(msg.manager))) { + _domManagers.splice(i, 1); + } + return; + } + + if (!aMessage.target.assertPermission("wifi-manage")) { + return; + } + + switch (aMessage.name) { + case "WifiP2pManager:getState": // A new DOM manager is created. + addDomManager(msg); + return { // Synchronous call. Simply return it. + enabled: _enabled, + groupOwner: _groupOwner, + currentPeer: _currentPeer + }; + + case "WifiP2pManager:setScanEnabled": + { + let enabled = msg.data; + + aDomMsgResponder.setScanEnabled(enabled, function(success) { + returnMessage(aMessage.name, success, (success ? true : "ERROR"), msg); + }); + } + break; + + case "WifiP2pManager:getPeerList": + { + // Convert the object to an array. + let peerArray = []; + for (let key in _peerList) { + if (_peerList.hasOwnProperty(key)) { + peerArray.push(_peerList[key]); + } + } + + returnMessage(aMessage.name, true, peerArray, msg); + } + break; + + case "WifiP2pManager:connect": + { + let peer = msg.data; + + let onDoConnect = function(success) { + returnMessage(aMessage.name, success, (success ? true : "ERROR"), msg); + }; + + aDomMsgResponder.connect(peer.address, peer.wpsMethod, + peer.goIntent, onDoConnect); + } + break; + + case "WifiP2pManager:disconnect": + { + let address = msg.data; + + aDomMsgResponder.disconnect(address, function(success) { + returnMessage(aMessage.name, success, (success ? true : "ERROR"), msg); + }); + } + break; + + case "WifiP2pManager:setPairingConfirmation": + { + let result = msg.data; + aDomMsgResponder.setPairingConfirmation(result); + returnMessage(aMessage.name, true, true, msg); + } + break; + + case "WifiP2pManager:setDeviceName": + { + let newDeviceName = msg.data; + aDomMsgResponder.setDeviceName(newDeviceName, function(success) { + returnMessage(aMessage.name, success, (success ? true : "ERROR"), msg); + }); + } + break; + + default: + if (0 === aMessage.name.indexOf("WifiP2pManager:")) { + debug("DOM WifiP2pManager message not handled: " + aMessage.name); + } + } // End of switch. + } + }; +}; diff --git a/dom/wifi/WifiProxyService.cpp b/dom/wifi/WifiProxyService.cpp new file mode 100644 index 000000000..0ff5097af --- /dev/null +++ b/dom/wifi/WifiProxyService.cpp @@ -0,0 +1,357 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#include "WifiProxyService.h" +#include "nsServiceManagerUtils.h" +#include "mozilla/ModuleUtils.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/dom/ToJSValue.h" +#include "nsXULAppAPI.h" +#include "WifiUtils.h" + +#ifdef MOZ_TASK_TRACER +#include "GeckoTaskTracer.h" +using namespace mozilla::tasktracer; +#endif + +#define NS_WIFIPROXYSERVICE_CID \ + { 0xc6c9be7e, 0x744f, 0x4222, {0xb2, 0x03, 0xcd, 0x55, 0xdf, 0xc8, 0xbc, 0x12} } + +using namespace mozilla; +using namespace mozilla::dom; + +namespace mozilla { + +// The singleton Wifi service, to be used on the main thread. +static StaticRefPtr<WifiProxyService> gWifiProxyService; + +// The singleton supplicant class, that can be used on any thread. +static UniquePtr<WpaSupplicant> gWpaSupplicant; + +// Runnable used dispatch the WaitForEvent result on the main thread. +class WifiEventDispatcher : public Runnable +{ +public: + WifiEventDispatcher(const nsAString& aEvent, const nsACString& aInterface) + : mEvent(aEvent) + , mInterface(aInterface) + { + MOZ_ASSERT(!NS_IsMainThread()); + } + + NS_IMETHOD Run() override + { + MOZ_ASSERT(NS_IsMainThread()); + gWifiProxyService->DispatchWifiEvent(mEvent, mInterface); + return NS_OK; + } + +private: + nsString mEvent; + nsCString mInterface; +}; + +// Runnable used to call WaitForEvent on the event thread. +class EventRunnable : public Runnable +{ +public: + EventRunnable(const nsACString& aInterface) + : mInterface(aInterface) + { + MOZ_ASSERT(NS_IsMainThread()); + } + + NS_IMETHOD Run() override + { + MOZ_ASSERT(!NS_IsMainThread()); + nsAutoString event; + gWpaSupplicant->WaitForEvent(event, mInterface); + if (!event.IsEmpty()) { +#ifdef MOZ_TASK_TRACER + // Make wifi initialization events to be the source events of TaskTracer, + // and originate the rest correlation tasks from here. + AutoSourceEvent taskTracerEvent(SourceEventType::Wifi); + AddLabel("%s %s", mInterface.get(), NS_ConvertUTF16toUTF8(event).get()); +#endif + nsCOMPtr<nsIRunnable> runnable = new WifiEventDispatcher(event, mInterface); + NS_DispatchToMainThread(runnable); + } + return NS_OK; + } + +private: + nsCString mInterface; +}; + +// Runnable used dispatch the Command result on the main thread. +class WifiResultDispatcher : public Runnable +{ +public: + WifiResultDispatcher(WifiResultOptions& aResult, const nsACString& aInterface) + : mResult(aResult) + , mInterface(aInterface) + { + MOZ_ASSERT(!NS_IsMainThread()); + } + + NS_IMETHOD Run() override + { + MOZ_ASSERT(NS_IsMainThread()); + gWifiProxyService->DispatchWifiResult(mResult, mInterface); + return NS_OK; + } + +private: + WifiResultOptions mResult; + nsCString mInterface; +}; + +// Runnable used to call SendCommand on the control thread. +class ControlRunnable : public Runnable +{ +public: + ControlRunnable(CommandOptions aOptions, const nsACString& aInterface) + : mOptions(aOptions) + , mInterface(aInterface) + { + MOZ_ASSERT(NS_IsMainThread()); + } + + NS_IMETHOD Run() override + { + WifiResultOptions result; + if (gWpaSupplicant->ExecuteCommand(mOptions, result, mInterface)) { + nsCOMPtr<nsIRunnable> runnable = new WifiResultDispatcher(result, mInterface); + NS_DispatchToMainThread(runnable); + } + return NS_OK; + } +private: + CommandOptions mOptions; + nsCString mInterface; +}; + +NS_IMPL_ISUPPORTS(WifiProxyService, nsIWifiProxyService) + +WifiProxyService::WifiProxyService() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!gWifiProxyService); +} + +WifiProxyService::~WifiProxyService() +{ + MOZ_ASSERT(!gWifiProxyService); +} + +already_AddRefed<WifiProxyService> +WifiProxyService::FactoryCreate() +{ + if (!XRE_IsParentProcess()) { + return nullptr; + } + + MOZ_ASSERT(NS_IsMainThread()); + + if (!gWifiProxyService) { + gWifiProxyService = new WifiProxyService(); + ClearOnShutdown(&gWifiProxyService); + + gWpaSupplicant = MakeUnique<WpaSupplicant>(); + ClearOnShutdown(&gWpaSupplicant); + } + + RefPtr<WifiProxyService> service = gWifiProxyService.get(); + return service.forget(); +} + +NS_IMETHODIMP +WifiProxyService::Start(nsIWifiEventListener* aListener, + const char ** aInterfaces, + uint32_t aNumOfInterfaces) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aListener); + +#if ANDROID_VERSION >= 19 + // KK changes the way mux'ing/demux'ing different supplicant interfaces + // (e.g. wlan0/p2p0) from multi-sockets to single socket embedded with + // prefixed interface name (e.g. IFNAME=wlan0 xxxxxx). Therefore, we use + // the first given interface as the global interface for KK. + aNumOfInterfaces = 1; +#endif + + nsresult rv; + + // Since EventRunnable runs in the manner of blocking, we have to + // spin a thread for each interface. + // (See the WpaSupplicant::WaitForEvent) + mEventThreadList.SetLength(aNumOfInterfaces); + for (uint32_t i = 0; i < aNumOfInterfaces; i++) { + mEventThreadList[i].mInterface = aInterfaces[i]; + rv = NS_NewThread(getter_AddRefs(mEventThreadList[i].mThread)); + if (NS_FAILED(rv)) { + NS_WARNING("Can't create wifi event thread"); + Shutdown(); + return NS_ERROR_FAILURE; + } + } + + rv = NS_NewThread(getter_AddRefs(mControlThread)); + if (NS_FAILED(rv)) { + NS_WARNING("Can't create wifi control thread"); + Shutdown(); + return NS_ERROR_FAILURE; + } + + mListener = aListener; + + return NS_OK; +} + +NS_IMETHODIMP +WifiProxyService::Shutdown() +{ + MOZ_ASSERT(NS_IsMainThread()); + for (size_t i = 0; i < mEventThreadList.Length(); i++) { + if (mEventThreadList[i].mThread) { + mEventThreadList[i].mThread->Shutdown(); + mEventThreadList[i].mThread = nullptr; + } + } + + mEventThreadList.Clear(); + + if (mControlThread) { + mControlThread->Shutdown(); + mControlThread = nullptr; + } + + mListener = nullptr; + + return NS_OK; +} + +NS_IMETHODIMP +WifiProxyService::SendCommand(JS::Handle<JS::Value> aOptions, + const nsACString& aInterface, + JSContext* aCx) +{ + MOZ_ASSERT(NS_IsMainThread()); + WifiCommandOptions options; + + if (!options.Init(aCx, aOptions)) { + NS_WARNING("Bad dictionary passed to WifiProxyService::SendCommand"); + return NS_ERROR_FAILURE; + } + + if (!mControlThread) { + return NS_ERROR_FAILURE; + } + + // Dispatch the command to the control thread. + CommandOptions commandOptions(options); + nsCOMPtr<nsIRunnable> runnable = new ControlRunnable(commandOptions, aInterface); + mControlThread->Dispatch(runnable, nsIEventTarget::DISPATCH_NORMAL); + return NS_OK; +} + +NS_IMETHODIMP +WifiProxyService::WaitForEvent(const nsACString& aInterface) +{ + MOZ_ASSERT(NS_IsMainThread()); + +#if ANDROID_VERSION >= 19 + // We will only have one global interface for KK. + if (!mEventThreadList.IsEmpty()) { + nsCOMPtr<nsIRunnable> runnable = new EventRunnable(aInterface); + mEventThreadList[0].mThread->Dispatch(runnable, nsIEventTarget::DISPATCH_NORMAL); + return NS_OK; + } +#else + // Dispatch to the event thread which has the given interface name + for (size_t i = 0; i < mEventThreadList.Length(); i++) { + if (mEventThreadList[i].mInterface.Equals(aInterface)) { + nsCOMPtr<nsIRunnable> runnable = new EventRunnable(aInterface); + mEventThreadList[i].mThread->Dispatch(runnable, nsIEventTarget::DISPATCH_NORMAL); + return NS_OK; + } + } +#endif + + return NS_ERROR_FAILURE; +} + +void +WifiProxyService::DispatchWifiResult(const WifiResultOptions& aOptions, const nsACString& aInterface) +{ + MOZ_ASSERT(NS_IsMainThread()); + + mozilla::AutoSafeJSContext cx; + JS::Rooted<JS::Value> val(cx); + + if (!ToJSValue(cx, aOptions, &val)) { + return; + } + + if (mListener) { + // Call the listener with a JS value. + mListener->OnCommand(val, aInterface); + } +} + +void +WifiProxyService::DispatchWifiEvent(const nsAString& aEvent, const nsACString& aInterface) +{ + MOZ_ASSERT(NS_IsMainThread()); + +#if ANDROID_VERSION < 19 + mListener->OnWaitEvent(aEvent, aInterface); +#else + // The interface might be embedded in the event string such as + // "IFNAME=wlan0 CTRL-EVENT-BSS-ADDED 65 3c:94:d5:7c:11:8b". + // Parse the interface name from the event string and use p2p0 + // as the default interface if "IFNAME" is not found. + nsAutoString event; + nsAutoString embeddedInterface(NS_LITERAL_STRING("p2p0")); + if (StringBeginsWith(aEvent, NS_LITERAL_STRING("IFNAME"))) { + int32_t ifnameFrom = aEvent.FindChar('=') + 1; + int32_t ifnameTo = aEvent.FindChar(' ') - 1; + embeddedInterface = Substring(aEvent, ifnameFrom, ifnameTo - ifnameFrom + 1); + event = Substring(aEvent, aEvent.FindChar(' ') + 1); + } + else { + event = aEvent; + } + mListener->OnWaitEvent(event, NS_ConvertUTF16toUTF8(embeddedInterface)); +#endif +} + +NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(WifiProxyService, + WifiProxyService::FactoryCreate) + +NS_DEFINE_NAMED_CID(NS_WIFIPROXYSERVICE_CID); + +static const mozilla::Module::CIDEntry kWifiProxyServiceCIDs[] = { + { &kNS_WIFIPROXYSERVICE_CID, false, nullptr, WifiProxyServiceConstructor }, + { nullptr } +}; + +static const mozilla::Module::ContractIDEntry kWifiProxyServiceContracts[] = { + { "@mozilla.org/wifi/service;1", &kNS_WIFIPROXYSERVICE_CID }, + { nullptr } +}; + +static const mozilla::Module kWifiProxyServiceModule = { + mozilla::Module::kVersion, + kWifiProxyServiceCIDs, + kWifiProxyServiceContracts, + nullptr +}; + +} // namespace mozilla + +NSMODULE_DEFN(WifiProxyServiceModule) = &kWifiProxyServiceModule; diff --git a/dom/wifi/WifiProxyService.h b/dom/wifi/WifiProxyService.h new file mode 100644 index 000000000..406be47de --- /dev/null +++ b/dom/wifi/WifiProxyService.h @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef WifiProxyService_h +#define WifiProxyService_h + +#include "nsIWifiService.h" +#include "nsCOMPtr.h" +#include "nsThread.h" +#include "mozilla/dom/WifiOptionsBinding.h" +#include "nsTArray.h" + +namespace mozilla { + +class WifiProxyService final : public nsIWifiProxyService +{ +private: + struct EventThreadListEntry + { + nsCOMPtr<nsIThread> mThread; + nsCString mInterface; + }; + +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIWIFIPROXYSERVICE + + static already_AddRefed<WifiProxyService> + FactoryCreate(); + + void DispatchWifiEvent(const nsAString& aEvent, const nsACString& aInterface); + void DispatchWifiResult(const mozilla::dom::WifiResultOptions& aOptions, + const nsACString& aInterface); + +private: + WifiProxyService(); + ~WifiProxyService(); + + nsTArray<EventThreadListEntry> mEventThreadList; + nsCOMPtr<nsIThread> mControlThread; + nsCOMPtr<nsIWifiEventListener> mListener; +}; + +} // namespace mozilla + +#endif // WifiProxyService_h diff --git a/dom/wifi/WifiUtils.cpp b/dom/wifi/WifiUtils.cpp new file mode 100644 index 000000000..2526c9ea4 --- /dev/null +++ b/dom/wifi/WifiUtils.cpp @@ -0,0 +1,521 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#include "WifiUtils.h" +#include <dlfcn.h> +#include <errno.h> +#include <cutils/properties.h> +#include "prinit.h" +#include "mozilla/Sprintf.h" +#include "js/CharacterEncoding.h" + +using namespace mozilla::dom; + +#define BUFFER_SIZE 4096 +#define COMMAND_SIZE 256 + +// Intentionally not trying to dlclose() this handle. That's playing +// Russian roulette with security bugs. +static void* sWifiLib; +static PRCallOnceType sInitWifiLib; + +static PRStatus +InitWifiLib() +{ + sWifiLib = dlopen("/system/lib/libhardware_legacy.so", RTLD_LAZY); + // We might fail to open the hardware lib. That's OK. + return PR_SUCCESS; +} + +static void* +GetSharedLibrary() +{ + PR_CallOnce(&sInitWifiLib, InitWifiLib); + return sWifiLib; +} + +static bool +GetWifiP2pSupported() +{ + char propP2pSupported[PROPERTY_VALUE_MAX]; + property_get("ro.moz.wifi.p2p_supported", propP2pSupported, "0"); + return (0 == strcmp(propP2pSupported, "1")); +} + +static int +hex2num(char c) +{ + if (c >= '0' && c <= '9') + return c - '0'; + if (c >= 'a' && c <= 'f') + return c - 'a' + 10; + if (c >= 'A' && c <= 'F') + return c - 'A' + 10; + return -1; +} + +static int +hex2byte(const char* hex) +{ + int a, b; + a = hex2num(*hex++); + if (a < 0) + return -1; + b = hex2num(*hex++); + if (b < 0) + return -1; + return (a << 4) | b; +} + +// This function is equivalent to printf_decode() at src/utils/common.c in +// the supplicant. + +static uint32_t +convertToBytes(char* buf, uint32_t maxlen, const char* str) +{ + const char *pos = str; + uint32_t len = 0; + int val; + + while (*pos) { + if (len == maxlen) + break; + switch (*pos) { + case '\\': + pos++; + switch (*pos) { + case '\\': + buf[len++] = '\\'; + pos++; + break; + case '"': + buf[len++] = '"'; + pos++; + break; + case 'n': + buf[len++] = '\n'; + pos++; + break; + case 'r': + buf[len++] = '\r'; + pos++; + break; + case 't': + buf[len++] = '\t'; + pos++; + break; + case 'e': + buf[len++] = '\e'; + pos++; + break; + case 'x': + pos++; + val = hex2byte(pos); + if (val < 0) { + val = hex2num(*pos); + if (val < 0) + break; + buf[len++] = val; + pos++; + } else { + buf[len++] = val; + pos += 2; + } + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + val = *pos++ - '0'; + if (*pos >= '0' && *pos <= '7') + val = val * 8 + (*pos++ - '0'); + if (*pos >= '0' && *pos <= '7') + val = val * 8 + (*pos++ - '0'); + buf[len++] = val; + break; + default: + break; + } + break; + default: + buf[len++] = *pos++; + break; + } + } + return len; +} + +// This is the same algorithm as in InflateUTF8StringToBuffer with Copy and +// while ignoring invalids. +// https://mxr.mozilla.org/mozilla-central/source/js/src/vm/CharacterEncoding.cpp#231 + +static const uint32_t REPLACE_UTF8 = 0xFFFD; + +static void +LossyConvertUTF8toUTF16(const char* aInput, uint32_t aLength, nsAString& aOut) +{ + JS::UTF8Chars src(aInput, aLength); + + char16_t dst[aLength]; // Allocating for worst case. + + // Count how many char16_t characters are needed in the inflated string. + // |i| is the index into |src|, and |j| is the the index into |dst|. + size_t srclen = src.length(); + uint32_t j = 0; + for (uint32_t i = 0; i < srclen; i++, j++) { + uint32_t v = uint32_t(src[i]); + if (v == uint32_t('\0') && i < srclen - 1) { + // If the leading byte is '\0' and it's not the last byte, + // just ignore it to prevent from being truncated. This could + // be caused by |convertToBytes| (e.g. \x00 would be converted to '\0') + j--; + continue; + } + if (!(v & 0x80)) { + // ASCII code unit. Simple copy. + dst[j] = char16_t(v); + } else { + // Non-ASCII code unit. Determine its length in bytes (n). + uint32_t n = 1; + while (v & (0x80 >> n)) + n++; + + #define INVALID(report, arg, n2) \ + do { \ + n = n2; \ + goto invalidMultiByteCodeUnit; \ + } while (0) + + // Check the leading byte. + if (n < 2 || n > 4) + INVALID(ReportInvalidCharacter, i, 1); + + // Check that |src| is large enough to hold an n-byte code unit. + if (i + n > srclen) + INVALID(ReportBufferTooSmall, /* dummy = */ 0, 1); + + // Check the second byte. From Unicode Standard v6.2, Table 3-7 + // Well-Formed UTF-8 Byte Sequences. + if ((v == 0xE0 && ((uint8_t)src[i + 1] & 0xE0) != 0xA0) || // E0 A0~BF + (v == 0xED && ((uint8_t)src[i + 1] & 0xE0) != 0x80) || // ED 80~9F + (v == 0xF0 && ((uint8_t)src[i + 1] & 0xF0) == 0x80) || // F0 90~BF + (v == 0xF4 && ((uint8_t)src[i + 1] & 0xF0) != 0x80)) // F4 80~8F + { + INVALID(ReportInvalidCharacter, i, 1); + } + + // Check the continuation bytes. + for (uint32_t m = 1; m < n; m++) + if ((src[i + m] & 0xC0) != 0x80) + INVALID(ReportInvalidCharacter, i, m); + + // Determine the code unit's length in char16_t units and act accordingly. + v = JS::Utf8ToOneUcs4Char((uint8_t *)&src[i], n); + if (v < 0x10000) { + // The n-byte UTF8 code unit will fit in a single char16_t. + dst[j] = char16_t(v); + } else { + v -= 0x10000; + if (v <= 0xFFFFF) { + // The n-byte UTF8 code unit will fit in two char16_t units. + dst[j] = char16_t((v >> 10) + 0xD800); + j++; + dst[j] = char16_t((v & 0x3FF) + 0xDC00); + } else { + // The n-byte UTF8 code unit won't fit in two char16_t units. + INVALID(ReportTooBigCharacter, v, 1); + } + } + + invalidMultiByteCodeUnit: + // Move i to the last byte of the multi-byte code unit; the loop + // header will do the final i++ to move to the start of the next + // code unit. + i += n - 1; + } + } + + dst[j] = 0; + aOut = dst; +} + +// Helper to check we have loaded the hardware shared library. +#define CHECK_HWLIB(ret) \ + void* hwLib = GetSharedLibrary(); \ + if (!hwLib) { \ + NS_WARNING("No /system/lib/libhardware_legacy.so"); \ + return ret; \ + } + +#define DEFAULT_IMPL(name, ret, args...) \ + DEFINE_DLFUNC(name, ret, args...) \ + ret do_##name(args) { \ + USE_DLFUNC(name) \ + return name(args); \ + } + +// ICS implementation. +class ICSWpaSupplicantImpl : public WpaSupplicantImpl +{ +public: + DEFAULT_IMPL(wifi_load_driver, int32_t, ) + DEFAULT_IMPL(wifi_unload_driver, int32_t, ) + + DEFINE_DLFUNC(wifi_wait_for_event, int32_t, char*, size_t) + int32_t do_wifi_wait_for_event(const char *iface, char *buf, size_t len) { + USE_DLFUNC(wifi_wait_for_event) + return wifi_wait_for_event(buf, len); + } + + DEFINE_DLFUNC(wifi_command, int32_t, const char*, char*, size_t*) + int32_t do_wifi_command(const char* iface, const char* cmd, char* buf, size_t* len) { + USE_DLFUNC(wifi_command) + return wifi_command(cmd, buf, len); + } + + DEFINE_DLFUNC(wifi_start_supplicant, int32_t, ) + int32_t do_wifi_start_supplicant(int32_t) { + USE_DLFUNC(wifi_start_supplicant) + return wifi_start_supplicant(); + } + + DEFINE_DLFUNC(wifi_stop_supplicant, int32_t) + int32_t do_wifi_stop_supplicant(int32_t) { + USE_DLFUNC(wifi_stop_supplicant) + return wifi_stop_supplicant(); + } + + DEFINE_DLFUNC(wifi_connect_to_supplicant, int32_t, ) + int32_t do_wifi_connect_to_supplicant(const char* iface) { + USE_DLFUNC(wifi_connect_to_supplicant) + return wifi_connect_to_supplicant(); + } + + DEFINE_DLFUNC(wifi_close_supplicant_connection, void, ) + void do_wifi_close_supplicant_connection(const char* iface) { + USE_DLFUNC(wifi_close_supplicant_connection) + return wifi_close_supplicant_connection(); + } +}; + +// JB implementation. +// We only redefine the methods that have a different signature than on ICS. +class JBWpaSupplicantImpl : public ICSWpaSupplicantImpl +{ +public: + DEFINE_DLFUNC(wifi_wait_for_event, int32_t, const char*, char*, size_t) + int32_t do_wifi_wait_for_event(const char* iface, char* buf, size_t len) { + USE_DLFUNC(wifi_wait_for_event) + return wifi_wait_for_event(iface, buf, len); + } + + DEFINE_DLFUNC(wifi_command, int32_t, const char*, const char*, char*, size_t*) + int32_t do_wifi_command(const char* iface, const char* cmd, char* buf, size_t* len) { + USE_DLFUNC(wifi_command) + return wifi_command(iface, cmd, buf, len); + } + + DEFINE_DLFUNC(wifi_start_supplicant, int32_t, int32_t) + int32_t do_wifi_start_supplicant(int32_t arg) { + USE_DLFUNC(wifi_start_supplicant) + return wifi_start_supplicant(arg); + } + + DEFINE_DLFUNC(wifi_stop_supplicant, int32_t, int32_t) + int32_t do_wifi_stop_supplicant(int32_t arg) { + USE_DLFUNC(wifi_stop_supplicant) + return wifi_stop_supplicant(arg); + } + + DEFINE_DLFUNC(wifi_connect_to_supplicant, int32_t, const char*) + int32_t do_wifi_connect_to_supplicant(const char* iface) { + USE_DLFUNC(wifi_connect_to_supplicant) + return wifi_connect_to_supplicant(iface); + } + + DEFINE_DLFUNC(wifi_close_supplicant_connection, void, const char*) + void do_wifi_close_supplicant_connection(const char* iface) { + USE_DLFUNC(wifi_close_supplicant_connection) + wifi_close_supplicant_connection(iface); + } +}; + +// KK implementation. +// We only redefine the methods that have a different signature than on ICS. +class KKWpaSupplicantImpl : public ICSWpaSupplicantImpl +{ +public: + DEFINE_DLFUNC(wifi_start_supplicant, int32_t, int32_t) + int32_t do_wifi_start_supplicant(int32_t arg) { + USE_DLFUNC(wifi_start_supplicant) + return wifi_start_supplicant(arg); + } + + DEFINE_DLFUNC(wifi_stop_supplicant, int32_t, int32_t) + int32_t do_wifi_stop_supplicant(int32_t arg) { + USE_DLFUNC(wifi_stop_supplicant) + return wifi_stop_supplicant(arg); + } + + DEFINE_DLFUNC(wifi_command, int32_t, const char*, char*, size_t*) + int32_t do_wifi_command(const char* iface, const char* cmd, char* buf, size_t* len) { + char command[COMMAND_SIZE]; + if (!strcmp(iface, "p2p0")) { + // Commands for p2p0 interface don't need prefix + SprintfLiteral(command, "%s", cmd); + } + else { + SprintfLiteral(command, "IFNAME=%s %s", iface, cmd); + } + USE_DLFUNC(wifi_command) + return wifi_command(command, buf, len); + } +}; + +// Concrete class to use to access the wpa supplicant. +WpaSupplicant::WpaSupplicant() +{ + char propVersion[PROPERTY_VALUE_MAX]; + property_get("ro.build.version.sdk", propVersion, "0"); + mSdkVersion = strtol(propVersion, nullptr, 10); + + if (mSdkVersion < 16) { + mImpl = MakeUnique<ICSWpaSupplicantImpl>(); + } else if (mSdkVersion < 19) { + mImpl = MakeUnique<JBWpaSupplicantImpl>(); + } else { + mImpl = MakeUnique<KKWpaSupplicantImpl>(); + } + mWifiHotspotUtils = MakeUnique<WifiHotspotUtils>(); +}; + +void WpaSupplicant::WaitForEvent(nsAString& aEvent, const nsCString& aInterface) +{ + CHECK_HWLIB() + + char buffer[BUFFER_SIZE]; + int32_t ret = mImpl->do_wifi_wait_for_event(aInterface.get(), buffer, BUFFER_SIZE); + CheckBuffer(buffer, ret, aEvent); +} + +#define GET_CHAR(prop) NS_ConvertUTF16toUTF8(aOptions.prop).get() + +/** + * Make a subnet mask. + */ +uint32_t WpaSupplicant::MakeMask(uint32_t len) { + uint32_t mask = 0; + for (uint32_t i = 0; i < len; ++i) { + mask |= (0x80000000 >> i); + } + return ntohl(mask); +} + +bool WpaSupplicant::ExecuteCommand(CommandOptions aOptions, + WifiResultOptions& aResult, + const nsCString& aInterface) +{ + CHECK_HWLIB(false) + + if (!mWifiHotspotUtils->GetSharedLibrary()) { + return false; + } + + // Always correlate the opaque ids. + aResult.mId = aOptions.mId; + + if (aOptions.mCmd.EqualsLiteral("command")) { + size_t len = BUFFER_SIZE - 1; + char buffer[BUFFER_SIZE]; + NS_ConvertUTF16toUTF8 request(aOptions.mRequest); + aResult.mStatus = mImpl->do_wifi_command(aInterface.get(), request.get(), buffer, &len); + nsString value; + if (aResult.mStatus == 0) { + if (buffer[len - 1] == '\n') { // remove trailing new lines. + len--; + } + buffer[len] = '\0'; + CheckBuffer(buffer, len, value); + } + aResult.mReply = value; + } else if (aOptions.mCmd.EqualsLiteral("close_supplicant_connection")) { + mImpl->do_wifi_close_supplicant_connection(aInterface.get()); + } else if (aOptions.mCmd.EqualsLiteral("load_driver")) { + aResult.mStatus = mImpl->do_wifi_load_driver(); + } else if (aOptions.mCmd.EqualsLiteral("unload_driver")) { + aResult.mStatus = mImpl->do_wifi_unload_driver(); + } else if (aOptions.mCmd.EqualsLiteral("start_supplicant")) { + aResult.mStatus = mImpl->do_wifi_start_supplicant(GetWifiP2pSupported() ? 1 : 0); + } else if (aOptions.mCmd.EqualsLiteral("stop_supplicant")) { + aResult.mStatus = mImpl->do_wifi_stop_supplicant(0); + } else if (aOptions.mCmd.EqualsLiteral("connect_to_supplicant")) { + aResult.mStatus = mImpl->do_wifi_connect_to_supplicant(aInterface.get()); + } else if (aOptions.mCmd.EqualsLiteral("hostapd_command")) { + size_t len = BUFFER_SIZE - 1; + char buffer[BUFFER_SIZE]; + NS_ConvertUTF16toUTF8 request(aOptions.mRequest); + aResult.mStatus = mWifiHotspotUtils->do_wifi_hostapd_command(request.get(), + buffer, + &len); + nsString value; + if (aResult.mStatus == 0) { + if (buffer[len - 1] == '\n') { // remove trailing new lines. + len--; + } + buffer[len] = '\0'; + CheckBuffer(buffer, len, value); + } + aResult.mReply = value; + } else if (aOptions.mCmd.EqualsLiteral("hostapd_get_stations")) { + aResult.mStatus = mWifiHotspotUtils->do_wifi_hostapd_get_stations(); + } else if (aOptions.mCmd.EqualsLiteral("connect_to_hostapd")) { + aResult.mStatus = mWifiHotspotUtils->do_wifi_connect_to_hostapd(); + } else if (aOptions.mCmd.EqualsLiteral("close_hostapd_connection")) { + aResult.mStatus = mWifiHotspotUtils->do_wifi_close_hostapd_connection(); + + } else { + NS_WARNING("WpaSupplicant::ExecuteCommand : Unknown command"); + printf_stderr("WpaSupplicant::ExecuteCommand : Unknown command: %s", + NS_ConvertUTF16toUTF8(aOptions.mCmd).get()); + return false; + } + + return true; +} + +// Checks the buffer and do the utf processing. +void +WpaSupplicant::CheckBuffer(char* buffer, int32_t length, + nsAString& aEvent) +{ + if (length <= 0 || length >= (BUFFER_SIZE - 1)) { + NS_WARNING("WpaSupplicant::CheckBuffer: Invalid buffer length"); + return; + } + + if (mSdkVersion < 18) { + buffer[length] = 0; + LossyConvertUTF8toUTF16(buffer, length, aEvent); + return; + } + + // After Android JB4.3, the SSIDs have been converted into printable form. + // In most of cases, SSIDs do not use unprintable characters, but IEEE 802.11 + // standard does not limit the used character set, so anything could be used + // in an SSID. Convert it to raw data form here. + char bytesBuffer[BUFFER_SIZE]; + uint32_t bytes = convertToBytes(bytesBuffer, length, buffer); + if (bytes <= 0 || bytes >= BUFFER_SIZE) { + NS_WARNING("WpaSupplicant::CheckBuffer: Invalid bytesbuffer length"); + return; + } + bytesBuffer[bytes] = 0; + LossyConvertUTF8toUTF16(bytesBuffer, bytes, aEvent); +} diff --git a/dom/wifi/WifiUtils.h b/dom/wifi/WifiUtils.h new file mode 100644 index 000000000..a83ba9c15 --- /dev/null +++ b/dom/wifi/WifiUtils.h @@ -0,0 +1,107 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +/** + * Abstraction on top of the wifi support from libhardware_legacy that we + * use to talk to the wpa_supplicant. + */ + +#ifndef WifiUtils_h +#define WifiUtils_h + +#include "nsString.h" +#include "mozilla/dom/WifiOptionsBinding.h" +#include "mozilla/UniquePtr.h" +#include "WifiHotspotUtils.h" + +// Needed to add a copy constructor to WifiCommandOptions. +struct CommandOptions +{ +public: + CommandOptions(const mozilla::dom::WifiCommandOptions& aOther) { + +#define COPY_OPT_FIELD(prop, defaultValue) \ + if (aOther.prop.WasPassed()) { \ + prop = aOther.prop.Value(); \ + } else { \ + prop = defaultValue; \ + } + +#define COPY_FIELD(prop) prop = aOther.prop; + COPY_FIELD(mId) + COPY_FIELD(mCmd) + COPY_OPT_FIELD(mRequest, EmptyString()) + +#undef COPY_OPT_FIELD +#undef COPY_FIELD + } + + // All the fields, not Optional<> anymore to get copy constructors. + nsString mCmd; + int32_t mId; + nsString mRequest; +}; + +// Abstract class that exposes libhardware_legacy functions we need for +// wifi management. +// We use the ICS signatures here since they are likely more future-proof. +class WpaSupplicantImpl +{ +public: + // Suppress warning from |UniquePtr| + virtual ~WpaSupplicantImpl() {} + + virtual int32_t + do_wifi_wait_for_event(const char *iface, char *buf, size_t len) = 0; // KK == ICS != JB + + virtual int32_t + do_wifi_command(const char* iface, const char* cmd, char* buff, size_t* len) = 0; // KK == ICS != JB + + virtual int32_t + do_wifi_load_driver() = 0; + + virtual int32_t + do_wifi_unload_driver() = 0; + + virtual int32_t + do_wifi_start_supplicant(int32_t) = 0; // ICS != JB == KK + + virtual int32_t + do_wifi_stop_supplicant(int32_t) = 0; //ICS != JB == KK + + virtual int32_t + do_wifi_connect_to_supplicant(const char* iface) = 0; // KK == ICS != JB + + virtual void + do_wifi_close_supplicant_connection(const char* iface) = 0; // KK == ICS != JB +}; + +// Concrete class to use to access the wpa supplicant. +class WpaSupplicant final +{ +public: + WpaSupplicant(); + + // Use nsCString as the type of aInterface to guarantee it's + // null-terminated so that we can pass it to c API without + // conversion + void WaitForEvent(nsAString& aEvent, const nsCString& aInterface); + bool ExecuteCommand(CommandOptions aOptions, + mozilla::dom::WifiResultOptions& result, + const nsCString& aInterface); + +private: + UniquePtr<WpaSupplicantImpl> mImpl; + UniquePtr<WifiHotspotUtils> mWifiHotspotUtils; + + uint32_t mSdkVersion; + +protected: + void CheckBuffer(char* buffer, int32_t length, nsAString& aEvent); + uint32_t MakeMask(uint32_t len); +}; + +#endif // WifiUtils_h diff --git a/dom/wifi/WifiWorker.h b/dom/wifi/WifiWorker.h new file mode 100644 index 000000000..2cd89c3e7 --- /dev/null +++ b/dom/wifi/WifiWorker.h @@ -0,0 +1,9 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#define NS_WIFIWORKER_CID \ +{ 0xA14E8977, 0xD259, 0x433A, \ + { 0xA8, 0x8D, 0x58, 0xDD, 0x44, 0x65, 0x7E, 0x5B } } diff --git a/dom/wifi/WifiWorker.js b/dom/wifi/WifiWorker.js new file mode 100644 index 000000000..243ba8b97 --- /dev/null +++ b/dom/wifi/WifiWorker.js @@ -0,0 +1,3928 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/systemlibs.js"); +Cu.import("resource://gre/modules/FileUtils.jsm"); +Cu.import("resource://gre/modules/WifiCommand.jsm"); +Cu.import("resource://gre/modules/WifiNetUtil.jsm"); +Cu.import("resource://gre/modules/WifiP2pManager.jsm"); +Cu.import("resource://gre/modules/WifiP2pWorkerObserver.jsm"); + +var DEBUG = false; // set to true to show debug messages. + +const WIFIWORKER_CONTRACTID = "@mozilla.org/wifi/worker;1"; +const WIFIWORKER_CID = Components.ID("{a14e8977-d259-433a-a88d-58dd44657e5b}"); + +const WIFIWORKER_WORKER = "resource://gre/modules/wifi_worker.js"; + +const kMozSettingsChangedObserverTopic = "mozsettings-changed"; + +const MAX_RETRIES_ON_AUTHENTICATION_FAILURE = 2; +const MAX_SUPPLICANT_LOOP_ITERATIONS = 4; +const MAX_RETRIES_ON_DHCP_FAILURE = 2; + +// Settings DB path for wifi +const SETTINGS_WIFI_ENABLED = "wifi.enabled"; +const SETTINGS_WIFI_DEBUG_ENABLED = "wifi.debugging.enabled"; +// Settings DB path for Wifi tethering. +const SETTINGS_WIFI_TETHERING_ENABLED = "tethering.wifi.enabled"; +const SETTINGS_WIFI_SSID = "tethering.wifi.ssid"; +const SETTINGS_WIFI_SECURITY_TYPE = "tethering.wifi.security.type"; +const SETTINGS_WIFI_SECURITY_PASSWORD = "tethering.wifi.security.password"; +const SETTINGS_WIFI_IP = "tethering.wifi.ip"; +const SETTINGS_WIFI_PREFIX = "tethering.wifi.prefix"; +const SETTINGS_WIFI_DHCPSERVER_STARTIP = "tethering.wifi.dhcpserver.startip"; +const SETTINGS_WIFI_DHCPSERVER_ENDIP = "tethering.wifi.dhcpserver.endip"; +const SETTINGS_WIFI_DNS1 = "tethering.wifi.dns1"; +const SETTINGS_WIFI_DNS2 = "tethering.wifi.dns2"; + +// Settings DB path for USB tethering. +const SETTINGS_USB_DHCPSERVER_STARTIP = "tethering.usb.dhcpserver.startip"; +const SETTINGS_USB_DHCPSERVER_ENDIP = "tethering.usb.dhcpserver.endip"; + +// Default value for WIFI tethering. +const DEFAULT_WIFI_IP = "192.168.1.1"; +const DEFAULT_WIFI_PREFIX = "24"; +const DEFAULT_WIFI_DHCPSERVER_STARTIP = "192.168.1.10"; +const DEFAULT_WIFI_DHCPSERVER_ENDIP = "192.168.1.30"; +const DEFAULT_WIFI_SSID = "FirefoxHotspot"; +const DEFAULT_WIFI_SECURITY_TYPE = "open"; +const DEFAULT_WIFI_SECURITY_PASSWORD = "1234567890"; +const DEFAULT_DNS1 = "8.8.8.8"; +const DEFAULT_DNS2 = "8.8.4.4"; + +// Default value for USB tethering. +const DEFAULT_USB_DHCPSERVER_STARTIP = "192.168.0.10"; +const DEFAULT_USB_DHCPSERVER_ENDIP = "192.168.0.30"; + +const WIFI_FIRMWARE_AP = "AP"; +const WIFI_FIRMWARE_STATION = "STA"; +const WIFI_SECURITY_TYPE_NONE = "open"; +const WIFI_SECURITY_TYPE_WPA_PSK = "wpa-psk"; +const WIFI_SECURITY_TYPE_WPA2_PSK = "wpa2-psk"; + +const NETWORK_INTERFACE_UP = "up"; +const NETWORK_INTERFACE_DOWN = "down"; + +const DEFAULT_WLAN_INTERFACE = "wlan0"; + +const DRIVER_READY_WAIT = 2000; + +const SUPP_PROP = "init.svc.wpa_supplicant"; +const WPA_SUPPLICANT = "wpa_supplicant"; +const DHCP_PROP = "init.svc.dhcpcd"; +const DHCP = "dhcpcd"; + +const MODE_ESS = 0; +const MODE_IBSS = 1; + +XPCOMUtils.defineLazyServiceGetter(this, "gNetworkManager", + "@mozilla.org/network/manager;1", + "nsINetworkManager"); + +XPCOMUtils.defineLazyServiceGetter(this, "gNetworkService", + "@mozilla.org/network/service;1", + "nsINetworkService"); + +XPCOMUtils.defineLazyServiceGetter(this, "gSettingsService", + "@mozilla.org/settingsService;1", + "nsISettingsService"); + +XPCOMUtils.defineLazyServiceGetter(this, "gTetheringService", + "@mozilla.org/tethering/service;1", + "nsITetheringService"); + +// A note about errors and error handling in this file: +// The libraries that we use in this file are intended for C code. For +// C code, it is natural to return -1 for errors and 0 for success. +// Therefore, the code that interacts directly with the worker uses this +// convention (note: command functions do get boolean results since the +// command always succeeds and we do a string/boolean check for the +// expected results). +var WifiManager = (function() { + var manager = {}; + + function getStartupPrefs() { + return { + sdkVersion: parseInt(libcutils.property_get("ro.build.version.sdk"), 10), + unloadDriverEnabled: libcutils.property_get("ro.moz.wifi.unloaddriver") === "1", + schedScanRecovery: libcutils.property_get("ro.moz.wifi.sched_scan_recover") === "false" ? false : true, + driverDelay: libcutils.property_get("ro.moz.wifi.driverDelay"), + p2pSupported: libcutils.property_get("ro.moz.wifi.p2p_supported") === "1", + eapSimSupported: libcutils.property_get("ro.moz.wifi.eapsim_supported") === "1", + ibssSupported: libcutils.property_get("ro.moz.wifi.ibss_supported", "true") === "true", + ifname: libcutils.property_get("wifi.interface") + }; + } + + let {sdkVersion, unloadDriverEnabled, schedScanRecovery, + driverDelay, p2pSupported, eapSimSupported, ibssSupported, ifname} = getStartupPrefs(); + + let capabilities = { + security: ["OPEN", "WEP", "WPA-PSK", "WPA-EAP"], + eapMethod: ["PEAP", "TTLS", "TLS"], + eapPhase2: ["MSCHAPV2"], + certificate: ["SERVER"], + mode: [MODE_ESS] + }; + if (eapSimSupported) { + capabilities.eapMethod.unshift("SIM"); + } + if (ibssSupported) { + capabilities.mode.push(MODE_IBSS); + } + + let wifiListener = { + onWaitEvent: function(event, iface) { + if (manager.ifname === iface && handleEvent(event)) { + waitForEvent(iface); + } else if (p2pSupported) { + // Please refer to + // http://androidxref.com/4.4.2_r1/xref/frameworks/base/wifi/java/android/net/wifi/WifiMonitor.java#519 + // for interface event mux/demux rules. In short words, both + // 'p2p0' and 'p2p-' should go to Wifi P2P state machine. + if (WifiP2pManager.INTERFACE_NAME === iface || -1 !== iface.indexOf('p2p-')) { + // If the connection is closed, wifi.c::wifi_wait_for_event() + // will still return 'CTRL-EVENT-TERMINATING - connection closed' + // rather than blocking. So when we see this special event string, + // just return immediately. + const TERMINATED_EVENT = 'CTRL-EVENT-TERMINATING - connection closed'; + if (-1 !== event.indexOf(TERMINATED_EVENT)) { + return; + } + p2pManager.handleEvent(event); + waitForEvent(iface); + } + } + }, + + onCommand: function(event, iface) { + onmessageresult(event, iface); + } + } + + manager.ifname = ifname; + manager.connectToSupplicant = false; + // Emulator build runs to here. + // The debug() should only be used after WifiManager. + if (!ifname) { + manager.ifname = DEFAULT_WLAN_INTERFACE; + } + manager.schedScanRecovery = schedScanRecovery; + manager.driverDelay = driverDelay ? parseInt(driverDelay, 10) : DRIVER_READY_WAIT; + + // Regular Wifi stuff. + var netUtil = WifiNetUtil(controlMessage); + var wifiCommand = WifiCommand(controlMessage, manager.ifname, sdkVersion); + + // Wifi P2P stuff + var p2pManager; + if (p2pSupported) { + let p2pCommand = WifiCommand(controlMessage, WifiP2pManager.INTERFACE_NAME, sdkVersion); + p2pManager = WifiP2pManager(p2pCommand, netUtil); + } + + let wifiService = Cc["@mozilla.org/wifi/service;1"]; + if (wifiService) { + wifiService = wifiService.getService(Ci.nsIWifiProxyService); + let interfaces = [manager.ifname]; + if (p2pSupported) { + interfaces.push(WifiP2pManager.INTERFACE_NAME); + } + wifiService.start(wifiListener, interfaces, interfaces.length); + } else { + debug("No wifi service component available!"); + } + + // Callbacks to invoke when a reply arrives from the wifi service. + var controlCallbacks = Object.create(null); + var idgen = 0; + + function controlMessage(obj, callback) { + var id = idgen++; + obj.id = id; + if (callback) { + controlCallbacks[id] = callback; + } + wifiService.sendCommand(obj, obj.iface); + } + + let onmessageresult = function(data, iface) { + var id = data.id; + var callback = controlCallbacks[id]; + if (callback) { + callback(data); + delete controlCallbacks[id]; + } + } + + // Polling the status worker + var recvErrors = 0; + + function waitForEvent(iface) { + wifiService.waitForEvent(iface); + } + + // Commands to the control worker. + + var driverLoaded = false; + + function loadDriver(callback) { + if (driverLoaded) { + callback(0); + return; + } + + wifiCommand.loadDriver(function (status) { + driverLoaded = (status >= 0); + callback(status) + }); + } + + function unloadDriver(type, callback) { + if (!unloadDriverEnabled) { + // Unloading drivers is generally unnecessary and + // can trigger bugs in some drivers. + // On properly written drivers, bringing the interface + // down powers down the interface. + if (type === WIFI_FIRMWARE_STATION) { + notify("supplicantlost", { success: true }); + } + callback(0); + return; + } + + wifiCommand.unloadDriver(function(status) { + driverLoaded = (status < 0); + if (type === WIFI_FIRMWARE_STATION) { + notify("supplicantlost", { success: true }); + } + callback(status); + }); + } + + // A note about background scanning: + // Normally, background scanning shouldn't be necessary as wpa_supplicant + // has the capability to automatically schedule its own scans at appropriate + // intervals. However, with some drivers, this appears to get stuck after + // three scans, so we enable the driver's background scanning to work around + // that when we're not connected to any network. This ensures that we'll + // automatically reconnect to networks if one falls out of range. + var reEnableBackgroundScan = false; + + // NB: This is part of the internal API. + manager.backgroundScanEnabled = false; + function setBackgroundScan(enable, callback) { + var doEnable = (enable === "ON"); + if (doEnable === manager.backgroundScanEnabled) { + callback(false, true); + return; + } + + manager.backgroundScanEnabled = doEnable; + wifiCommand.setBackgroundScan(manager.backgroundScanEnabled, callback); + } + + var scanModeActive = false; + + function scan(forceActive, callback) { + if (forceActive && !scanModeActive) { + // Note: we ignore errors from doSetScanMode. + wifiCommand.doSetScanMode(true, function(ignore) { + setBackgroundScan("OFF", function(turned, ignore) { + reEnableBackgroundScan = turned; + manager.handlePreWifiScan(); + wifiCommand.scan(function(ok) { + wifiCommand.doSetScanMode(false, function(ignore) { + // The result of scanCommand is the result of the actual SCAN + // request. + callback(ok); + }); + }); + }); + }); + return; + } + manager.handlePreWifiScan(); + wifiCommand.scan(callback); + } + + var debugEnabled = false; + + function syncDebug() { + if (debugEnabled !== DEBUG) { + let wanted = DEBUG; + wifiCommand.setLogLevel(wanted ? "DEBUG" : "INFO", function(ok) { + if (ok) + debugEnabled = wanted; + }); + if (p2pSupported && p2pManager) { + p2pManager.setDebug(DEBUG); + } + } + } + + function getDebugEnabled(callback) { + wifiCommand.getLogLevel(function(level) { + if (level === null) { + debug("Unable to get wpa_supplicant's log level"); + callback(false); + return; + } + + var lines = level.split("\n"); + for (let i = 0; i < lines.length; ++i) { + let match = /Current level: (.*)/.exec(lines[i]); + if (match) { + debugEnabled = match[1].toLowerCase() === "debug"; + callback(true); + return; + } + } + + // If we're here, we didn't get the current level. + callback(false); + }); + } + + function setScanMode(setActive, callback) { + scanModeActive = setActive; + wifiCommand.doSetScanMode(setActive, callback); + } + + var httpProxyConfig = Object.create(null); + + /** + * Given a network, configure http proxy when using wifi. + * @param network A network object to update http proxy + * @param info Info should have following field: + * - httpProxyHost ip address of http proxy. + * - httpProxyPort port of http proxy, set 0 to use default port 8080. + * @param callback callback function. + */ + function configureHttpProxy(network, info, callback) { + if (!network) + return; + + let networkKey = getNetworkKey(network); + + if (!info || info.httpProxyHost === "") { + delete httpProxyConfig[networkKey]; + } else { + httpProxyConfig[networkKey] = network; + httpProxyConfig[networkKey].httpProxyHost = info.httpProxyHost; + httpProxyConfig[networkKey].httpProxyPort = info.httpProxyPort; + } + + callback(true); + } + + function getHttpProxyNetwork(network) { + if (!network) + return null; + + let networkKey = getNetworkKey(network); + return httpProxyConfig[networkKey]; + } + + function setHttpProxy(network) { + if (!network) + return; + + // If we got here, arg network must be the currentNetwork, so we just update + // WifiNetworkInterface correspondingly and notify NetworkManager. + WifiNetworkInterface.httpProxyHost = network.httpProxyHost; + WifiNetworkInterface.httpProxyPort = network.httpProxyPort; + + if (WifiNetworkInterface.info.state == + Ci.nsINetworkInfo.NETWORK_STATE_CONNECTED) { + gNetworkManager.updateNetworkInterface(WifiNetworkInterface); + } + } + + var staticIpConfig = Object.create(null); + function setStaticIpMode(network, info, callback) { + let setNetworkKey = getNetworkKey(network); + let curNetworkKey = null; + let currentNetwork = Object.create(null); + currentNetwork.netId = manager.connectionInfo.id; + + manager.getNetworkConfiguration(currentNetwork, function () { + curNetworkKey = getNetworkKey(currentNetwork); + + // Add additional information to static ip configuration + // It is used to compatiable with information dhcp callback. + info.ipaddr = netHelpers.stringToIP(info.ipaddr_str); + info.gateway = netHelpers.stringToIP(info.gateway_str); + info.mask_str = netHelpers.ipToString(netHelpers.makeMask(info.maskLength)); + + // Optional + info.dns1 = netHelpers.stringToIP(info.dns1_str); + info.dns2 = netHelpers.stringToIP(info.dns2_str); + info.proxy = netHelpers.stringToIP(info.proxy_str); + + staticIpConfig[setNetworkKey] = info; + + // If the ssid of current connection is the same as configured ssid + // It means we need update current connection to use static IP address. + if (setNetworkKey == curNetworkKey) { + // Use configureInterface directly doesn't work, the network interface + // and routing table is changed but still cannot connect to network + // so the workaround here is disable interface the enable again to + // trigger network reconnect with static ip. + gNetworkService.disableInterface(manager.ifname, function (ok) { + gNetworkService.enableInterface(manager.ifname, function (ok) { + callback(ok); + }); + }); + return; + } + + callback(true); + }); + } + + var dhcpInfo = null; + + function runStaticIp(ifname, key) { + debug("Run static ip"); + + // Read static ip information from settings. + let staticIpInfo; + + if (!(key in staticIpConfig)) + return; + + staticIpInfo = staticIpConfig[key]; + + // Stop dhcpd when use static IP + if (dhcpInfo != null) { + netUtil.stopDhcp(manager.ifname, function() {}); + } + + // Set ip, mask length, gateway, dns to network interface + gNetworkService.configureInterface( { ifname: ifname, + ipaddr: staticIpInfo.ipaddr, + mask: staticIpInfo.maskLength, + gateway: staticIpInfo.gateway, + dns1: staticIpInfo.dns1, + dns2: staticIpInfo.dns2 }, function (data) { + netUtil.runIpConfig(ifname, staticIpInfo, function(data) { + dhcpInfo = data.info; + notify("networkconnected", data); + }); + }); + } + + var suppressEvents = false; + function notify(eventName, eventObject) { + if (suppressEvents) + return; + var handler = manager["on" + eventName]; + if (handler) { + if (!eventObject) + eventObject = ({}); + handler.call(eventObject); + } + } + + function notifyStateChange(fields) { + // If we're already in the COMPLETED state, we might receive events from + // the supplicant that tell us that we're re-authenticating or reminding + // us that we're associated to a network. In those cases, we don't need to + // do anything, so just ignore them. + if (manager.state === "COMPLETED" && + fields.state !== "DISCONNECTED" && + fields.state !== "INTERFACE_DISABLED" && + fields.state !== "INACTIVE" && + fields.state !== "SCANNING") { + return false; + } + + // Stop background scanning if we're trying to connect to a network. + if (manager.backgroundScanEnabled && + (fields.state === "ASSOCIATING" || + fields.state === "ASSOCIATED" || + fields.state === "FOUR_WAY_HANDSHAKE" || + fields.state === "GROUP_HANDSHAKE" || + fields.state === "COMPLETED")) { + setBackgroundScan("OFF", function() {}); + } + + fields.prevState = manager.state; + // Detect wpa_supplicant's loop iterations. + manager.supplicantLoopDetection(fields.prevState, fields.state); + notify("statechange", fields); + + // Don't update state when and after disabling. + if (manager.state === "DISABLING" || + manager.state === "UNINITIALIZED") { + return false; + } + + manager.state = fields.state; + return true; + } + + function parseStatus(status) { + if (status === null) { + debug("Unable to get wpa supplicant's status"); + return; + } + + var ssid; + var bssid; + var state; + var ip_address; + var id; + + var lines = status.split("\n"); + for (let i = 0; i < lines.length; ++i) { + let [key, value] = lines[i].split("="); + switch (key) { + case "wpa_state": + state = value; + break; + case "ssid": + ssid = value; + break; + case "bssid": + bssid = value; + break; + case "ip_address": + ip_address = value; + break; + case "id": + id = value; + break; + } + } + + if (bssid && ssid) { + manager.connectionInfo.bssid = bssid; + manager.connectionInfo.ssid = ssid; + manager.connectionInfo.id = id; + } + + if (ip_address) + dhcpInfo = { ip_address: ip_address }; + + notifyStateChange({ state: state, fromStatus: true }); + + // If we parse the status and the supplicant has already entered the + // COMPLETED state, then we need to set up DHCP right away. + if (state === "COMPLETED") + onconnected(); + } + + // try to connect to the supplicant + var connectTries = 0; + var retryTimer = null; + function connectCallback(ok) { + if (ok === 0) { + // Tell the event worker to start waiting for events. + retryTimer = null; + connectTries = 0; + recvErrors = 0; + manager.connectToSupplicant = true; + didConnectSupplicant(function(){}); + return; + } + if (connectTries++ < 5) { + // Try again in 1 seconds. + if (!retryTimer) + retryTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + + retryTimer.initWithCallback(function(timer) { + wifiCommand.connectToSupplicant(connectCallback); + }, 1000, Ci.nsITimer.TYPE_ONE_SHOT); + return; + } + + retryTimer = null; + connectTries = 0; + notify("supplicantlost", { success: false }); + } + + manager.connectionDropped = function(callback) { + // Reset network interface when connection drop + gNetworkService.configureInterface( { ifname: manager.ifname, + ipaddr: 0, + mask: 0, + gateway: 0, + dns1: 0, + dns2: 0 }, function (data) { + }); + + // If we got disconnected, kill the DHCP client in preparation for + // reconnection. + gNetworkService.resetConnections(manager.ifname, function() { + netUtil.stopDhcp(manager.ifname, function() { + callback(); + }); + }); + } + + manager.start = function() { + debug("detected SDK version " + sdkVersion); + wifiCommand.connectToSupplicant(connectCallback); + } + + let dhcpRequestGen = 0; + + function onconnected() { + // For now we do our own DHCP. In the future, this should be handed + // off to the Network Manager. + let currentNetwork = Object.create(null); + currentNetwork.netId = manager.connectionInfo.id; + + manager.getNetworkConfiguration(currentNetwork, function (){ + let key = getNetworkKey(currentNetwork); + if (staticIpConfig && + (key in staticIpConfig) && + staticIpConfig[key].enabled) { + debug("Run static ip"); + runStaticIp(manager.ifname, key); + return; + } + netUtil.runDhcp(manager.ifname, dhcpRequestGen++, function(data, gen) { + dhcpInfo = data.info; + debug('dhcpRequestGen: ' + dhcpRequestGen + ', gen: ' + gen); + if (!dhcpInfo) { + if (gen + 1 < dhcpRequestGen) { + debug('Do not bother younger DHCP request.'); + return; + } + if (++manager.dhcpFailuresCount >= MAX_RETRIES_ON_DHCP_FAILURE) { + manager.dhcpFailuresCount = 0; + notify("disconnected", {connectionInfo: manager.connectionInfo}); + return; + } + // NB: We have to call disconnect first. Otherwise, we only reauth with + // the existing AP and don't retrigger DHCP. + manager.disconnect(function() { + manager.reassociate(function(){}); + }); + return; + } + + manager.dhcpFailuresCount = 0; + notify("networkconnected", data); + }); + }); + } + + var supplicantStatesMap = (sdkVersion >= 15) ? + ["DISCONNECTED", "INTERFACE_DISABLED", "INACTIVE", "SCANNING", + "AUTHENTICATING", "ASSOCIATING", "ASSOCIATED", "FOUR_WAY_HANDSHAKE", + "GROUP_HANDSHAKE", "COMPLETED"] + : + ["DISCONNECTED", "INACTIVE", "SCANNING", "ASSOCIATING", + "ASSOCIATED", "FOUR_WAY_HANDSHAKE", "GROUP_HANDSHAKE", + "COMPLETED", "DORMANT", "UNINITIALIZED"]; + + var driverEventMap = { STOPPED: "driverstopped", STARTED: "driverstarted", HANGED: "driverhung" }; + + manager.getNetworkId = function (ssid, callback) { + manager.getConfiguredNetworks(function(networks) { + if (!networks) { + debug("Unable to get configured networks"); + return callback(null); + } + for (let net in networks) { + let network = networks[net]; + // Trying to get netId from + // 1. network matching SSID if SSID is provided. + // 2. current network if no SSID is provided, it's not guaranteed that + // current network matches requested SSID. + if ((!ssid && network.status === "CURRENT") || + (ssid && network.ssid && ssid === dequote(network.ssid))) { + return callback(net); + } + } + callback(null); + }); + } + + function handleWpaEapEvents(event) { + if (event.indexOf("CTRL-EVENT-EAP-FAILURE") !== -1) { + if (event.indexOf("EAP authentication failed") !== -1) { + notify("passwordmaybeincorrect"); + if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) { + manager.authenticationFailuresCount = 0; + notify("disconnected", {connectionInfo: manager.connectionInfo}); + } + } + return true; + } + if (event.indexOf("CTRL-EVENT-EAP-TLS-CERT-ERROR") !== -1) { + // Cert Error + notify("passwordmaybeincorrect"); + if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) { + manager.authenticationFailuresCount = 0; + notify("disconnected", {connectionInfo: manager.connectionInfo}); + } + return true; + } + if (event.indexOf("CTRL-EVENT-EAP-STARTED") !== -1) { + notifyStateChange({ state: "AUTHENTICATING" }); + return true; + } + return true; + } + + // Handle events sent to us by the event worker. + function handleEvent(event) { + debug("Event coming in: " + event); + if (event.indexOf("CTRL-EVENT-") !== 0 && event.indexOf("WPS") !== 0) { + // Handle connection fail exception on WEP-128, while password length + // is not 5 nor 13 bytes. + if (event.indexOf("Association request to the driver failed") !== -1) { + notify("passwordmaybeincorrect"); + if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) { + manager.authenticationFailuresCount = 0; + notify("disconnected", {connectionInfo: manager.connectionInfo}); + } + return true; + } + + if (event.indexOf("WPA:") == 0 && + event.indexOf("pre-shared key may be incorrect") != -1) { + notify("passwordmaybeincorrect"); + } + + // This is ugly, but we need to grab the SSID here. BSSID is not guaranteed + // to be provided, so don't grab BSSID here. + var match = /Trying to associate with.*SSID[ =]'(.*)'/.exec(event); + if (match) { + debug("Matched: " + match[1] + "\n"); + manager.connectionInfo.ssid = match[1]; + } + return true; + } + + var space = event.indexOf(" "); + var eventData = event.substr(0, space + 1); + if (eventData.indexOf("CTRL-EVENT-STATE-CHANGE") === 0) { + // Parse the event data. + var fields = {}; + var tokens = event.substr(space + 1).split(" "); + for (var n = 0; n < tokens.length; ++n) { + var kv = tokens[n].split("="); + if (kv.length === 2) + fields[kv[0]] = kv[1]; + } + if (!("state" in fields)) + return true; + fields.state = supplicantStatesMap[fields.state]; + + // The BSSID field is only valid in the ASSOCIATING and ASSOCIATED + // states, except when we "reauth", except this seems to depend on the + // driver, so simply check to make sure that we don't have a null BSSID. + if (fields.BSSID !== "00:00:00:00:00:00") + manager.connectionInfo.bssid = fields.BSSID; + + if (notifyStateChange(fields) && fields.state === "COMPLETED") { + onconnected(); + } + return true; + } + if (eventData.indexOf("CTRL-EVENT-DRIVER-STATE") === 0) { + var handlerName = driverEventMap[eventData]; + if (handlerName) + notify(handlerName); + return true; + } + if (eventData.indexOf("CTRL-EVENT-TERMINATING") === 0) { + // As long the monitor socket is not closed and we haven't seen too many + // recv errors yet, we will keep going for a bit longer. + if (event.indexOf("connection closed") === -1 && + event.indexOf("recv error") !== -1 && ++recvErrors < 10) + return true; + + notifyStateChange({ state: "DISCONNECTED", BSSID: null, id: -1 }); + + // If the supplicant is terminated as commanded, the supplicant lost + // notification will be sent after driver unloaded. In such case, the + // manager state will be "DISABLING" or "UNINITIALIZED". + // So if supplicant terminated with incorrect manager state, implying + // unexpected condition, we should notify supplicant lost here. + if (manager.state !== "DISABLING" && manager.state !== "UNINITIALIZED") { + notify("supplicantlost", { success: true }); + } + + if (manager.stopSupplicantCallback) { + cancelWaitForTerminateEventTimer(); + // It's possible that the terminating event triggered by timer comes + // earlier than the event from wpa_supplicant. Since + // stopSupplicantCallback contains async. callbacks, swap it to local + // to prevent calling the callback twice. + let stopSupplicantCallback = manager.stopSupplicantCallback.bind(manager); + manager.stopSupplicantCallback = null; + stopSupplicantCallback(); + stopSupplicantCallback = null; + } + return false; + } + if (eventData.indexOf("CTRL-EVENT-DISCONNECTED") === 0) { + var token = event.split(" ")[1]; + var bssid = token.split("=")[1]; + if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) { + manager.authenticationFailuresCount = 0; + notify("disconnected", {connectionInfo: manager.connectionInfo}); + } + manager.connectionInfo.bssid = null; + manager.connectionInfo.ssid = null; + manager.connectionInfo.id = -1; + return true; + } + if (eventData.indexOf("CTRL-EVENT-CONNECTED") === 0) { + // Format: CTRL-EVENT-CONNECTED - Connection to 00:1e:58:ec:d5:6d completed (reauth) [id=1 id_str=] + var bssid = event.split(" ")[4]; + + var keyword = "id="; + var id = event.substr(event.indexOf(keyword) + keyword.length).split(" ")[0]; + // Read current BSSID here, it will always being provided. + manager.connectionInfo.id = id; + manager.connectionInfo.bssid = bssid; + return true; + } + if (eventData.indexOf("CTRL-EVENT-SCAN-RESULTS") === 0) { + debug("Notifying of scan results available"); + if (reEnableBackgroundScan) { + reEnableBackgroundScan = false; + setBackgroundScan("ON", function() {}); + } + manager.handlePostWifiScan(); + notify("scanresultsavailable"); + return true; + } + if (eventData.indexOf("CTRL-EVENT-EAP") === 0) { + return handleWpaEapEvents(event); + } + if (eventData.indexOf("CTRL-EVENT-ASSOC-REJECT") === 0) { + debug("CTRL-EVENT-ASSOC-REJECT: network error"); + notify("passwordmaybeincorrect"); + if (manager.authenticationFailuresCount > MAX_RETRIES_ON_AUTHENTICATION_FAILURE) { + manager.authenticationFailuresCount = 0; + debug("CTRL-EVENT-ASSOC-REJECT: disconnect network"); + notify("disconnected", {connectionInfo: manager.connectionInfo}); + } + return true; + } + if (eventData.indexOf("WPS-TIMEOUT") === 0) { + notifyStateChange({ state: "WPS_TIMEOUT", BSSID: null, id: -1 }); + return true; + } + if (eventData.indexOf("WPS-FAIL") === 0) { + notifyStateChange({ state: "WPS_FAIL", BSSID: null, id: -1 }); + return true; + } + if (eventData.indexOf("WPS-OVERLAP-DETECTED") === 0) { + notifyStateChange({ state: "WPS_OVERLAP_DETECTED", BSSID: null, id: -1 }); + return true; + } + // Unknown event. + return true; + } + + function setPowerSavingMode(enabled) { + let mode = enabled ? "AUTO" : "ACTIVE"; + // Some wifi drivers may not implement this command. Set power mode + // even if suspend optimization command failed. + manager.setSuspendOptimizations(enabled, function(ok) { + manager.setPowerMode(mode, function() {}); + }); + } + + function didConnectSupplicant(callback) { + waitForEvent(manager.ifname); + + // Load up the supplicant state. + getDebugEnabled(function(ok) { + syncDebug(); + }); + wifiCommand.status(function(status) { + parseStatus(status); + notify("supplicantconnection"); + callback(); + }); + // WPA supplicant already connected. + manager.setPowerSavingMode(true); + if (p2pSupported) { + manager.enableP2p(function(success) {}); + } + } + + function prepareForStartup(callback) { + let status = libcutils.property_get(DHCP_PROP + "_" + manager.ifname); + if (status !== "running") { + tryStopSupplicant(); + return; + } + manager.connectionDropped(function() { + tryStopSupplicant(); + }); + + // Ignore any errors and kill any currently-running supplicants. On some + // phones, stopSupplicant won't work for a supplicant that we didn't + // start, so we hand-roll it here. + function tryStopSupplicant () { + let status = libcutils.property_get(SUPP_PROP); + if (status !== "running") { + callback(); + return; + } + suppressEvents = true; + wifiCommand.killSupplicant(function() { + gNetworkService.disableInterface(manager.ifname, function (ok) { + suppressEvents = false; + callback(); + }); + }); + } + } + + // Initial state. + manager.state = "UNINITIALIZED"; + manager.tetheringState = "UNINITIALIZED"; + manager.supplicantStarted = false; + manager.connectionInfo = { ssid: null, bssid: null, id: -1 }; + manager.authenticationFailuresCount = 0; + manager.loopDetectionCount = 0; + manager.dhcpFailuresCount = 0; + manager.stopSupplicantCallback = null; + + manager.__defineGetter__("enabled", function() { + switch (manager.state) { + case "UNINITIALIZED": + case "INITIALIZING": + case "DISABLING": + return false; + default: + return true; + } + }); + + var waitForTerminateEventTimer = null; + function cancelWaitForTerminateEventTimer() { + if (waitForTerminateEventTimer) { + waitForTerminateEventTimer.cancel(); + waitForTerminateEventTimer = null; + } + }; + function createWaitForTerminateEventTimer(onTimeout) { + if (waitForTerminateEventTimer) { + return; + } + waitForTerminateEventTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + waitForTerminateEventTimer.initWithCallback(onTimeout, + 4000, + Ci.nsITimer.TYPE_ONE_SHOT); + }; + + var waitForDriverReadyTimer = null; + function cancelWaitForDriverReadyTimer() { + if (waitForDriverReadyTimer) { + waitForDriverReadyTimer.cancel(); + waitForDriverReadyTimer = null; + } + }; + function createWaitForDriverReadyTimer(onTimeout) { + waitForDriverReadyTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + waitForDriverReadyTimer.initWithCallback(onTimeout, + manager.driverDelay, + Ci.nsITimer.TYPE_ONE_SHOT); + }; + + // Public interface of the wifi service. + manager.setWifiEnabled = function(enabled, callback) { + if (enabled === manager.isWifiEnabled(manager.state)) { + callback("no change"); + return; + } + + if (enabled) { + manager.state = "INITIALIZING"; + // Register as network interface. + WifiNetworkInterface.info.name = manager.ifname; + if (!WifiNetworkInterface.registered) { + gNetworkManager.registerNetworkInterface(WifiNetworkInterface); + WifiNetworkInterface.registered = true; + } + WifiNetworkInterface.info.state = + Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED; + WifiNetworkInterface.info.ips = []; + WifiNetworkInterface.info.prefixLengths = []; + WifiNetworkInterface.info.gateways = []; + WifiNetworkInterface.info.dnses = []; + gNetworkManager.updateNetworkInterface(WifiNetworkInterface); + + prepareForStartup(function() { + loadDriver(function (status) { + if (status < 0) { + callback(status); + manager.state = "UNINITIALIZED"; + return; + } + // This command is mandatory for Nexus 4. But some devices like + // Galaxy S2 don't support it. Continue to start wpa_supplicant + // even if we fail to set wifi operation mode to station. + gNetworkService.setWifiOperationMode(manager.ifname, + WIFI_FIRMWARE_STATION, + function (status) { + + function startSupplicantInternal() { + wifiCommand.startSupplicant(function (status) { + if (status < 0) { + unloadDriver(WIFI_FIRMWARE_STATION, function() { + callback(status); + }); + manager.state = "UNINITIALIZED"; + return; + } + + manager.supplicantStarted = true; + gNetworkService.enableInterface(manager.ifname, function (ok) { + callback(ok ? 0 : -1); + }); + }); + } + + function doStartSupplicant() { + cancelWaitForDriverReadyTimer(); + + if (!manager.connectToSupplicant) { + startSupplicantInternal(); + return; + } + wifiCommand.closeSupplicantConnection(function () { + manager.connectToSupplicant = false; + // closeSupplicantConnection() will trigger onsupplicantlost + // and set manager.state to "UNINITIALIZED", we have to + // restore it here. + manager.state = "INITIALIZING"; + startSupplicantInternal(); + }); + } + // Driver startup on certain platforms takes longer than it takes for us + // to return from loadDriver, so wait 2 seconds before starting + // the supplicant to give it a chance to start. + if (manager.driverDelay > 0) { + createWaitForDriverReadyTimer(doStartSupplicant); + } else { + doStartSupplicant(); + } + }); + }); + }); + } else { + manager.state = "DISABLING"; + // Note these following calls ignore errors. If we fail to kill the + // supplicant gracefully, then we need to continue telling it to die + // until it does. + let doDisableWifi = function() { + manager.stopSupplicantCallback = (function () { + wifiCommand.stopSupplicant(function (status) { + wifiCommand.closeSupplicantConnection(function() { + manager.connectToSupplicant = false; + manager.state = "UNINITIALIZED"; + gNetworkService.disableInterface(manager.ifname, function (ok) { + unloadDriver(WIFI_FIRMWARE_STATION, callback); + }); + }); + }); + }).bind(this); + + let terminateEventCallback = (function() { + handleEvent("CTRL-EVENT-TERMINATING"); + }).bind(this); + createWaitForTerminateEventTimer(terminateEventCallback); + + // We are going to terminate the connection between wpa_supplicant. + // Stop the polling timer immediately to prevent connection info update + // command blocking in control thread until socket timeout. + notify("stopconnectioninfotimer"); + + wifiCommand.terminateSupplicant(function (ok) { + manager.connectionDropped(function () { + }); + }); + } + + if (p2pSupported) { + p2pManager.setEnabled(false, { onDisabled: doDisableWifi }); + } else { + doDisableWifi(); + } + } + } + + var wifiHotspotStatusTimer = null; + function cancelWifiHotspotStatusTimer() { + if (wifiHotspotStatusTimer) { + wifiHotspotStatusTimer.cancel(); + wifiHotspotStatusTimer = null; + } + } + + function createWifiHotspotStatusTimer(onTimeout) { + wifiHotspotStatusTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + wifiHotspotStatusTimer.init(onTimeout, 5000, Ci.nsITimer.TYPE_REPEATING_SLACK); + } + + // Get wifi interface and load wifi driver when enable Ap mode. + manager.setWifiApEnabled = function(enabled, configuration, callback) { + if (enabled === manager.isWifiTetheringEnabled(manager.tetheringState)) { + callback("no change"); + return; + } + + if (enabled) { + manager.tetheringState = "INITIALIZING"; + loadDriver(function (status) { + if (status < 0) { + callback(); + manager.tetheringState = "UNINITIALIZED"; + if (wifiHotspotStatusTimer) { + cancelWifiHotspotStatusTimer(); + wifiCommand.closeHostapdConnection(function(result) { + }); + } + return; + } + + function getWifiHotspotStatus() { + wifiCommand.hostapdGetStations(function(result) { + notify("stationinfoupdate", {station: result}); + }); + } + + function doStartWifiTethering() { + cancelWaitForDriverReadyTimer(); + WifiNetworkInterface.info.name = + libcutils.property_get("wifi.tethering.interface", manager.ifname); + gTetheringService.setWifiTethering(enabled, + WifiNetworkInterface.info.name, + configuration, function(result) { + if (result) { + manager.tetheringState = "UNINITIALIZED"; + } else { + manager.tetheringState = "COMPLETED"; + wifiCommand.connectToHostapd(function(result) { + if (result) { + return; + } + // Create a timer to track the connection status. + createWifiHotspotStatusTimer(getWifiHotspotStatus); + }); + } + // Pop out current request. + callback(); + // Should we fire a dom event if we fail to set wifi tethering ? + debug("Enable Wifi tethering result: " + (result ? result : "successfully")); + }); + } + + // Driver startup on certain platforms takes longer than it takes + // for us to return from loadDriver, so wait 2 seconds before + // turning on Wifi tethering. + createWaitForDriverReadyTimer(doStartWifiTethering); + }); + } else { + cancelWifiHotspotStatusTimer(); + gTetheringService.setWifiTethering(enabled, WifiNetworkInterface, + configuration, function(result) { + // Should we fire a dom event if we fail to set wifi tethering ? + debug("Disable Wifi tethering result: " + (result ? result : "successfully")); + // Unload wifi driver even if we fail to control wifi tethering. + unloadDriver(WIFI_FIRMWARE_AP, function(status) { + if (status < 0) { + debug("Fail to unload wifi driver"); + } + manager.tetheringState = "UNINITIALIZED"; + callback(); + }); + }); + } + } + + manager.disconnect = wifiCommand.disconnect; + manager.reconnect = wifiCommand.reconnect; + manager.reassociate = wifiCommand.reassociate; + + var networkConfigurationFields = [ + {name: "ssid", type: "string"}, + {name: "bssid", type: "string"}, + {name: "psk", type: "string"}, + {name: "wep_key0", type: "string"}, + {name: "wep_key1", type: "string"}, + {name: "wep_key2", type: "string"}, + {name: "wep_key3", type: "string"}, + {name: "wep_tx_keyidx", type: "integer"}, + {name: "priority", type: "integer"}, + {name: "key_mgmt", type: "string"}, + {name: "scan_ssid", type: "string"}, + {name: "disabled", type: "integer"}, + {name: "identity", type: "string"}, + {name: "password", type: "string"}, + {name: "auth_alg", type: "string"}, + {name: "phase1", type: "string"}, + {name: "phase2", type: "string"}, + {name: "eap", type: "string"}, + {name: "pin", type: "string"}, + {name: "pcsc", type: "string"}, + {name: "ca_cert", type: "string"}, + {name: "subject_match", type: "string"}, + {name: "client_cert", type: "string"}, + {name: "private_key", type: "stirng"}, + {name: "engine", type: "integer"}, + {name: "engine_id", type: "string"}, + {name: "key_id", type: "string"}, + {name: "frequency", type: "integer"}, + {name: "mode", type: "integer"} + ]; + // These fields are only handled in IBSS (aka ad-hoc) mode + var ibssNetworkConfigurationFields = [ + "frequency", "mode" + ]; + + manager.getNetworkConfiguration = function(config, callback) { + var netId = config.netId; + var done = 0; + for (var n = 0; n < networkConfigurationFields.length; ++n) { + let fieldName = networkConfigurationFields[n].name; + let fieldType = networkConfigurationFields[n].type; + wifiCommand.getNetworkVariable(netId, fieldName, function(value) { + if (value !== null) { + if (fieldType === "integer") { + config[fieldName] = parseInt(value, 10); + } else if ( fieldName == "ssid" && value[0] != '"' ) { + // SET_NETWORK will set a quoted ssid to wpa_supplicant. + // But if ssid contains non-ascii char, it will be converted into utf-8. + // For example: "Testçš„wifi" --> 54657374e79a8477696669 + // When GET_NETWORK receive a un-quoted utf-8 ssid, it must be decoded and quoted. + config[fieldName] = quote(decodeURIComponent(value.replace(/[0-9a-f]{2}/g, '%$&'))); + } else { + // value is string type by default. + config[fieldName] = value; + } + } + if (++done == networkConfigurationFields.length) + callback(config); + }); + } + } + manager.setNetworkConfiguration = function(config, callback) { + var netId = config.netId; + var done = 0; + var errors = 0; + + function hasValidProperty(name) { + return ((name in config) && + config[name] != null && + (["password", "wep_key0", "psk"].indexOf(name) === -1 || + config[name] !== '*')); + } + + function getModeFromConfig() { + /* we use the mode from the config, or ESS as default */ + return hasValidProperty("mode") ? config["mode"] : MODE_ESS; + } + + var mode = getModeFromConfig(); + + function validForMode(name, mode) { + /* all fields are valid for IBSS */ + return (mode == MODE_IBSS) || + /* IBSS fields are not valid for ESS */ + ((mode == MODE_ESS) && !(name in ibssNetworkConfigurationFields)); + } + + for (var n = 0; n < networkConfigurationFields.length; ++n) { + let fieldName = networkConfigurationFields[n].name; + if (!hasValidProperty(fieldName) || !validForMode(fieldName, mode)) { + ++done; + } else { + wifiCommand.setNetworkVariable(netId, fieldName, config[fieldName], function(ok) { + if (!ok) + ++errors; + if (++done == networkConfigurationFields.length) + callback(errors == 0); + }); + } + } + // If config didn't contain any of the fields we want, don't lose the error callback. + if (done == networkConfigurationFields.length) + callback(false); + } + manager.getConfiguredNetworks = function(callback) { + wifiCommand.listNetworks(function (reply) { + var networks = Object.create(null); + var lines = reply ? reply.split("\n") : 0; + if (lines.length <= 1) { + // We need to make sure we call the callback even if there are no + // configured networks. + callback(networks); + return; + } + + var done = 0; + var errors = 0; + for (var n = 1; n < lines.length; ++n) { + var result = lines[n].split("\t"); + var netId = parseInt(result[0], 10); + var config = networks[netId] = { netId: netId }; + switch (result[3]) { + case "[CURRENT]": + config.status = "CURRENT"; + break; + case "[DISABLED]": + config.status = "DISABLED"; + break; + default: + config.status = "ENABLED"; + break; + } + manager.getNetworkConfiguration(config, function (ok) { + if (!ok) + ++errors; + if (++done == lines.length - 1) { + if (errors) { + // If an error occured, delete the new netId. + wifiCommand.removeNetwork(netId, function() { + callback(null); + }); + } else { + callback(networks); + } + } + }); + } + }); + } + manager.addNetwork = function(config, callback) { + wifiCommand.addNetwork(function (netId) { + config.netId = netId; + manager.setNetworkConfiguration(config, function (ok) { + if (!ok) { + wifiCommand.removeNetwork(netId, function() { callback(false); }); + return; + } + + callback(ok); + }); + }); + } + manager.updateNetwork = function(config, callback) { + manager.setNetworkConfiguration(config, callback); + } + manager.removeNetwork = function(netId, callback) { + wifiCommand.removeNetwork(netId, callback); + } + + manager.saveConfig = function(callback) { + wifiCommand.saveConfig(callback); + } + manager.enableNetwork = function(netId, disableOthers, callback) { + if (p2pSupported) { + // We have to stop wifi direct scan before associating to an AP. + // Otherwise we will get a "REJECT" wpa supplicant event. + p2pManager.setScanEnabled(false, function(success) {}); + } + wifiCommand.enableNetwork(netId, disableOthers, callback); + } + manager.disableNetwork = function(netId, callback) { + wifiCommand.disableNetwork(netId, callback); + } + manager.getMacAddress = wifiCommand.getMacAddress; + manager.getScanResults = wifiCommand.scanResults; + manager.setScanMode = function(mode, callback) { + setScanMode(mode === "active", callback); // Use our own version. + } + manager.setBackgroundScan = setBackgroundScan; // Use our own version. + manager.scan = scan; // Use our own version. + manager.wpsPbc = wifiCommand.wpsPbc; + manager.wpsPin = wifiCommand.wpsPin; + manager.wpsCancel = wifiCommand.wpsCancel; + manager.setPowerMode = (sdkVersion >= 16) + ? wifiCommand.setPowerModeJB + : wifiCommand.setPowerModeICS; + manager.setPowerSavingMode = setPowerSavingMode; + manager.getHttpProxyNetwork = getHttpProxyNetwork; + manager.setHttpProxy = setHttpProxy; + manager.configureHttpProxy = configureHttpProxy; + manager.setSuspendOptimizations = (sdkVersion >= 16) + ? wifiCommand.setSuspendOptimizationsJB + : wifiCommand.setSuspendOptimizationsICS; + manager.setStaticIpMode = setStaticIpMode; + manager.getRssiApprox = wifiCommand.getRssiApprox; + manager.getLinkSpeed = wifiCommand.getLinkSpeed; + manager.getDhcpInfo = function() { return dhcpInfo; } + manager.getConnectionInfo = (sdkVersion >= 15) + ? wifiCommand.getConnectionInfoICS + : wifiCommand.getConnectionInfoGB; + + manager.ensureSupplicantDetached = aCallback => { + if (!manager.enabled) { + aCallback(); + return; + } + wifiCommand.closeSupplicantConnection(aCallback); + }; + + manager.isHandShakeState = function(state) { + switch (state) { + case "AUTHENTICATING": + case "ASSOCIATING": + case "ASSOCIATED": + case "FOUR_WAY_HANDSHAKE": + case "GROUP_HANDSHAKE": + return true; + case "DORMANT": + case "COMPLETED": + case "DISCONNECTED": + case "INTERFACE_DISABLED": + case "INACTIVE": + case "SCANNING": + case "UNINITIALIZED": + case "INVALID": + case "CONNECTED": + default: + return false; + } + } + + manager.isWifiEnabled = function(state) { + switch (state) { + case "UNINITIALIZED": + case "DISABLING": + return false; + default: + return true; + } + } + + manager.isWifiTetheringEnabled = function(state) { + switch (state) { + case "UNINITIALIZED": + return false; + default: + return true; + } + } + + manager.syncDebug = syncDebug; + manager.stateOrdinal = function(state) { + return supplicantStatesMap.indexOf(state); + } + manager.supplicantLoopDetection = function(prevState, state) { + var isPrevStateInHandShake = manager.isHandShakeState(prevState); + var isStateInHandShake = manager.isHandShakeState(state); + + if (isPrevStateInHandShake) { + if (isStateInHandShake) { + // Increase the count only if we are in the loop. + if (manager.stateOrdinal(state) > manager.stateOrdinal(prevState)) { + manager.loopDetectionCount++; + } + if (manager.loopDetectionCount > MAX_SUPPLICANT_LOOP_ITERATIONS) { + notify("disconnected", {connectionInfo: manager.connectionInfo}); + manager.loopDetectionCount = 0; + } + } + } else { + // From others state to HandShake state. Reset the count. + if (isStateInHandShake) { + manager.loopDetectionCount = 0; + } + } + } + + manager.handlePreWifiScan = function() { + if (p2pSupported) { + // Before doing regular wifi scan, we have to disable wifi direct + // scan first. Otherwise we will never get the scan result. + p2pManager.blockScan(); + } + }; + + manager.handlePostWifiScan = function() { + if (p2pSupported) { + // After regular wifi scanning, we should restore the restricted + // wifi direct scan. + p2pManager.unblockScan(); + } + }; + + // + // Public APIs for P2P. + // + + manager.p2pSupported = function() { + return p2pSupported; + }; + + manager.getP2pManager = function() { + return p2pManager; + }; + + manager.enableP2p = function(callback) { + p2pManager.setEnabled(true, { + onSupplicantConnected: function() { + waitForEvent(WifiP2pManager.INTERFACE_NAME); + }, + + onEnabled: function(success) { + callback(success); + } + }); + }; + + manager.getCapabilities = function() { + return capabilities; + } + + // Cert Services + let wifiCertService = Cc["@mozilla.org/wifi/certservice;1"]; + if (wifiCertService) { + wifiCertService = wifiCertService.getService(Ci.nsIWifiCertService); + wifiCertService.start(wifiListener); + } else { + debug("No wifi CA service component available"); + } + + manager.importCert = function(caInfo, callback) { + var id = idgen++; + if (callback) { + controlCallbacks[id] = callback; + } + + wifiCertService.importCert(id, caInfo.certBlob, caInfo.certPassword, + caInfo.certNickname); + } + + manager.deleteCert = function(caInfo, callback) { + var id = idgen++; + if (callback) { + controlCallbacks[id] = callback; + } + + wifiCertService.deleteCert(id, caInfo.certNickname); + } + + manager.sdkVersion = function() { + return sdkVersion; + } + + return manager; +})(); + +// Get unique key for a network, now the key is created by escape(SSID)+Security. +// So networks of same SSID but different security mode can be identified. +function getNetworkKey(network) +{ + var ssid = "", + encryption = "OPEN"; + + if ("security" in network) { + // manager network object, represents an AP + // object structure + // { + // .ssid : SSID of AP + // .security[] : "WPA-PSK" for WPA-PSK + // "WPA-EAP" for WPA-EAP + // "WEP" for WEP + // "" for OPEN + // other keys + // } + + var security = network.security; + ssid = network.ssid; + + for (let j = 0; j < security.length; j++) { + if (security[j] === "WPA-PSK") { + encryption = "WPA-PSK"; + break; + } else if (security[j] === "WPA-EAP") { + encryption = "WPA-EAP"; + break; + } else if (security[j] === "WEP") { + encryption = "WEP"; + break; + } + } + } else if ("key_mgmt" in network) { + // configure network object, represents a network + // object structure + // { + // .ssid : SSID of network, quoted + // .key_mgmt : Encryption type + // "WPA-PSK" for WPA-PSK + // "WPA-EAP" for WPA-EAP + // "NONE" for WEP/OPEN + // .auth_alg : Encryption algorithm(WEP mode only) + // "OPEN_SHARED" for WEP + // other keys + // } + var key_mgmt = network.key_mgmt, + auth_alg = network.auth_alg; + ssid = dequote(network.ssid); + + if (key_mgmt == "WPA-PSK") { + encryption = "WPA-PSK"; + } else if (key_mgmt.indexOf("WPA-EAP") != -1) { + encryption = "WPA-EAP"; + } else if (key_mgmt == "NONE" && auth_alg === "OPEN SHARED") { + encryption = "WEP"; + } + } + + // ssid here must be dequoted, and it's safer to esacpe it. + // encryption won't be empty and always be assigned one of the followings : + // "OPEN"/"WEP"/"WPA-PSK"/"WPA-EAP". + // So for a invalid network object, the returned key will be "OPEN". + return escape(ssid) + encryption; +} + +function getMode(flags) { + if (/\[IBSS/.test(flags)) + return MODE_IBSS; + + return MODE_ESS; +} + +function getKeyManagement(flags) { + var types = []; + if (!flags) + return types; + + if (/\[WPA2?-PSK/.test(flags)) + types.push("WPA-PSK"); + if (/\[WPA2?-EAP/.test(flags)) + types.push("WPA-EAP"); + if (/\[WEP/.test(flags)) + types.push("WEP"); + return types; +} + +function getCapabilities(flags) { + var types = []; + if (!flags) + return types; + + if (/\[WPS/.test(flags)) + types.push("WPS"); + return types; +} + +// These constants shamelessly ripped from WifiManager.java +// strength is the value returned by scan_results. It is nominally in dB. We +// transform it into a percentage for clients looking to simply show a +// relative indication of the strength of a network. +const MIN_RSSI = -100; +const MAX_RSSI = -55; + +function calculateSignal(strength) { + // Some wifi drivers represent their signal strengths as 8-bit integers, so + // in order to avoid negative numbers, they add 256 to the actual values. + // While we don't *know* that this is the case here, we make an educated + // guess. + if (strength > 0) + strength -= 256; + + if (strength <= MIN_RSSI) + return 0; + if (strength >= MAX_RSSI) + return 100; + return Math.floor(((strength - MIN_RSSI) / (MAX_RSSI - MIN_RSSI)) * 100); +} + +function Network(ssid, mode, frequency, security, password, capabilities) { + this.ssid = ssid; + this.mode = mode; + this.frequency = frequency; + this.security = security; + + if (typeof password !== "undefined") + this.password = password; + if (capabilities !== undefined) + this.capabilities = capabilities; + // TODO connected here as well? + + this.__exposedProps__ = Network.api; +} + +Network.api = { + ssid: "r", + mode: "r", + frequency: "r", + security: "r", + capabilities: "r", + known: "r", + + password: "rw", + keyManagement: "rw", + psk: "rw", + identity: "rw", + wep: "rw", + hidden: "rw", + eap: "rw", + pin: "rw", + phase1: "rw", + phase2: "rw", + serverCertificate: "rw", + userCertificate: "rw" +}; + +// Note: We never use ScanResult.prototype, so the fact that it's unrelated to +// Network.prototype is OK. +function ScanResult(ssid, bssid, frequency, flags, signal) { + Network.call(this, ssid, getMode(flags), frequency, + getKeyManagement(flags), undefined, getCapabilities(flags)); + this.bssid = bssid; + this.signalStrength = signal; + this.relSignalStrength = calculateSignal(Number(signal)); + + this.__exposedProps__ = ScanResult.api; +} + +// XXX This should probably live in the DOM-facing side, but it's hard to do +// there, so we stick this here. +ScanResult.api = { + bssid: "r", + signalStrength: "r", + relSignalStrength: "r", + connected: "r" +}; + +for (let i in Network.api) { + ScanResult.api[i] = Network.api[i]; +} + +function quote(s) { + return '"' + s + '"'; +} + +function dequote(s) { + if (s[0] != '"' || s[s.length - 1] != '"') + throw "Invalid argument, not a quoted string: " + s; + return s.substr(1, s.length - 2); +} + +function isWepHexKey(s) { + if (s.length != 10 && s.length != 26 && s.length != 58) + return false; + return !/[^a-fA-F0-9]/.test(s); +} + + +var WifiNetworkInterface = { + + QueryInterface: XPCOMUtils.generateQI([Ci.nsINetworkInterface]), + + registered: false, + + // nsINetworkInterface + + NETWORK_STATE_UNKNOWN: Ci.nsINetworkInfo.NETWORK_STATE_UNKNOWN, + NETWORK_STATE_CONNECTING: Ci.nsINetworkInfo.CONNECTING, + NETWORK_STATE_CONNECTED: Ci.nsINetworkInfo.CONNECTED, + NETWORK_STATE_DISCONNECTING: Ci.nsINetworkInfo.DISCONNECTING, + NETWORK_STATE_DISCONNECTED: Ci.nsINetworkInfo.DISCONNECTED, + + NETWORK_TYPE_WIFI: Ci.nsINetworkInfo.NETWORK_TYPE_WIFI, + NETWORK_TYPE_MOBILE: Ci.nsINetworkInfo.NETWORK_TYPE_MOBILE, + NETWORK_TYPE_MOBILE_MMS: Ci.nsINetworkInfo.NETWORK_TYPE_MOBILE_MMS, + NETWORK_TYPE_MOBILE_SUPL: Ci.nsINetworkInfo.NETWORK_TYPE_MOBILE_SUPL, + + info: { + QueryInterface: XPCOMUtils.generateQI([Ci.nsINetworkInfo]), + + state: Ci.nsINetworkInfo.NETWORK_STATE_UNKNOWN, + + type: Ci.nsINetworkInfo.NETWORK_TYPE_WIFI, + + name: null, + + ips: [], + + prefixLengths: [], + + dnses: [], + + gateways: [], + + getAddresses: function (ips, prefixLengths) { + ips.value = this.ips.slice(); + prefixLengths.value = this.prefixLengths.slice(); + + return this.ips.length; + }, + + getGateways: function (count) { + if (count) { + count.value = this.gateways.length; + } + return this.gateways.slice(); + }, + + getDnses: function (count) { + if (count) { + count.value = this.dnses.length; + } + return this.dnses.slice(); + } + }, + + httpProxyHost: null, + + httpProxyPort: null +}; + +function WifiScanResult() {} + +// TODO Make the difference between a DOM-based network object and our +// networks objects much clearer. +var netToDOM; +var netFromDOM; + +function WifiWorker() { + var self = this; + + this._mm = Cc["@mozilla.org/parentprocessmessagemanager;1"] + .getService(Ci.nsIMessageListenerManager); + const messages = ["WifiManager:getNetworks", "WifiManager:getKnownNetworks", + "WifiManager:associate", "WifiManager:forget", + "WifiManager:wps", "WifiManager:getState", + "WifiManager:setPowerSavingMode", + "WifiManager:setHttpProxy", + "WifiManager:setStaticIpMode", + "WifiManager:importCert", + "WifiManager:getImportedCerts", + "WifiManager:deleteCert", + "WifiManager:setWifiEnabled", + "WifiManager:setWifiTethering", + "child-process-shutdown"]; + + messages.forEach((function(msgName) { + this._mm.addMessageListener(msgName, this); + }).bind(this)); + + Services.obs.addObserver(this, kMozSettingsChangedObserverTopic, false); + Services.obs.addObserver(this, "xpcom-shutdown", false); + + this.wantScanResults = []; + + this._needToEnableNetworks = false; + this._highestPriority = -1; + + // Networks is a map from SSID -> a scan result. + this.networks = Object.create(null); + + // ConfiguredNetworks is a map from SSID -> our view of a network. It only + // lists networks known to the wpa_supplicant. The SSID field (and other + // fields) are quoted for ease of use with WifiManager commands. + // Note that we don't have to worry about escaping embedded quotes since in + // all cases, the supplicant will take the last quotation that we pass it as + // the end of the string. + this.configuredNetworks = Object.create(null); + this._addingNetworks = Object.create(null); + + this.currentNetwork = null; + this.ipAddress = ""; + this.macAddress = null; + + this._lastConnectionInfo = null; + this._connectionInfoTimer = null; + this._reconnectOnDisconnect = false; + + // Create p2pObserver and assign to p2pManager. + if (WifiManager.p2pSupported()) { + this._p2pObserver = WifiP2pWorkerObserver(WifiManager.getP2pManager()); + WifiManager.getP2pManager().setObserver(this._p2pObserver); + + // Add DOM message observerd by p2pObserver to the message listener as well. + this._p2pObserver.getObservedDOMMessages().forEach((function(msgName) { + this._mm.addMessageListener(msgName, this); + }).bind(this)); + } + + // Users of instances of nsITimer should keep a reference to the timer until + // it is no longer needed in order to assure the timer is fired. + this._callbackTimer = null; + + // XXX On some phones (Otoro and Unagi) the wifi driver doesn't play nicely + // with the automatic scans that wpa_supplicant does (it appears that the + // driver forgets that it's returned scan results and then refuses to try to + // rescan. In order to detect this case we start a timer when we enter the + // SCANNING state and reset it whenever we either get scan results or leave + // the SCANNING state. If the timer fires, we assume that we are stuck and + // forceably try to unstick the supplican, also turning on background + // scanning to avoid having to constantly poke the supplicant. + + // How long we wait is controlled by the SCAN_STUCK_WAIT constant. + const SCAN_STUCK_WAIT = 12000; + this._scanStuckTimer = null; + this._turnOnBackgroundScan = false; + + function startScanStuckTimer() { + if (WifiManager.schedScanRecovery) { + self._scanStuckTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + self._scanStuckTimer.initWithCallback(scanIsStuck, SCAN_STUCK_WAIT, + Ci.nsITimer.TYPE_ONE_SHOT); + } + } + + function scanIsStuck() { + // Uh-oh, we've waited too long for scan results. Disconnect (which + // guarantees that we leave the SCANNING state and tells wpa_supplicant to + // wait for our next command) ensure that background scanning is on and + // then try again. + debug("Determined that scanning is stuck, turning on background scanning!"); + WifiManager.handlePostWifiScan(); + WifiManager.disconnect(function(ok) {}); + self._turnOnBackgroundScan = true; + } + + // A list of requests to turn wifi on or off. + this._stateRequests = []; + + // Given a connection status network, takes a network from + // self.configuredNetworks and prepares it for the DOM. + netToDOM = function(net) { + if (!net) { + return null; + } + var ssid = dequote(net.ssid); + var mode = net.mode; + var frequency = net.frequency; + var security = (net.key_mgmt === "NONE" && net.wep_key0) ? ["WEP"] : + (net.key_mgmt && net.key_mgmt !== "NONE") ? [net.key_mgmt.split(" ")[0]] : + []; + var password; + if (("psk" in net && net.psk) || + ("password" in net && net.password) || + ("wep_key0" in net && net.wep_key0)) { + password = "*"; + } + + var pub = new Network(ssid, mode, frequency, security, password); + if (net.identity) + pub.identity = dequote(net.identity); + if ("netId" in net) + pub.known = true; + if (net.scan_ssid === 1) + pub.hidden = true; + if ("ca_cert" in net && net.ca_cert && + net.ca_cert.indexOf("keystore://WIFI_SERVERCERT_" === 0)) { + pub.serverCertificate = net.ca_cert.substr(27); + } + if(net.subject_match) { + pub.subjectMatch = net.subject_match; + } + if ("client_cert" in net && net.client_cert && + net.client_cert.indexOf("keystore://WIFI_USERCERT_" === 0)) { + pub.userCertificate = net.client_cert.substr(25); + } + return pub; + }; + + netFromDOM = function(net, configured) { + // Takes a network from the DOM and makes it suitable for insertion into + // self.configuredNetworks (that is calling addNetwork will do the right + // thing). + // NB: Modifies net in place: safe since we don't share objects between + // the dom and the chrome code. + + // Things that are useful for the UI but not to us. + delete net.bssid; + delete net.signalStrength; + delete net.relSignalStrength; + delete net.security; + delete net.capabilities; + + if (!configured) + configured = {}; + + net.ssid = quote(net.ssid); + + let wep = false; + if ("keyManagement" in net) { + if (net.keyManagement === "WEP") { + wep = true; + net.keyManagement = "NONE"; + } else if (net.keyManagement === "WPA-EAP") { + net.keyManagement += " IEEE8021X"; + } + + configured.key_mgmt = net.key_mgmt = net.keyManagement; // WPA2-PSK, WPA-PSK, etc. + delete net.keyManagement; + } else { + configured.key_mgmt = net.key_mgmt = "NONE"; + } + + if (net.hidden) { + configured.scan_ssid = net.scan_ssid = 1; + delete net.hidden; + } + + function checkAssign(name, checkStar) { + if (name in net) { + let value = net[name]; + if (!value || (checkStar && value === '*')) { + if (name in configured) + net[name] = configured[name]; + else + delete net[name]; + } else { + configured[name] = net[name] = quote(value); + } + } + } + + checkAssign("psk", true); + checkAssign("identity", false); + checkAssign("password", true); + if (wep && net.wep && net.wep != '*') { + configured.wep_key0 = net.wep_key0 = isWepHexKey(net.wep) ? net.wep : quote(net.wep); + configured.auth_alg = net.auth_alg = "OPEN SHARED"; + } + + function hasValidProperty(name) { + return ((name in net) && net[name] != null); + } + + if (hasValidProperty("eap")) { + if (hasValidProperty("pin")) { + net.pin = quote(net.pin); + } + + if (hasValidProperty("phase1")) + net.phase1 = quote(net.phase1); + + if (hasValidProperty("phase2")) { + if (net.phase2 === "TLS") { + net.phase2 = quote("autheap=" + net.phase2); + } else { // PAP, MSCHAPV2, etc. + net.phase2 = quote("auth=" + net.phase2); + } + } + + if (hasValidProperty("serverCertificate")) + net.ca_cert = quote("keystore://WIFI_SERVERCERT_" + net.serverCertificate); + + if (hasValidProperty("subjectMatch")) + net.subject_match = quote(net.subjectMatch); + + if (hasValidProperty("userCertificate")) { + let userCertName = "WIFI_USERCERT_" + net.userCertificate; + net.client_cert = quote("keystore://" + userCertName); + + let wifiCertService = Cc["@mozilla.org/wifi/certservice;1"]. + getService(Ci.nsIWifiCertService); + if (wifiCertService.hasPrivateKey(userCertName)) { + if (WifiManager.sdkVersion() >= 19) { + // Use openssol engine instead of keystore protocol after Kitkat. + net.engine = 1; + net.engine_id = quote("keystore"); + net.key_id = quote("WIFI_USERKEY_" + net.userCertificate); + } else { + net.private_key = quote("keystore://WIFI_USERKEY_" + net.userCertificate); + } + } + } + } + + return net; + }; + + WifiManager.onsupplicantconnection = function() { + debug("Connected to supplicant"); + // Give it a state other than UNINITIALIZED, INITIALIZING or DISABLING + // defined in getter function of WifiManager.enabled. It implies that + // we are ready to accept dom request from applications. + WifiManager.state = "DISCONNECTED"; + self._reloadConfiguredNetworks(function(ok) { + // Prime this.networks. + if (!ok) + return; + + // The select network command we used in associate() disables others networks. + // Enable them here to make sure wpa_supplicant helps to connect to known + // network automatically. + self._enableAllNetworks(); + WifiManager.saveConfig(function() {}) + }); + + // Notify everybody, even if they didn't ask us to come up. + WifiManager.getMacAddress(function (mac) { + self.macAddress = mac; + debug("Got mac: " + mac); + self._fireEvent("wifiUp", { macAddress: mac }); + self.requestDone(); + }); + + if (WifiManager.state === "SCANNING") + startScanStuckTimer(); + }; + + WifiManager.onsupplicantlost = function() { + WifiManager.supplicantStarted = false; + WifiManager.state = "UNINITIALIZED"; + debug("Supplicant died!"); + + // Notify everybody, even if they didn't ask us to come up. + self._fireEvent("wifiDown", {}); + self.requestDone(); + }; + + WifiManager.onpasswordmaybeincorrect = function() { + WifiManager.authenticationFailuresCount++; + }; + + WifiManager.ondisconnected = function() { + // We may fail to establish the connection, re-enable the + // rest of our networks. + if (self._needToEnableNetworks) { + self._enableAllNetworks(); + self._needToEnableNetworks = false; + } + + let connectionInfo = this.connectionInfo; + WifiManager.getNetworkId(connectionInfo.ssid, function(netId) { + // Trying to get netId from current network. + if (!netId && + self.currentNetwork && self.currentNetwork.ssid && + dequote(self.currentNetwork.ssid) == connectionInfo.ssid && + typeof self.currentNetwork.netId !== "undefined") { + netId = self.currentNetwork.netId; + } + if (netId) { + WifiManager.disableNetwork(netId, function() {}); + } + }); + self._fireEvent("onconnectingfailed", {network: netToDOM(self.currentNetwork)}); + } + + WifiManager.onstatechange = function() { + debug("State change: " + this.prevState + " -> " + this.state); + + if (self._connectionInfoTimer && + this.state !== "CONNECTED" && + this.state !== "COMPLETED") { + self._stopConnectionInfoTimer(); + } + + if (this.state !== "SCANNING" && + self._scanStuckTimer) { + self._scanStuckTimer.cancel(); + self._scanStuckTimer = null; + } + + switch (this.state) { + case "DORMANT": + // The dormant state is a bad state to be in since we won't + // automatically connect. Try to knock us out of it. We only + // hit this state when we've failed to run DHCP, so trying + // again isn't the worst thing we can do. Eventually, we'll + // need to detect if we're looping in this state and bail out. + WifiManager.reconnect(function(){}); + break; + case "ASSOCIATING": + // id has not yet been filled in, so we can only report the ssid and + // bssid. mode and frequency are simply made up. + self.currentNetwork = + { bssid: WifiManager.connectionInfo.bssid, + ssid: quote(WifiManager.connectionInfo.ssid), + mode: MODE_ESS, + frequency: 0}; + WifiManager.getNetworkConfiguration(self.currentNetwork, function (){ + // Notify again because we get complete network information. + self._fireEvent("onconnecting", { network: netToDOM(self.currentNetwork) }); + }); + break; + case "ASSOCIATED": + // set to full power mode when ready to do 4 way handsharke. + WifiManager.setPowerSavingMode(false); + if (!self.currentNetwork) { + self.currentNetwork = + { bssid: WifiManager.connectionInfo.bssid, + ssid: quote(WifiManager.connectionInfo.ssid) }; + } + self.currentNetwork.netId = this.id; + WifiManager.getNetworkConfiguration(self.currentNetwork, function (){ + // Notify again because we get complete network information. + self._fireEvent("onconnecting", { network: netToDOM(self.currentNetwork) }); + }); + break; + case "COMPLETED": + // Now that we've successfully completed the connection, re-enable the + // rest of our networks. + // XXX Need to do this eventually if the user entered an incorrect + // password. For now, we require user interaction to break the loop and + // select a better network! + if (self._needToEnableNetworks) { + self._enableAllNetworks(); + self._needToEnableNetworks = false; + } + + var _oncompleted = function() { + // The full authentication process is completed, reset the count. + WifiManager.authenticationFailuresCount = 0; + WifiManager.loopDetectionCount = 0; + self._startConnectionInfoTimer(); + self._fireEvent("onassociate", { network: netToDOM(self.currentNetwork) }); + }; + + // We get the ASSOCIATED event when we've associated but not connected, so + // wait until the handshake is complete. + if (this.fromStatus || !self.currentNetwork) { + // In this case, we connected to an already-connected wpa_supplicant, + // because of that we need to gather information about the current + // network here. + self.currentNetwork = { bssid: WifiManager.connectionInfo.bssid, + ssid: quote(WifiManager.connectionInfo.ssid), + netId: WifiManager.connectionInfo.id }; + WifiManager.getNetworkConfiguration(self.currentNetwork, _oncompleted); + } else { + _oncompleted(); + } + break; + case "CONNECTED": + // wifi connection complete, turn on the power saving mode. + WifiManager.setPowerSavingMode(true); + // BSSID is read after connected, update it. + self.currentNetwork.bssid = WifiManager.connectionInfo.bssid; + break; + case "DISCONNECTED": + // wpa_supplicant may give us a "DISCONNECTED" event even if + // we are already in "DISCONNECTED" state. + if ((WifiNetworkInterface.info.state === + Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED) && + (this.prevState === "INITIALIZING" || + this.prevState === "DISCONNECTED" || + this.prevState === "INTERFACE_DISABLED" || + this.prevState === "INACTIVE" || + this.prevState === "UNINITIALIZED")) { + // When in disconnected mode, need to turn on wifi power saving mode. + WifiManager.setPowerSavingMode(true); + return; + } + + self._fireEvent("ondisconnect", {network: netToDOM(self.currentNetwork)}); + + self.currentNetwork = null; + self.ipAddress = ""; + + if (self._turnOnBackgroundScan) { + self._turnOnBackgroundScan = false; + WifiManager.setBackgroundScan("ON", function(did_something, ok) { + WifiManager.reassociate(function() {}); + }); + } + + WifiManager.connectionDropped(function() { + // We've disconnected from a network because of a call to forgetNetwork. + // Reconnect to the next available network (if any). + if (self._reconnectOnDisconnect) { + self._reconnectOnDisconnect = false; + WifiManager.reconnect(function(){}); + } + }); + + WifiNetworkInterface.info.state = + Ci.nsINetworkInfo.NETWORK_STATE_DISCONNECTED; + + // Update network infterface first then clear properties. + gNetworkManager.updateNetworkInterface(WifiNetworkInterface); + WifiNetworkInterface.info.ips = []; + WifiNetworkInterface.info.prefixLengths = []; + WifiNetworkInterface.info.gateways = []; + WifiNetworkInterface.info.dnses = []; + + + break; + case "WPS_TIMEOUT": + self._fireEvent("onwpstimeout", {}); + break; + case "WPS_FAIL": + self._fireEvent("onwpsfail", {}); + break; + case "WPS_OVERLAP_DETECTED": + self._fireEvent("onwpsoverlap", {}); + break; + case "AUTHENTICATING": + self._fireEvent("onauthenticating", {network: netToDOM(self.currentNetwork)}); + break; + case "SCANNING": + // If we're already scanning in the background, we don't need to worry + // about getting stuck while scanning. + if (!WifiManager.backgroundScanEnabled && WifiManager.enabled) + startScanStuckTimer(); + break; + } + }; + + WifiManager.onnetworkconnected = function() { + if (!this.info || !this.info.ipaddr_str) { + debug("Network information is invalid."); + return; + } + + let maskLength = + netHelpers.getMaskLength(netHelpers.stringToIP(this.info.mask_str)); + if (!maskLength) { + maskLength = 32; // max prefix for IPv4. + } + + let netConnect = WifiManager.getHttpProxyNetwork(self.currentNetwork); + if (netConnect) { + WifiNetworkInterface.httpProxyHost = netConnect.httpProxyHost; + WifiNetworkInterface.httpProxyPort = netConnect.httpProxyPort; + } + + WifiNetworkInterface.info.state = + Ci.nsINetworkInfo.NETWORK_STATE_CONNECTED; + WifiNetworkInterface.info.ips = [this.info.ipaddr_str]; + WifiNetworkInterface.info.prefixLengths = [maskLength]; + WifiNetworkInterface.info.gateways = [this.info.gateway_str]; + if (typeof this.info.dns1_str == "string" && + this.info.dns1_str.length) { + WifiNetworkInterface.info.dnses.push(this.info.dns1_str); + } + if (typeof this.info.dns2_str == "string" && + this.info.dns2_str.length) { + WifiNetworkInterface.info.dnses.push(this.info.dns2_str); + } + gNetworkManager.updateNetworkInterface(WifiNetworkInterface); + + self.ipAddress = this.info.ipaddr_str; + + // We start the connection information timer when we associate, but + // don't have our IP address until here. Make sure that we fire a new + // connectionInformation event with the IP address the next time the + // timer fires. + self._lastConnectionInfo = null; + self._fireEvent("onconnect", { network: netToDOM(self.currentNetwork) }); + }; + + WifiManager.onscanresultsavailable = function() { + if (self._scanStuckTimer) { + // We got scan results! We must not be stuck for now, try again. + self._scanStuckTimer.cancel(); + self._scanStuckTimer.initWithCallback(scanIsStuck, SCAN_STUCK_WAIT, + Ci.nsITimer.TYPE_ONE_SHOT); + } + + if (self.wantScanResults.length === 0) { + debug("Scan results available, but we don't need them"); + return; + } + + debug("Scan results are available! Asking for them."); + WifiManager.getScanResults(function(r) { + // Failure. + if (!r) { + self.wantScanResults.forEach(function(callback) { callback(null) }); + self.wantScanResults = []; + return; + } + + let capabilities = WifiManager.getCapabilities(); + + // Now that we have scan results, there's no more need to continue + // scanning. Ignore any errors from this command. + WifiManager.setScanMode("inactive", function() {}); + let lines = r.split("\n"); + // NB: Skip the header line. + self.networksArray = []; + for (let i = 1; i < lines.length; ++i) { + // bssid / frequency / signal level / flags / ssid + var match = /([\S]+)\s+([\S]+)\s+([\S]+)\s+(\[[\S]+\])?\s(.*)/.exec(lines[i]); + + if (match && match[5]) { + let ssid = match[5], + bssid = match[1], + frequency = match[2], + signalLevel = match[3], + flags = match[4]; + + /* Skip networks with unknown or unsupported modes. */ + if (capabilities.mode.indexOf(getMode(flags)) == -1) + continue; + + // If this is the first time that we've seen this SSID in the scan + // results, add it to the list along with any other information. + // Also, we use the highest signal strength that we see. + let network = new ScanResult(ssid, bssid, frequency, flags, signalLevel); + + let networkKey = getNetworkKey(network); + let eapIndex = -1; + if (networkKey in self.configuredNetworks) { + let known = self.configuredNetworks[networkKey]; + network.known = true; + + if ("identity" in known && known.identity) + network.identity = dequote(known.identity); + + // Note: we don't hand out passwords here! The * marks that there + // is a password that we're hiding. + if (("psk" in known && known.psk) || + ("password" in known && known.password) || + ("wep_key0" in known && known.wep_key0)) { + network.password = "*"; + } + } + + self.networksArray.push(network); + if (network.bssid === WifiManager.connectionInfo.bssid) + network.connected = true; + + let signal = calculateSignal(Number(match[3])); + if (signal > network.relSignalStrength) + network.relSignalStrength = signal; + } else if (!match) { + debug("Match didn't find anything for: " + lines[i]); + } + } + + self.wantScanResults.forEach(function(callback) { callback(self.networksArray) }); + self.wantScanResults = []; + }); + }; + + WifiManager.onstationinfoupdate = function() { + self._fireEvent("stationinfoupdate", { station: this.station }); + }; + + WifiManager.onstopconnectioninfotimer = function() { + self._stopConnectionInfoTimer(); + }; + + // Read the 'wifi.enabled' setting in order to start with a known + // value at boot time. The handle() will be called after reading. + // + // nsISettingsServiceCallback implementation. + var initWifiEnabledCb = { + handle: function handle(aName, aResult) { + if (aName !== SETTINGS_WIFI_ENABLED) + return; + if (aResult === null) + aResult = true; + self.handleWifiEnabled(aResult); + }, + handleError: function handleError(aErrorMessage) { + debug("Error reading the 'wifi.enabled' setting. Default to wifi on."); + self.handleWifiEnabled(true); + } + }; + + var initWifiDebuggingEnabledCb = { + handle: function handle(aName, aResult) { + if (aName !== SETTINGS_WIFI_DEBUG_ENABLED) + return; + if (aResult === null) + aResult = false; + DEBUG = aResult; + updateDebug(); + }, + handleError: function handleError(aErrorMessage) { + debug("Error reading the 'wifi.debugging.enabled' setting. Default to debugging off."); + DEBUG = false; + updateDebug(); + } + }; + + this.initTetheringSettings(); + + let lock = gSettingsService.createLock(); + lock.get(SETTINGS_WIFI_ENABLED, initWifiEnabledCb); + lock.get(SETTINGS_WIFI_DEBUG_ENABLED, initWifiDebuggingEnabledCb); + + lock.get(SETTINGS_WIFI_SSID, this); + lock.get(SETTINGS_WIFI_SECURITY_TYPE, this); + lock.get(SETTINGS_WIFI_SECURITY_PASSWORD, this); + lock.get(SETTINGS_WIFI_IP, this); + lock.get(SETTINGS_WIFI_PREFIX, this); + lock.get(SETTINGS_WIFI_DHCPSERVER_STARTIP, this); + lock.get(SETTINGS_WIFI_DHCPSERVER_ENDIP, this); + lock.get(SETTINGS_WIFI_DNS1, this); + lock.get(SETTINGS_WIFI_DNS2, this); + lock.get(SETTINGS_WIFI_TETHERING_ENABLED, this); + + lock.get(SETTINGS_USB_DHCPSERVER_STARTIP, this); + lock.get(SETTINGS_USB_DHCPSERVER_ENDIP, this); + + this._wifiTetheringSettingsToRead = [SETTINGS_WIFI_SSID, + SETTINGS_WIFI_SECURITY_TYPE, + SETTINGS_WIFI_SECURITY_PASSWORD, + SETTINGS_WIFI_IP, + SETTINGS_WIFI_PREFIX, + SETTINGS_WIFI_DHCPSERVER_STARTIP, + SETTINGS_WIFI_DHCPSERVER_ENDIP, + SETTINGS_WIFI_DNS1, + SETTINGS_WIFI_DNS2, + SETTINGS_WIFI_TETHERING_ENABLED, + SETTINGS_USB_DHCPSERVER_STARTIP, + SETTINGS_USB_DHCPSERVER_ENDIP]; +} + +function translateState(state) { + switch (state) { + case "INTERFACE_DISABLED": + case "INACTIVE": + case "SCANNING": + case "DISCONNECTED": + default: + return "disconnected"; + + case "AUTHENTICATING": + case "ASSOCIATING": + case "ASSOCIATED": + case "FOUR_WAY_HANDSHAKE": + case "GROUP_HANDSHAKE": + return "connecting"; + + case "COMPLETED": + return WifiManager.getDhcpInfo() ? "connected" : "associated"; + } +} + +WifiWorker.prototype = { + classID: WIFIWORKER_CID, + classInfo: XPCOMUtils.generateCI({classID: WIFIWORKER_CID, + contractID: WIFIWORKER_CONTRACTID, + classDescription: "WifiWorker", + interfaces: [Ci.nsIWorkerHolder, + Ci.nsIWifi, + Ci.nsIObserver]}), + + QueryInterface: XPCOMUtils.generateQI([Ci.nsIWorkerHolder, + Ci.nsIWifi, + Ci.nsIObserver, + Ci.nsISettingsServiceCallback]), + + disconnectedByWifi: false, + + disconnectedByWifiTethering: false, + + _wifiTetheringSettingsToRead: [], + + _oldWifiTetheringEnabledState: null, + + tetheringSettings: {}, + + initTetheringSettings: function initTetheringSettings() { + this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] = null; + this.tetheringSettings[SETTINGS_WIFI_SSID] = DEFAULT_WIFI_SSID; + this.tetheringSettings[SETTINGS_WIFI_SECURITY_TYPE] = DEFAULT_WIFI_SECURITY_TYPE; + this.tetheringSettings[SETTINGS_WIFI_SECURITY_PASSWORD] = DEFAULT_WIFI_SECURITY_PASSWORD; + this.tetheringSettings[SETTINGS_WIFI_IP] = DEFAULT_WIFI_IP; + this.tetheringSettings[SETTINGS_WIFI_PREFIX] = DEFAULT_WIFI_PREFIX; + this.tetheringSettings[SETTINGS_WIFI_DHCPSERVER_STARTIP] = DEFAULT_WIFI_DHCPSERVER_STARTIP; + this.tetheringSettings[SETTINGS_WIFI_DHCPSERVER_ENDIP] = DEFAULT_WIFI_DHCPSERVER_ENDIP; + this.tetheringSettings[SETTINGS_WIFI_DNS1] = DEFAULT_DNS1; + this.tetheringSettings[SETTINGS_WIFI_DNS2] = DEFAULT_DNS2; + + this.tetheringSettings[SETTINGS_USB_DHCPSERVER_STARTIP] = DEFAULT_USB_DHCPSERVER_STARTIP; + this.tetheringSettings[SETTINGS_USB_DHCPSERVER_ENDIP] = DEFAULT_USB_DHCPSERVER_ENDIP; + }, + + // Internal methods. + waitForScan: function(callback) { + this.wantScanResults.push(callback); + }, + + // In order to select a specific network, we disable the rest of the + // networks known to us. However, in general, we want the supplicant to + // connect to which ever network it thinks is best, so when we select the + // proper network (or fail to), we need to re-enable the rest. + _enableAllNetworks: function() { + for (let key in this.configuredNetworks) { + let net = this.configuredNetworks[key]; + WifiManager.enableNetwork(net.netId, false, function(ok) { + net.disabled = ok ? 1 : 0; + }); + } + }, + + _startConnectionInfoTimer: function() { + if (this._connectionInfoTimer) + return; + + var self = this; + function getConnectionInformation() { + WifiManager.getConnectionInfo(function(connInfo) { + // See comments in calculateSignal for information about this. + if (!connInfo) { + self._lastConnectionInfo = null; + return; + } + + let { rssi, linkspeed } = connInfo; + if (rssi > 0) + rssi -= 256; + if (rssi <= MIN_RSSI) + rssi = MIN_RSSI; + else if (rssi >= MAX_RSSI) + rssi = MAX_RSSI; + + let info = { signalStrength: rssi, + relSignalStrength: calculateSignal(rssi), + linkSpeed: linkspeed, + ipAddress: self.ipAddress }; + let last = self._lastConnectionInfo; + + // Only fire the event if the link speed changed or the signal + // strength changed by more than 10%. + function tensPlace(percent) { + return (percent / 10) | 0; + } + + if (last && last.linkSpeed === info.linkSpeed && + last.ipAddress === info.ipAddress && + tensPlace(last.relSignalStrength) === tensPlace(info.relSignalStrength)) { + return; + } + + self._lastConnectionInfo = info; + debug("Firing connectioninfoupdate: " + uneval(info)); + self._fireEvent("connectioninfoupdate", info); + }); + } + + // Prime our _lastConnectionInfo immediately and fire the event at the + // same time. + getConnectionInformation(); + + // Now, set up the timer for regular updates. + this._connectionInfoTimer = + Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + this._connectionInfoTimer.init(getConnectionInformation, 5000, + Ci.nsITimer.TYPE_REPEATING_SLACK); + }, + + _stopConnectionInfoTimer: function() { + if (!this._connectionInfoTimer) + return; + + this._connectionInfoTimer.cancel(); + this._connectionInfoTimer = null; + this._lastConnectionInfo = null; + }, + + _reloadConfiguredNetworks: function(callback) { + WifiManager.getConfiguredNetworks((function(networks) { + if (!networks) { + debug("Unable to get configured networks"); + callback(false); + return; + } + + this._highestPriority = -1; + + // Convert between netId-based and ssid-based indexing. + for (let net in networks) { + let network = networks[net]; + delete networks[net]; + + if (!network.ssid) { + WifiManager.removeNetwork(network.netId, function() {}); + continue; + } + + if (network.hasOwnProperty("priority") && + network.priority > this._highestPriority) { + this._highestPriority = network.priority; + } + + let networkKey = getNetworkKey(network); + // Accept latest config of same network(same SSID and same security). + if (networks[networkKey]) { + WifiManager.removeNetwork(networks[networkKey].netId, function() {}); + } + networks[networkKey] = network; + } + + this.configuredNetworks = networks; + callback(true); + }).bind(this)); + }, + + // Important side effect: calls WifiManager.saveConfig. + _reprioritizeNetworks: function(callback) { + // First, sort the networks in orer of their priority. + var ordered = Object.getOwnPropertyNames(this.configuredNetworks); + let self = this; + ordered.sort(function(a, b) { + var neta = self.configuredNetworks[a], + netb = self.configuredNetworks[b]; + + // Sort unsorted networks to the end of the list. + if (isNaN(neta.priority)) + return isNaN(netb.priority) ? 0 : 1; + if (isNaN(netb.priority)) + return -1; + return netb.priority - neta.priority; + }); + + // Skip unsorted networks. + let newPriority = 0, i; + for (i = ordered.length - 1; i >= 0; --i) { + if (!isNaN(this.configuredNetworks[ordered[i]].priority)) + break; + } + + // No networks we care about? + if (i < 0) { + WifiManager.saveConfig(callback); + return; + } + + // Now assign priorities from 0 to length, starting with the smallest + // priority and heading towards the highest (note the dependency between + // total and i here). + let done = 0, errors = 0, total = i + 1; + for (; i >= 0; --i) { + let network = this.configuredNetworks[ordered[i]]; + network.priority = newPriority++; + + // Note: networkUpdated declared below since it happens logically after + // this loop. + WifiManager.updateNetwork(network, networkUpdated); + } + + function networkUpdated(ok) { + if (!ok) + ++errors; + if (++done === total) { + if (errors > 0) { + callback(false); + return; + } + + WifiManager.saveConfig(function(ok) { + if (!ok) { + callback(false); + return; + } + + self._reloadConfiguredNetworks(function(ok) { + callback(ok); + }); + }); + } + } + }, + + // nsIWifi + + _domManagers: [], + _fireEvent: function(message, data) { + this._domManagers.forEach(function(manager) { + // Note: We should never have a dead message manager here because we + // observe our child message managers shutting down, below. + manager.sendAsyncMessage("WifiManager:" + message, data); + }); + }, + + _sendMessage: function(message, success, data, msg) { + try { + msg.manager.sendAsyncMessage(message + (success ? ":OK" : ":NO"), + { data: data, rid: msg.rid, mid: msg.mid }); + } catch (e) { + debug("sendAsyncMessage error : " + e); + } + this._splicePendingRequest(msg); + }, + + _domRequest: [], + + _splicePendingRequest: function(msg) { + for (let i = 0; i < this._domRequest.length; i++) { + if (this._domRequest[i].msg === msg) { + this._domRequest.splice(i, 1); + return; + } + } + }, + + _clearPendingRequest: function() { + if (this._domRequest.length === 0) return; + this._domRequest.forEach((function(req) { + this._sendMessage(req.name + ":Return", false, "Wifi is disabled", req.msg); + }).bind(this)); + }, + + receiveMessage: function MessageManager_receiveMessage(aMessage) { + let msg = aMessage.data || {}; + msg.manager = aMessage.target; + + if (WifiManager.p2pSupported()) { + // If p2pObserver returns something truthy, return it! + // Otherwise, continue to do the rest of tasks. + var p2pRet = this._p2pObserver.onDOMMessage(aMessage); + if (p2pRet) { + return p2pRet; + } + } + + // Note: By the time we receive child-process-shutdown, the child process + // has already forgotten its permissions so we do this before the + // permissions check. + if (aMessage.name === "child-process-shutdown") { + let i; + if ((i = this._domManagers.indexOf(msg.manager)) != -1) { + this._domManagers.splice(i, 1); + } + for (i = this._domRequest.length - 1; i >= 0; i--) { + if (this._domRequest[i].msg.manager === msg.manager) { + this._domRequest.splice(i, 1); + } + } + return; + } + + if (!aMessage.target.assertPermission("wifi-manage")) { + return; + } + + // We are interested in DOMRequests only. + if (aMessage.name != "WifiManager:getState") { + this._domRequest.push({name: aMessage.name, msg:msg}); + } + + switch (aMessage.name) { + case "WifiManager:setWifiEnabled": + this.setWifiEnabled(msg); + break; + case "WifiManager:getNetworks": + this.getNetworks(msg); + break; + case "WifiManager:getKnownNetworks": + this.getKnownNetworks(msg); + break; + case "WifiManager:associate": + this.associate(msg); + break; + case "WifiManager:forget": + this.forget(msg); + break; + case "WifiManager:wps": + this.wps(msg); + break; + case "WifiManager:setPowerSavingMode": + this.setPowerSavingMode(msg); + break; + case "WifiManager:setHttpProxy": + this.setHttpProxy(msg); + break; + case "WifiManager:setStaticIpMode": + this.setStaticIpMode(msg); + break; + case "WifiManager:importCert": + this.importCert(msg); + break; + case "WifiManager:getImportedCerts": + this.getImportedCerts(msg); + break; + case "WifiManager:deleteCert": + this.deleteCert(msg); + break; + case "WifiManager:setWifiTethering": + this.setWifiTethering(msg); + break; + case "WifiManager:getState": { + let i; + if ((i = this._domManagers.indexOf(msg.manager)) === -1) { + this._domManagers.push(msg.manager); + } + + let net = this.currentNetwork ? netToDOM(this.currentNetwork) : null; + return { network: net, + connectionInfo: this._lastConnectionInfo, + enabled: WifiManager.enabled, + status: translateState(WifiManager.state), + macAddress: this.macAddress, + capabilities: WifiManager.getCapabilities()}; + } + } + }, + + getNetworks: function(msg) { + const message = "WifiManager:getNetworks:Return"; + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + let sent = false; + let callback = (function (networks) { + if (sent) + return; + sent = true; + this._sendMessage(message, networks !== null, networks, msg); + }).bind(this); + this.waitForScan(callback); + + WifiManager.scan(true, (function(ok) { + // If the scan command succeeded, we're done. + if (ok) + return; + + // Avoid sending multiple responses. + if (sent) + return; + + // Otherwise, let the client know that it failed, it's responsible for + // trying again in a few seconds. + sent = true; + this._sendMessage(message, false, "ScanFailed", msg); + }).bind(this)); + }, + + getWifiScanResults: function(callback) { + var count = 0; + var timer = null; + var self = this; + + if (!WifiManager.enabled) { + callback.onfailure(); + return; + } + + self.waitForScan(waitForScanCallback); + doScan(); + function doScan() { + WifiManager.scan(true, (function (ok) { + if (!ok) { + if (!timer) { + count = 0; + timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + } + + if (count++ >= 3) { + timer = null; + self.wantScanResults.splice(self.wantScanResults.indexOf(waitForScanCallback), 1); + callback.onfailure(); + return; + } + + // Else it's still running, continue waiting. + timer.initWithCallback(doScan, 10000, Ci.nsITimer.TYPE_ONE_SHOT); + return; + } + }).bind(this)); + } + + function waitForScanCallback(networks) { + if (networks === null) { + callback.onfailure(); + return; + } + + var wifiScanResults = new Array(); + var net; + for (let net in networks) { + let value = networks[net]; + wifiScanResults.push(transformResult(value)); + } + callback.onready(wifiScanResults.length, wifiScanResults); + } + + function transformResult(element) { + var result = new WifiScanResult(); + result.connected = false; + for (let id in element) { + if (id === "__exposedProps__") { + continue; + } + if (id === "security") { + result[id] = 0; + var security = element[id]; + for (let j = 0; j < security.length; j++) { + if (security[j] === "WPA-PSK") { + result[id] |= Ci.nsIWifiScanResult.WPA_PSK; + } else if (security[j] === "WPA-EAP") { + result[id] |= Ci.nsIWifiScanResult.WPA_EAP; + } else if (security[j] === "WEP") { + result[id] |= Ci.nsIWifiScanResult.WEP; + } else { + result[id] = 0; + } + } + } else { + result[id] = element[id]; + } + } + return result; + } + }, + + getKnownNetworks: function(msg) { + const message = "WifiManager:getKnownNetworks:Return"; + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + this._reloadConfiguredNetworks((function(ok) { + if (!ok) { + this._sendMessage(message, false, "Failed", msg); + return; + } + + var networks = []; + for (let networkKey in this.configuredNetworks) { + networks.push(netToDOM(this.configuredNetworks[networkKey])); + } + + this._sendMessage(message, true, networks, msg); + }).bind(this)); + }, + + _setWifiEnabledCallback: function(status) { + if (status !== 0) { + this.requestDone(); + return; + } + + // If we're enabling ourselves, then wait until we've connected to the + // supplicant to notify. If we're disabling, we take care of this in + // supplicantlost. + if (WifiManager.supplicantStarted) + WifiManager.start(); + }, + + /** + * Compatibility flags for detecting if Gaia is controlling wifi by settings + * or API, once API is called, gecko will no longer accept wifi enable + * control from settings. + * This is used to deal with compatibility issue while Gaia adopted to use + * API but gecko doesn't remove the settings code in time. + * TODO: Remove this flag in Bug 1050147 + */ + ignoreWifiEnabledFromSettings: false, + setWifiEnabled: function(msg) { + const message = "WifiManager:setWifiEnabled:Return"; + let self = this; + let enabled = msg.data; + + self.ignoreWifiEnabledFromSettings = true; + // No change. + if (enabled === WifiManager.enabled) { + this._sendMessage(message, true, true, msg); + return; + } + + // Can't enable wifi while hotspot mode is enabled. + if (enabled && (this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] || + WifiManager.isWifiTetheringEnabled(WifiManager.tetheringState))) { + self._sendMessage(message, false, "Can't enable Wifi while hotspot mode is enabled", msg); + return; + } + + WifiManager.setWifiEnabled(enabled, function(ok) { + if (ok === 0 || ok === "no change") { + self._sendMessage(message, true, true, msg); + + // Reply error to pending requests. + if (!enabled) { + self._clearPendingRequest(); + } else { + WifiManager.start(); + } + } else { + self._sendMessage(message, false, "Set wifi enabled failed", msg); + } + }); + }, + + _setWifiEnabled: function(enabled, callback) { + // Reply error to pending requests. + if (!enabled) { + this._clearPendingRequest(); + } + + WifiManager.setWifiEnabled(enabled, callback); + }, + + // requestDone() must be called to before callback complete(or error) + // so next queue in the request quene can be executed. + // TODO: Remove command queue in Bug 1050147 + queueRequest: function(data, callback) { + if (!callback) { + throw "Try to enqueue a request without callback"; + } + + let optimizeCommandList = ["setWifiEnabled", "setWifiApEnabled"]; + if (optimizeCommandList.indexOf(data.command) != -1) { + this._stateRequests = this._stateRequests.filter(function(element) { + return element.data.command !== data.command; + }); + } + + this._stateRequests.push({ + data: data, + callback: callback + }); + + this.nextRequest(); + }, + + getWifiTetheringParameters: function getWifiTetheringParameters(enable) { + if (this.useTetheringAPI) { + return this.getWifiTetheringConfiguration(enable); + } else { + return this.getWifiTetheringParametersBySetting(enable); + } + }, + + getWifiTetheringConfiguration: function getWifiTetheringConfiguration(enable) { + let config = {}; + let params = this.tetheringConfig; + + let check = function(field, _default) { + config[field] = field in params ? params[field] : _default; + }; + + check("ssid", DEFAULT_WIFI_SSID); + check("security", DEFAULT_WIFI_SECURITY_TYPE); + check("key", DEFAULT_WIFI_SECURITY_PASSWORD); + check("ip", DEFAULT_WIFI_IP); + check("prefix", DEFAULT_WIFI_PREFIX); + check("wifiStartIp", DEFAULT_WIFI_DHCPSERVER_STARTIP); + check("wifiEndIp", DEFAULT_WIFI_DHCPSERVER_ENDIP); + check("usbStartIp", DEFAULT_USB_DHCPSERVER_STARTIP); + check("usbEndIp", DEFAULT_USB_DHCPSERVER_ENDIP); + check("dns1", DEFAULT_DNS1); + check("dns2", DEFAULT_DNS2); + + config.enable = enable; + config.mode = enable ? WIFI_FIRMWARE_AP : WIFI_FIRMWARE_STATION; + config.link = enable ? NETWORK_INTERFACE_UP : NETWORK_INTERFACE_DOWN; + + // Check the format to prevent netd from crash. + if (enable && (!config.ssid || config.ssid == "")) { + debug("Invalid SSID value."); + return null; + } + + if (enable && (config.security != WIFI_SECURITY_TYPE_NONE && !config.key)) { + debug("Invalid security password."); + return null; + } + + // Using the default values here until application supports these settings. + if (config.ip == "" || config.prefix == "" || + config.wifiStartIp == "" || config.wifiEndIp == "" || + config.usbStartIp == "" || config.usbEndIp == "") { + debug("Invalid subnet information."); + return null; + } + + return config; + }, + + getWifiTetheringParametersBySetting: function getWifiTetheringParametersBySetting(enable) { + let ssid; + let securityType; + let securityId; + let interfaceIp; + let prefix; + let wifiDhcpStartIp; + let wifiDhcpEndIp; + let usbDhcpStartIp; + let usbDhcpEndIp; + let dns1; + let dns2; + + ssid = this.tetheringSettings[SETTINGS_WIFI_SSID]; + securityType = this.tetheringSettings[SETTINGS_WIFI_SECURITY_TYPE]; + securityId = this.tetheringSettings[SETTINGS_WIFI_SECURITY_PASSWORD]; + interfaceIp = this.tetheringSettings[SETTINGS_WIFI_IP]; + prefix = this.tetheringSettings[SETTINGS_WIFI_PREFIX]; + wifiDhcpStartIp = this.tetheringSettings[SETTINGS_WIFI_DHCPSERVER_STARTIP]; + wifiDhcpEndIp = this.tetheringSettings[SETTINGS_WIFI_DHCPSERVER_ENDIP]; + usbDhcpStartIp = this.tetheringSettings[SETTINGS_USB_DHCPSERVER_STARTIP]; + usbDhcpEndIp = this.tetheringSettings[SETTINGS_USB_DHCPSERVER_ENDIP]; + dns1 = this.tetheringSettings[SETTINGS_WIFI_DNS1]; + dns2 = this.tetheringSettings[SETTINGS_WIFI_DNS2]; + + // Check the format to prevent netd from crash. + if (!ssid || ssid == "") { + debug("Invalid SSID value."); + return null; + } + // Truncate ssid if its length of encoded to utf8 is longer than 32. + while (unescape(encodeURIComponent(ssid)).length > 32) + { + ssid = ssid.substring(0, ssid.length-1); + } + + if (securityType != WIFI_SECURITY_TYPE_NONE && + securityType != WIFI_SECURITY_TYPE_WPA_PSK && + securityType != WIFI_SECURITY_TYPE_WPA2_PSK) { + + debug("Invalid security type."); + return null; + } + if (securityType != WIFI_SECURITY_TYPE_NONE && !securityId) { + debug("Invalid security password."); + return null; + } + // Using the default values here until application supports these settings. + if (interfaceIp == "" || prefix == "" || + wifiDhcpStartIp == "" || wifiDhcpEndIp == "" || + usbDhcpStartIp == "" || usbDhcpEndIp == "") { + debug("Invalid subnet information."); + return null; + } + + return { + ssid: ssid, + security: securityType, + key: securityId, + ip: interfaceIp, + prefix: prefix, + wifiStartIp: wifiDhcpStartIp, + wifiEndIp: wifiDhcpEndIp, + usbStartIp: usbDhcpStartIp, + usbEndIp: usbDhcpEndIp, + dns1: dns1, + dns2: dns2, + enable: enable, + mode: enable ? WIFI_FIRMWARE_AP : WIFI_FIRMWARE_STATION, + link: enable ? NETWORK_INTERFACE_UP : NETWORK_INTERFACE_DOWN + }; + }, + + setWifiApEnabled: function(enabled, callback) { + let configuration = this.getWifiTetheringParameters(enabled); + + if (!configuration) { + this.requestDone(); + debug("Invalid Wifi Tethering configuration."); + return; + } + + WifiManager.setWifiApEnabled(enabled, configuration, callback); + }, + + associate: function(msg) { + const MAX_PRIORITY = 9999; + const message = "WifiManager:associate:Return"; + let network = msg.data; + + let privnet = network; + let dontConnect = privnet.dontConnect; + delete privnet.dontConnect; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + let self = this; + function networkReady() { + // saveConfig now before we disable most of the other networks. + function selectAndConnect() { + WifiManager.enableNetwork(privnet.netId, true, function (ok) { + if (ok) + self._needToEnableNetworks = true; + if (WifiManager.state === "DISCONNECTED" || + WifiManager.state === "SCANNING") { + WifiManager.reconnect(function (ok) { + self._sendMessage(message, ok, ok, msg); + }); + } else { + self._sendMessage(message, ok, ok, msg); + } + }); + } + + var selectAndConnectOrReturn = dontConnect ? + function() { + self._sendMessage(message, true, "Wifi has been recorded", msg); + } : selectAndConnect; + if (self._highestPriority >= MAX_PRIORITY) { + self._reprioritizeNetworks(selectAndConnectOrReturn); + } else { + WifiManager.saveConfig(selectAndConnectOrReturn); + } + } + + function connectToNetwork() { + WifiManager.updateNetwork(privnet, (function(ok) { + if (!ok) { + self._sendMessage(message, false, "Network is misconfigured", msg); + return; + } + + networkReady(); + })); + } + + let ssid = privnet.ssid; + let networkKey = getNetworkKey(privnet); + let configured; + + if (networkKey in this._addingNetworks) { + this._sendMessage(message, false, "Racing associates"); + return; + } + + if (networkKey in this.configuredNetworks) + configured = this.configuredNetworks[networkKey]; + + netFromDOM(privnet, configured); + + privnet.priority = ++this._highestPriority; + if (configured) { + privnet.netId = configured.netId; + // Sync priority back to configured so if priority reaches MAX_PRIORITY, + // it can be sorted correctly in _reprioritizeNetworks() because the + // function sort network based on priority in configure list. + configured.priority = privnet.priority; + + // When investigating Bug 1123680, we observed that gaia may unexpectedly + // request to associate with incorrect password before successfully + // forgetting the network. It would cause the network unable to connect + // subsequently. Aside from preventing the racing forget/associate, we + // also try to disable network prior to updating the network. + WifiManager.getNetworkId(dequote(configured.ssid), function(netId) { + if (netId) { + WifiManager.disableNetwork(netId, function() { + connectToNetwork(); + }); + } + else { + connectToNetwork(); + } + }); + } else { + // networkReady, above, calls saveConfig. We want to remember the new + // network as being enabled, which isn't the default, so we explicitly + // set it to being "enabled" before we add it and save the + // configuration. + privnet.disabled = 0; + this._addingNetworks[networkKey] = privnet; + WifiManager.addNetwork(privnet, (function(ok) { + delete this._addingNetworks[networkKey]; + + if (!ok) { + this._sendMessage(message, false, "Network is misconfigured", msg); + return; + } + + this.configuredNetworks[networkKey] = privnet; + networkReady(); + }).bind(this)); + } + }, + + forget: function(msg) { + const message = "WifiManager:forget:Return"; + let network = msg.data; + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + this._reloadConfiguredNetworks((function(ok) { + // Give it a chance to remove the network even if reload is failed. + if (!ok) { + debug("Warning !!! Failed to reload the configured networks"); + } + + let ssid = network.ssid; + let networkKey = getNetworkKey(network); + if (!(networkKey in this.configuredNetworks)) { + this._sendMessage(message, false, "Trying to forget an unknown network", msg); + return; + } + + let self = this; + let configured = this.configuredNetworks[networkKey]; + this._reconnectOnDisconnect = (this.currentNetwork && + (this.currentNetwork.ssid === ssid)); + WifiManager.removeNetwork(configured.netId, function(ok) { + if (self._needToEnableNetworks) { + self._enableAllNetworks(); + self._needToEnableNetworks = false; + } + + if (!ok) { + self._sendMessage(message, false, "Unable to remove the network", msg); + self._reconnectOnDisconnect = false; + return; + } + + WifiManager.saveConfig(function() { + self._reloadConfiguredNetworks(function() { + self._sendMessage(message, true, true, msg); + }); + }); + }); + }).bind(this)); + }, + + wps: function(msg) { + const message = "WifiManager:wps:Return"; + let self = this; + let detail = msg.data; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + if (detail.method === "pbc") { + WifiManager.wpsPbc(function(ok) { + if (ok) + self._sendMessage(message, true, true, msg); + else + self._sendMessage(message, false, "WPS PBC failed", msg); + }); + } else if (detail.method === "pin") { + WifiManager.wpsPin(detail, function(pin) { + if (pin) + self._sendMessage(message, true, pin, msg); + else + self._sendMessage(message, false, "WPS PIN failed", msg); + }); + } else if (detail.method === "cancel") { + WifiManager.wpsCancel(function(ok) { + if (ok) + self._sendMessage(message, true, true, msg); + else + self._sendMessage(message, false, "WPS Cancel failed", msg); + }); + } else { + self._sendMessage(message, false, "Invalid WPS method=" + detail.method, + msg); + } + }, + + setPowerSavingMode: function(msg) { + const message = "WifiManager:setPowerSavingMode:Return"; + let self = this; + let enabled = msg.data; + let mode = enabled ? "AUTO" : "ACTIVE"; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + // Some wifi drivers may not implement this command. Set power mode + // even if suspend optimization command failed. + WifiManager.setSuspendOptimizations(enabled, function(ok) { + WifiManager.setPowerMode(mode, function(ok) { + if (ok) { + self._sendMessage(message, true, true, msg); + } else { + self._sendMessage(message, false, "Set power saving mode failed", msg); + } + }); + }); + }, + + setHttpProxy: function(msg) { + const message = "WifiManager:setHttpProxy:Return"; + let self = this; + let network = msg.data.network; + let info = msg.data.info; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + WifiManager.configureHttpProxy(network, info, function(ok) { + if (ok) { + // If configured network is current connected network + // need update http proxy immediately. + let setNetworkKey = getNetworkKey(network); + let curNetworkKey = self.currentNetwork ? getNetworkKey(self.currentNetwork) : null; + if (setNetworkKey === curNetworkKey) + WifiManager.setHttpProxy(network); + + self._sendMessage(message, true, true, msg); + } else { + self._sendMessage(message, false, "Set http proxy failed", msg); + } + }); + }, + + setStaticIpMode: function(msg) { + const message = "WifiManager:setStaticIpMode:Return"; + let self = this; + let network = msg.data.network; + let info = msg.data.info; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + // To compatiable with DHCP returned info structure, do translation here + info.ipaddr_str = info.ipaddr; + info.proxy_str = info.proxy; + info.gateway_str = info.gateway; + info.dns1_str = info.dns1; + info.dns2_str = info.dns2; + + WifiManager.setStaticIpMode(network, info, function(ok) { + if (ok) { + self._sendMessage(message, true, true, msg); + } else { + self._sendMessage(message, false, "Set static ip mode failed", msg); + } + }); + }, + + importCert: function importCert(msg) { + const message = "WifiManager:importCert:Return"; + let self = this; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + WifiManager.importCert(msg.data, function(data) { + if (data.status === 0) { + let usageString = ["ServerCert", "UserCert"]; + let usageArray = []; + for (let i = 0; i < usageString.length; i++) { + if (data.usageFlag & (0x01 << i)) { + usageArray.push(usageString[i]); + } + } + + self._sendMessage(message, true, { + nickname: data.nickname, + usage: usageArray + }, msg); + } else { + self._sendMessage(message, false, "Import Cert failed", msg); + } + }); + }, + + getImportedCerts: function getImportedCerts(msg) { + const message = "WifiManager:getImportedCerts:Return"; + let self = this; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + let certDB = Cc["@mozilla.org/security/x509certdb;1"] + .getService(Ci.nsIX509CertDB); + if (!certDB) { + self._sendMessage(message, false, "Failed to query NSS DB service", msg); + } + + let certList = certDB.getCerts(); + if (!certList) { + self._sendMessage(message, false, "Failed to get certificate List", msg); + } + + let certListEnum = certList.getEnumerator(); + if (!certListEnum) { + self._sendMessage(message, false, "Failed to get certificate List enumerator", msg); + } + let importedCerts = { + ServerCert: [], + UserCert: [], + }; + let UsageMapping = { + SERVERCERT: "ServerCert", + USERCERT: "UserCert", + }; + + while (certListEnum.hasMoreElements()) { + let certInfo = certListEnum.getNext().QueryInterface(Ci.nsIX509Cert); + let certNicknameInfo = /WIFI\_([A-Z]*)\_(.*)/.exec(certInfo.nickname); + if (!certNicknameInfo) { + continue; + } + importedCerts[UsageMapping[certNicknameInfo[1]]].push(certNicknameInfo[2]); + } + + self._sendMessage(message, true, importedCerts, msg); + }, + + deleteCert: function deleteCert(msg) { + const message = "WifiManager:deleteCert:Return"; + let self = this; + + if (!WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is disabled", msg); + return; + } + + WifiManager.deleteCert(msg.data, function(data) { + self._sendMessage(message, data.status === 0, "Delete Cert failed", msg); + }); + }, + + // TODO : These two variables should be removed once GAIA uses tethering API. + useTetheringAPI : false, + tetheringConfig : {}, + + setWifiTethering: function setWifiTethering(msg) { + const message = "WifiManager:setWifiTethering:Return"; + let self = this; + let enabled = msg.data.enabled; + + this.useTetheringAPI = true; + this.tetheringConfig = msg.data.config; + + if (WifiManager.enabled) { + this._sendMessage(message, false, "Wifi is enabled", msg); + return; + } + + this.setWifiApEnabled(enabled, function() { + if ((enabled && WifiManager.tetheringState == "COMPLETED") || + (!enabled && WifiManager.tetheringState == "UNINITIALIZED")) { + self._sendMessage(message, true, msg.data, msg); + } else { + msg.data.reason = enabled ? + "Enable WIFI tethering faild" : "Disable WIFI tethering faild"; + self._sendMessage(message, false, msg.data, msg); + } + }); + }, + + // This is a bit ugly, but works. In particular, this depends on the fact + // that RadioManager never actually tries to get the worker from us. + get worker() { throw "Not implemented"; }, + + shutdown: function() { + debug("shutting down ..."); + this.queueRequest({command: "setWifiEnabled", value: false}, function(data) { + this._setWifiEnabled(false, this._setWifiEnabledCallback.bind(this)); + }.bind(this)); + }, + + // TODO: Remove command queue in Bug 1050147. + requestProcessing: false, // Hold while dequeue and execution a request. + // Released upon the request is fully executed, + // i.e, mostly after callback is done. + requestDone: function requestDone() { + this.requestProcessing = false; + this.nextRequest(); + }, + + nextRequest: function nextRequest() { + // No request to process + if (this._stateRequests.length === 0) { + return; + } + + // Handling request, wait for it. + if (this.requestProcessing) { + return; + } + + // Hold processing lock + this.requestProcessing = true; + + // Find next valid request + let request = this._stateRequests.shift(); + + request.callback(request.data); + }, + + notifyTetheringOn: function notifyTetheringOn() { + // It's really sad that we don't have an API to notify the wifi + // hotspot status. Toggle settings to let gaia know that wifi hotspot + // is enabled. + let self = this; + this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] = true; + this._oldWifiTetheringEnabledState = true; + gSettingsService.createLock().set( + SETTINGS_WIFI_TETHERING_ENABLED, + true, + { + handle: function(aName, aResult) { + self.requestDone(); + }, + handleError: function(aErrorMessage) { + self.requestDone(); + } + }); + }, + + notifyTetheringOff: function notifyTetheringOff() { + // It's really sad that we don't have an API to notify the wifi + // hotspot status. Toggle settings to let gaia know that wifi hotspot + // is disabled. + let self = this; + this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] = false; + this._oldWifiTetheringEnabledState = false; + gSettingsService.createLock().set( + SETTINGS_WIFI_TETHERING_ENABLED, + false, + { + handle: function(aName, aResult) { + self.requestDone(); + }, + handleError: function(aErrorMessage) { + self.requestDone(); + } + }); + }, + + handleWifiEnabled: function(enabled) { + if (this.ignoreWifiEnabledFromSettings) { + return; + } + + // Make sure Wifi hotspot is idle before switching to Wifi mode. + if (enabled) { + this.queueRequest({command: "setWifiApEnabled", value: false}, function(data) { + if (this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] || + WifiManager.isWifiTetheringEnabled(WifiManager.tetheringState)) { + this.disconnectedByWifi = true; + this.setWifiApEnabled(false, this.notifyTetheringOff.bind(this)); + } else { + this.requestDone(); + } + }.bind(this)); + } + + this.queueRequest({command: "setWifiEnabled", value: enabled}, function(data) { + this._setWifiEnabled(enabled, this._setWifiEnabledCallback.bind(this)); + }.bind(this)); + + if (!enabled) { + this.queueRequest({command: "setWifiApEnabled", value: true}, function(data) { + if (this.disconnectedByWifi) { + this.setWifiApEnabled(true, this.notifyTetheringOn.bind(this)); + } else { + this.requestDone(); + } + this.disconnectedByWifi = false; + }.bind(this)); + } + }, + + handleWifiTetheringEnabled: function(enabled) { + // Make sure Wifi is idle before switching to Wifi hotspot mode. + if (enabled) { + this.queueRequest({command: "setWifiEnabled", value: false}, function(data) { + if (WifiManager.isWifiEnabled(WifiManager.state)) { + this.disconnectedByWifiTethering = true; + this._setWifiEnabled(false, this._setWifiEnabledCallback.bind(this)); + } else { + this.requestDone(); + } + }.bind(this)); + } + + this.queueRequest({command: "setWifiApEnabled", value: enabled}, function(data) { + this.setWifiApEnabled(enabled, this.requestDone.bind(this)); + }.bind(this)); + + if (!enabled) { + this.queueRequest({command: "setWifiEnabled", value: true}, function(data) { + if (this.disconnectedByWifiTethering) { + this._setWifiEnabled(true, this._setWifiEnabledCallback.bind(this)); + } else { + this.requestDone(); + } + this.disconnectedByWifiTethering = false; + }.bind(this)); + } + }, + + // nsIObserver implementation + observe: function observe(subject, topic, data) { + switch (topic) { + case kMozSettingsChangedObserverTopic: + // To avoid WifiWorker setting the wifi again, don't need to deal with + // the "mozsettings-changed" event fired from internal setting. + if ("wrappedJSObject" in subject) { + subject = subject.wrappedJSObject; + } + if (subject.isInternalChange) { + return; + } + + this.handle(subject.key, subject.value); + break; + + case "xpcom-shutdown": + // Ensure the supplicant is detached from B2G to avoid XPCOM shutdown + // blocks forever. + WifiManager.ensureSupplicantDetached(() => { + let wifiService = Cc["@mozilla.org/wifi/service;1"].getService(Ci.nsIWifiProxyService); + wifiService.shutdown(); + let wifiCertService = Cc["@mozilla.org/wifi/certservice;1"].getService(Ci.nsIWifiCertService); + wifiCertService.shutdown(); + }); + break; + } + }, + + handle: function handle(aName, aResult) { + switch(aName) { + // TODO: Remove function call in Bug 1050147. + case SETTINGS_WIFI_ENABLED: + this.handleWifiEnabled(aResult) + break; + case SETTINGS_WIFI_DEBUG_ENABLED: + if (aResult === null) + aResult = false; + DEBUG = aResult; + updateDebug(); + break; + case SETTINGS_WIFI_TETHERING_ENABLED: + this._oldWifiTetheringEnabledState = this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED]; + // Fall through! + case SETTINGS_WIFI_SSID: + case SETTINGS_WIFI_SECURITY_TYPE: + case SETTINGS_WIFI_SECURITY_PASSWORD: + case SETTINGS_WIFI_IP: + case SETTINGS_WIFI_PREFIX: + case SETTINGS_WIFI_DHCPSERVER_STARTIP: + case SETTINGS_WIFI_DHCPSERVER_ENDIP: + case SETTINGS_WIFI_DNS1: + case SETTINGS_WIFI_DNS2: + case SETTINGS_USB_DHCPSERVER_STARTIP: + case SETTINGS_USB_DHCPSERVER_ENDIP: + // TODO: code related to wifi-tethering setting should be removed after GAIA + // use tethering API + if (this.useTetheringAPI) { + break; + } + + if (aResult !== null) { + this.tetheringSettings[aName] = aResult; + } + debug("'" + aName + "'" + " is now " + this.tetheringSettings[aName]); + let index = this._wifiTetheringSettingsToRead.indexOf(aName); + + if (index != -1) { + this._wifiTetheringSettingsToRead.splice(index, 1); + } + + if (this._wifiTetheringSettingsToRead.length) { + debug("We haven't read completely the wifi Tethering data from settings db."); + break; + } + + if (this._oldWifiTetheringEnabledState === this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED]) { + debug("No changes for SETTINGS_WIFI_TETHERING_ENABLED flag. Nothing to do."); + break; + } + + if (this._oldWifiTetheringEnabledState === null && + !this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED]) { + debug("Do nothing when initial settings for SETTINGS_WIFI_TETHERING_ENABLED flag is false."); + break; + } + + this._oldWifiTetheringEnabledState = this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED]; + this.handleWifiTetheringEnabled(aResult) + break; + }; + }, + + handleError: function handleError(aErrorMessage) { + debug("There was an error while reading Tethering settings."); + this.tetheringSettings = {}; + this.tetheringSettings[SETTINGS_WIFI_TETHERING_ENABLED] = false; + }, +}; + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([WifiWorker]); + +var debug; +function updateDebug() { + if (DEBUG) { + debug = function (s) { + dump("-*- WifiWorker component: " + s + "\n"); + }; + } else { + debug = function (s) {}; + } + WifiManager.syncDebug(); +} +updateDebug(); diff --git a/dom/wifi/WifiWorker.manifest b/dom/wifi/WifiWorker.manifest new file mode 100644 index 000000000..e33d6401a --- /dev/null +++ b/dom/wifi/WifiWorker.manifest @@ -0,0 +1 @@ +component {a14e8977-d259-433a-a88d-58dd44657e5b} WifiWorker.js diff --git a/dom/wifi/moz.build b/dom/wifi/moz.build new file mode 100644 index 000000000..d769c649c --- /dev/null +++ b/dom/wifi/moz.build @@ -0,0 +1,41 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +XPIDL_SOURCES += [ + 'nsIWifi.idl', + 'nsIWifiCertService.idl', + 'nsIWifiService.idl', +] + +XPIDL_MODULE = 'dom_wifi' + +EXTRA_COMPONENTS += [ + 'DOMWifiManager.js', + 'DOMWifiManager.manifest', + 'DOMWifiP2pManager.js', + 'DOMWifiP2pManager.manifest', + 'WifiWorker.js', + 'WifiWorker.manifest', +] + +EXTRA_JS_MODULES += [ + 'StateMachine.jsm', + 'WifiCommand.jsm', + 'WifiNetUtil.jsm', + 'WifiP2pManager.jsm', + 'WifiP2pWorkerObserver.jsm', +] + +if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gonk': + UNIFIED_SOURCES = [ + 'WifiCertService.cpp', + 'WifiHotspotUtils.cpp', + 'WifiProxyService.cpp', + 'WifiUtils.cpp', + ] + DEFINES['CERT_AddTempCertToPerm'] = '__CERT_AddTempCertToPerm' + +FINAL_LIBRARY = 'xul' diff --git a/dom/wifi/nsIWifi.idl b/dom/wifi/nsIWifi.idl new file mode 100644 index 000000000..82ab9a75b --- /dev/null +++ b/dom/wifi/nsIWifi.idl @@ -0,0 +1,60 @@ +/* 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/. */ + +#include "nsISupports.idl" +#include "nsIDOMDOMRequest.idl" +#include "nsIDOMEvent.idl" + +interface nsIVariant; + +[scriptable, uuid(cf1ac02b-1f39-446e-815b-651ac78d2233)] +interface nsIWifiScanResult : nsISupports { + readonly attribute DOMString ssid; + readonly attribute DOMString bssid; + + const int32_t WPA_PSK = 0x01; + const int32_t WPA_EAP = 0x02; + const int32_t WEP = 0x04; + readonly attribute uint32_t capabilities; + + /** + * Strength of the signal to network. + */ + readonly attribute uint32_t signalStrength; + + readonly attribute uint32_t relSignalStrength; + readonly attribute boolean connected; +}; + +[scriptable, uuid(a6931ebf-8493-4014-90e2-99f406999982)] +interface nsIWifiScanResultsReady : nsISupports { + + /** + * Callback with list of networks. + */ + void onready(in uint32_t count, [array, size_is(count)] in nsIWifiScanResult results); + + /** + * Callback if scanning for networks failed after 3 retry attempts. + */ + void onfailure(); +}; + +[scriptable, uuid(08dfefed-5c5d-4468-8c5d-2c65c24692d9)] +interface nsIWifi : nsISupports +{ + /** + * Shutdown the wifi system. + */ + void shutdown(); + + /** + * Returns the list of currently available networks as well as the list of + * currently configured networks. + * + * On success a callback is notified with the list of networks. + * On failure after 3 scan retry attempts a callback is notified of failure. + */ + void getWifiScanResults(in nsIWifiScanResultsReady callback); +}; diff --git a/dom/wifi/nsIWifiCertService.idl b/dom/wifi/nsIWifiCertService.idl new file mode 100644 index 000000000..fce2dd719 --- /dev/null +++ b/dom/wifi/nsIWifiCertService.idl @@ -0,0 +1,54 @@ +/* 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/. */ + +#include "nsISupports.idl" + +interface nsIDOMBlob; +interface nsIWifiEventListener; + +[scriptable, uuid(5d0edcd3-c2f1-4946-aae5-06adcbdf0992)] +interface nsIWifiCertService : nsISupports +{ + const unsigned short WIFI_CERT_USAGE_FLAG_SERVER = 0x01; + const unsigned short WIFI_CERT_USAGE_FLAG_USER = 0x02; + + void start(in nsIWifiEventListener listener); + void shutdown(); + + /** + * Import a certificate file. + * + * @param id + * Request ID. + * @param certBlob + * A Blob object containing raw data of certificate to be imported. + * @param certPassword + * Password of certificate. + * @param certNickname + * User assigned nickname for imported certificate. + */ + void importCert(in long id, + in nsIDOMBlob certBlob, + in DOMString certPassword, + in DOMString certNickname); + + /** + * Delete an imported certificate file + * + * @param id + * Request ID. + * @param certNickname + * Certificate nickname to delete. + */ + void deleteCert(in long id, + in DOMString certNickname); + + /** + * Check if certificate has private key. + * + * @param certNickname + * Certificate nickname to check for private key. + */ + boolean hasPrivateKey(in DOMString certNickname); +}; diff --git a/dom/wifi/nsIWifiService.idl b/dom/wifi/nsIWifiService.idl new file mode 100644 index 000000000..0f320ddda --- /dev/null +++ b/dom/wifi/nsIWifiService.idl @@ -0,0 +1,22 @@ +/* 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/. */ + +#include "nsISupports.idl" + +[scriptable, uuid(4d4389e0-1547-11e3-8ffd-0800200c9a66)] +interface nsIWifiEventListener : nsISupports { + void onWaitEvent(in AString event, in ACString aInterface); + void onCommand(in jsval result, in ACString aInterface); +}; + +[scriptable, uuid(5e2bd8c0-1547-11e3-8ffd-0800200c9a66)] +interface nsIWifiProxyService : nsISupports { + void start(in nsIWifiEventListener listener, + [array, size_is(aNumOfInterface)] in string aInterfaces, + in unsigned long aNumOfInterface); + void shutdown(); + [implicit_jscontext] + void sendCommand(in jsval parameters, in ACString aInterface); + void waitForEvent(in ACString aInterface); +}; diff --git a/dom/wifi/test/marionette/head.js b/dom/wifi/test/marionette/head.js new file mode 100644 index 000000000..f4a212b11 --- /dev/null +++ b/dom/wifi/test/marionette/head.js @@ -0,0 +1,1486 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +// Emulate Promise.jsm semantics. +Promise.defer = function() { return new Deferred(); } +function Deferred() { + this.promise = new Promise(function(resolve, reject) { + this.resolve = resolve; + this.reject = reject; + }.bind(this)); + Object.freeze(this); +} + +const STOCK_HOSTAPD_NAME = 'goldfish-hostapd'; +const HOSTAPD_CONFIG_PATH = '/data/misc/wifi/remote-hostapd/'; + +const SETTINGS_RIL_DATA_ENABLED = 'ril.data.enabled'; +const SETTINGS_TETHERING_WIFI_ENABLED = 'tethering.wifi.enabled'; +const SETTINGS_TETHERING_WIFI_IP = 'tethering.wifi.ip'; +const SETTINGS_TETHERING_WIFI_SECURITY = 'tethering.wifi.security.type'; + +const HOSTAPD_COMMON_CONFIG = { + driver: 'test', + ctrl_interface: '/data/misc/wifi/remote-hostapd', + test_socket: 'DIR:/data/misc/wifi/sockets', + hw_mode: 'b', + channel: '2', +}; + +const HOSTAPD_CONFIG_LIST = [ + { ssid: 'ap0' }, + + { ssid: 'ap1', + wpa: 1, + wpa_pairwise: 'TKIP CCMP', + wpa_passphrase: '12345678' + }, + + { ssid: 'ap2', + wpa: 2, + rsn_pairwise: 'CCMP', + wpa_passphrase: '12345678', + }, +]; + +var gTestSuite = (function() { + let suite = {}; + + // Private member variables of the returned object |suite|. + let wifiManager; + let wifiOrigEnabled; + let pendingEmulatorShellCount = 0; + let sdkVersion; + + /** + * A wrapper function of "is". + * + * Calls the marionette function "is" as well as throws an exception + * if the givens values are not equal. + * + * @param value1 + * Any type of value to compare. + * + * @param value2 + * Any type of value to compare. + * + * @param message + * Debug message for this check. + * + */ + function isOrThrow(value1, value2, message) { + is(value1, value2, message); + if (value1 !== value2) { + throw message; + } + } + + /** + * Send emulator shell command with safe guard. + * + * We should only call |finish()| after all emulator command transactions + * end, so here comes with the pending counter. Resolve when the emulator + * gives positive response, and reject otherwise. + * + * Fulfill params: + * result -- an array of emulator response lines. + * Reject params: + * result -- an array of emulator response lines. + * + * @param aCommand + * A string command to be passed to emulator through its telnet console. + * + * @return A deferred promise. + */ + function runEmulatorShellSafe(aCommand) { + let deferred = Promise.defer(); + + ++pendingEmulatorShellCount; + runEmulatorShell(aCommand, function(aResult) { + --pendingEmulatorShellCount; + + ok(true, "Emulator shell response: " + JSON.stringify(aResult)); + if (Array.isArray(aResult)) { + deferred.resolve(aResult); + } else { + deferred.reject(aResult); + } + }); + + return deferred.promise; + } + + /** + * Wait for one named MozWifiManager event. + * + * Resolve if that named event occurs. Never reject. + * + * Fulfill params: the DOMEvent passed. + * + * @param aEventName + * A string event name. + * + * @return A deferred promise. + */ + function waitForWifiManagerEventOnce(aEventName) { + let deferred = Promise.defer(); + + wifiManager.addEventListener(aEventName, function onevent(aEvent) { + wifiManager.removeEventListener(aEventName, onevent); + + ok(true, "WifiManager event '" + aEventName + "' got."); + deferred.resolve(aEvent); + }); + + return deferred.promise; + } + + /** + * Wait for one named MozMobileConnection event. + * + * Resolve if that named event occurs. Never reject. + * + * Fulfill params: the DOMEvent passed. + * + * @param aEventName + * A string event name. + * + * @return A deferred promise. + */ + function waitForMobileConnectionEventOnce(aEventName, aServiceId) { + aServiceId = aServiceId || 0; + + let deferred = Promise.defer(); + let mobileconnection = navigator.mozMobileConnections[aServiceId]; + + mobileconnection.addEventListener(aEventName, function onevent(aEvent) { + mobileconnection.removeEventListener(aEventName, onevent); + + ok(true, "Mobile connection event '" + aEventName + "' got."); + deferred.resolve(aEvent); + }); + + return deferred.promise; + } + + /** + * Get the detail of currently running processes containing the given name. + * + * Use shell command 'ps' to get the desired process's detail. Never reject. + * + * Fulfill params: + * result -- an array of { pname, pid } + * + * @param aProcessName + * The process to get the detail. + * + * @return A deferred promise. + */ + function getProcessDetail(aProcessName) { + return runEmulatorShellSafe(['ps']) + .then(processes => { + // Sample 'ps' output: + // + // USER PID PPID VSIZE RSS WCHAN PC NAME + // root 1 0 284 204 c009e6c4 0000deb4 S /init + // root 2 0 0 0 c0052c64 00000000 S kthreadd + // root 3 2 0 0 c0044978 00000000 S ksoftirqd/0 + // + let detail = []; + + processes.shift(); // Skip the first line. + for (let i = 0; i < processes.length; i++) { + let tokens = processes[i].split(/\s+/); + let pname = tokens[tokens.length - 1]; + let pid = tokens[1]; + if (-1 !== pname.indexOf(aProcessName)) { + detail.push({ pname: pname, pid: pid }); + } + } + + return detail; + }); + } + + /** + * Add required permissions for wifi testing. Never reject. + * + * The permissions required for wifi testing are 'wifi-manage' and 'settings-write'. + * Never reject. + * + * Fulfill params: (none) + * + * @return A deferred promise. + */ + function addRequiredPermissions() { + let deferred = Promise.defer(); + + let permissions = [{ 'type': 'wifi-manage', 'allow': 1, 'context': window.document }, + { 'type': 'settings-write', 'allow': 1, 'context': window.document }, + { 'type': 'settings-read', 'allow': 1, 'context': window.document }, + { 'type': 'settings-api-write', 'allow': 1, 'context': window.document }, + { 'type': 'settings-api-read', 'allow': 1, 'context': window.document }, + { 'type': 'mobileconnection', 'allow': 1, 'context': window.document }]; + + SpecialPowers.pushPermissions(permissions, function() { + deferred.resolve(); + }); + + return deferred.promise; + } + + /** + * Wrap DOMRequest onsuccess/onerror events to Promise resolve/reject. + * + * Fulfill params: A DOMEvent. + * Reject params: A DOMEvent. + * + * @param aRequest + * A DOMRequest instance. + * + * @return A deferred promise. + */ + function wrapDomRequestAsPromise(aRequest) { + let deferred = Promise.defer(); + + ok(aRequest instanceof DOMRequest, + "aRequest is instanceof " + aRequest.constructor); + + aRequest.addEventListener("success", function(aEvent) { + deferred.resolve(aEvent); + }); + aRequest.addEventListener("error", function(aEvent) { + deferred.reject(aEvent); + }); + + return deferred.promise; + } + + /** + * Ensure wifi is enabled/disabled. + * + * Issue a wifi enable/disable request if wifi is not in the desired state; + * return a resolved promise otherwise. Note that you cannot rely on this + * function to test the correctness of enabling/disabling wifi. + * (use requestWifiEnabled instead) + * + * Fulfill params: (none) + * Reject params: (none) + * + * @return a resolved promise or deferred promise. + */ + function ensureWifiEnabled(aEnabled, useAPI) { + if (wifiManager.enabled === aEnabled) { + log('Already ' + (aEnabled ? 'enabled' : 'disabled')); + return Promise.resolve(); + } + return requestWifiEnabled(aEnabled, useAPI); + } + + /** + * Issue a request to enable/disable wifi. + * + * This function will attempt to enable/disable wifi, by calling API or by + * writing settings 'wifi.enabled' regardless of the wifi state, based on the + * value of |userAPI| parameter. + * Default is using settings. + * + * Note there's a limitation of co-existance of both method, per bug 930355, + * that once enable/disable wifi by API, the settings method won't work until + * reboot. So the test of wifi enable API should be executed last. + * TODO: Remove settings method after enable/disable wifi by settings is + * removed after bug 1050147. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @return A deferred promise. + */ + function requestWifiEnabled(aEnabled, useAPI) { + return Promise.all([ + waitForWifiManagerEventOnce(aEnabled ? 'enabled' : 'disabled'), + useAPI ? + wrapDomRequestAsPromise(wifiManager.setWifiEnabled(aEnabled)) : + setSettings({ 'wifi.enabled': aEnabled }), + ]); + } + + /** + * Wait for RIL data being connected. + * + * This function will check |MozMobileConnection.data.connected| on + * every 'datachange' event. Resolve when |MozMobileConnection.data.connected| + * becomes the expected state. Never reject. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @param aConnected + * Boolean that indicates the desired data state. + * + * @param aServiceId [optional] + * A numeric DSDS service id. Default: 0. + * + * @return A deferred promise. + */ + function waitForRilDataConnected(aConnected, aServiceId) { + aServiceId = aServiceId || 0; + return waitForMobileConnectionEventOnce('datachange', aServiceId) + .then(function () { + let mobileconnection = navigator.mozMobileConnections[aServiceId]; + if (mobileconnection.data.connected !== aConnected) { + return waitForRilDataConnected(aConnected, aServiceId); + } + }); + } + + /** + * Request to enable/disable wifi tethering. + * + * Enable/disable wifi tethering by changing the settings value 'tethering.wifi.enabled'. + * Resolve when the routing is verified to set up successfully in 20 seconds. The polling + * period is 1 second. + * + * Fulfill params: (none) + * Reject params: The error message. + * + * @param aEnabled + * Boolean that indicates to enable or disable wifi tethering. + * + * @return A deferred promise. + */ + function requestTetheringEnabled(aEnabled) { + let RETRY_INTERVAL_MS = 1000; + let retryCnt = 20; + + return setSettings1(SETTINGS_TETHERING_WIFI_ENABLED, aEnabled) + .then(function waitForRoutingVerified() { + return verifyTetheringRouting(aEnabled) + .then(null, function onreject(aReason) { + + log('verifyTetheringRouting rejected due to ' + aReason + + ' (' + retryCnt + ')'); + + if (!retryCnt--) { + throw aReason; + } + + return waitForTimeout(RETRY_INTERVAL_MS).then(waitForRoutingVerified); + }); + }); + } + + /** + * Forget the given network. + * + * Resolve when we successfully forget the given network; reject when any error + * occurs. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @param aNetwork + * An object of MozWifiNetwork. + * + * @return A deferred promise. + */ + function forgetNetwork(aNetwork) { + let request = wifiManager.forget(aNetwork); + return wrapDomRequestAsPromise(request) + .then(event => event.target.result); + } + + /** + * Forget all known networks. + * + * Resolve when we successfully forget all the known network; + * reject when any error occurs. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @return A deferred promise. + */ + function forgetAllKnownNetworks() { + + function createForgetNetworkChain(aNetworks) { + let chain = Promise.resolve(); + + aNetworks.forEach(function (aNetwork) { + chain = chain.then(() => forgetNetwork(aNetwork)); + }); + + return chain; + } + + return getKnownNetworks() + .then(networks => createForgetNetworkChain(networks)); + } + + /** + * Get all known networks. + * + * Resolve when we get all the known networks; reject when any error + * occurs. + * + * Fulfill params: An array of MozWifiNetwork + * Reject params: (none) + * + * @return A deferred promise. + */ + function getKnownNetworks() { + let request = wifiManager.getKnownNetworks(); + return wrapDomRequestAsPromise(request) + .then(event => event.target.result); + } + + /** + * Set the given network to static ip mode. + * + * Resolve when we set static ip mode successfully; reject when any error + * occurs. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @return A deferred promise. + */ + function setStaticIpMode(aNetwork, aConfig) { + let request = wifiManager.setStaticIpMode(aNetwork, aConfig); + return wrapDomRequestAsPromise(request) + .then(event => event.target.result); + } + + /** + * Issue a request to scan all wifi available networks. + * + * Resolve when we get the scan result; reject when any error + * occurs. + * + * Fulfill params: An array of MozWifiNetwork + * Reject params: (none) + * + * @return A deferred promise. + */ + function requestWifiScan() { + let request = wifiManager.getNetworks(); + return wrapDomRequestAsPromise(request) + .then(event => event.target.result); + } + + /** + * Import a certificate with nickname and password. + * + * Resolve when we import certificate successfully; reject when any error + * occurs. + * + * Fulfill params: An object of certificate information. + * Reject params: (none) + * + * @return A deferred promise. + */ + function importCert(certBlob, password, nickname) { + let request = wifiManager.importCert(certBlob, password, nickname); + return wrapDomRequestAsPromise(request) + .then(event => event.target.result); + } + + /** + * Delete certificate of nickname. + * + * Resolve when we delete certificate successfully; reject when any error + * occurs. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @return A deferred promise. + */ + function deleteCert(nickname) { + let request = wifiManager.deleteCert(nickname); + return wrapDomRequestAsPromise(request) + .then(event => event.target.result); + } + + /** + * Get list of imported certificates. + * + * Resolve when we get certificate list successfully; reject when any error + * occurs. + * + * Fulfill params: Nickname of imported certificate arranged by usage. + * Reject params: (none) + * + * @return A deferred promise. + */ + function getImportedCerts() { + let request = wifiManager.getImportedCerts(); + return wrapDomRequestAsPromise(request) + .then(event => event.target.result); + } + + /** + * Request wifi scan and verify the scan result as well. + * + * Issue a wifi scan request and check if the result is expected. + * Since the old APs may be cached and the newly added APs may be + * still not scan-able, a couple of attempts are acceptable. + * Resolve if we eventually get the expected scan result; reject otherwise. + * + * Fulfill params: The scan result, which is an array of MozWifiNetwork + * Reject params: (none) + * + * @param aRetryCnt + * The maxmimum number of attempts until we get the expected scan result. + * @param aExpectedNetworks + * An array of object, each of which contains at least the |ssid| property. + * + * @return A deferred promise. + */ + function testWifiScanWithRetry(aRetryCnt, aExpectedNetworks) { + + // Check if every single ssid of each |aScanResult| exists in |aExpectedNetworks| + // as well as the length of |aScanResult| equals to |aExpectedNetworks|. + function isScanResultExpected(aScanResult) { + if (aScanResult.length !== aExpectedNetworks.length) { + return false; + } + + for (let i = 0; i < aScanResult.length; i++) { + if (-1 === getFirstIndexBySsid(aScanResult[i].ssid, aExpectedNetworks)) { + return false; + } + } + return true; + } + + return requestWifiScan() + .then(function (networks) { + if (isScanResultExpected(networks, aExpectedNetworks)) { + return networks; + } + if (aRetryCnt > 0) { + return testWifiScanWithRetry(aRetryCnt - 1, aExpectedNetworks); + } + throw 'Unexpected scan result!'; + }); + } + + /** + * Test wifi association. + * + * Associate with the given network object which is obtained by + * MozWifiManager.getNetworks() (i.e. MozWifiNetwork). + * Resolve when the 'connected' status change event is received. + * Note that we might see other events like 'connecting' + * before 'connected'. So we need to call |waitForWifiManagerEventOnce| + * again whenever non 'connected' event is seen. Never reject. + * + * Fulfill params: (none) + * + * @param aNetwork + * An object of MozWifiNetwork. + * + * @return A deferred promise. + */ + function testAssociate(aNetwork) { + setPasswordIfNeeded(aNetwork); + + let promises = []; + + // Register the event listerner to wait for 'connected' event first + // to avoid racing issue. + promises.push(waitForConnected(aNetwork)); + + // Then we do the association. + let request = wifiManager.associate(aNetwork); + promises.push(wrapDomRequestAsPromise(request)); + + return Promise.all(promises); + } + + function waitForConnected(aExpectedNetwork) { + return waitForWifiManagerEventOnce('statuschange') + .then(function onstatuschange(event) { + log("event.status: " + event.status); + log("event.network.ssid: " + (event.network ? event.network.ssid : '')); + + if ("connected" === event.status && + event.network.ssid === aExpectedNetwork.ssid) { + return; // Got expected 'connected' event from aNetwork.ssid. + } + + log('Not expected "connected" statuschange event. Wait again!'); + return waitForConnected(aExpectedNetwork); + }); + } + + /** + * Set the password for associating the given network if needed. + * + * Set the password by looking up HOSTAPD_CONFIG_LIST. This function + * will also set |keyManagement| properly. + * + * @param aNetwork + * The MozWifiNetwork object. + */ + function setPasswordIfNeeded(aNetwork) { + let i = getFirstIndexBySsid(aNetwork.ssid, HOSTAPD_CONFIG_LIST); + if (-1 === i) { + log('unknown ssid: ' + aNetwork.ssid); + return; // Unknown network. Assume insecure. + } + + if (!aNetwork.security.length) { + return; // No need to set password. + } + + let security = aNetwork.security[0]; + if (/PSK$/.test(security)) { + aNetwork.psk = HOSTAPD_CONFIG_LIST[i].wpa_passphrase; + aNetwork.keyManagement = 'WPA-PSK'; + } else if (/WEP$/.test(security)) { + aNetwork.wep = HOSTAPD_CONFIG_LIST[i].wpa_passphrase; + aNetwork.keyManagement = 'WEP'; + } + } + + /** + * Set mozSettings values. + * + * Resolve if that mozSettings value is set successfully, reject otherwise. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @param aSettings + * An object of format |{key1: value1, key2: value2, ...}|. + * @param aAllowError [optional] + * A boolean value. If set to true, an error response won't be treated + * as test failure. Default: false. + * + * @return A deferred promise. + */ + function setSettings(aSettings) { + let lock = window.navigator.mozSettings.createLock(); + let request = lock.set(aSettings); + let deferred = Promise.defer(); + lock.onsettingstransactionsuccess = function () { + ok(true, "setSettings(" + JSON.stringify(aSettings) + ")"); + deferred.resolve(); + }; + lock.onsettingstransactionfailure = function (aEvent) { + ok(false, "setSettings(" + JSON.stringify(aSettings) + ")"); + deferred.reject(); + throw aEvent.target.error; + }; + return deferred.promise; + } + + /** + * Set mozSettings value with only one key. + * + * Resolve if that mozSettings value is set successfully, reject otherwise. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @param aKey + * A string key. + * @param aValue + * An object value. + * @param aAllowError [optional] + * A boolean value. If set to true, an error response won't be treated + * as test failure. Default: false. + * + * @return A deferred promise. + */ + function setSettings1(aKey, aValue, aAllowError) { + let settings = {}; + settings[aKey] = aValue; + return setSettings(settings, aAllowError); + } + + /** + * Get mozSettings value specified by @aKey. + * + * Resolve if that mozSettings value is retrieved successfully, reject + * otherwise. + * + * Fulfill params: + * The corresponding mozSettings value of the key. + * Reject params: (none) + * + * @param aKey + * A string. + * @param aAllowError [optional] + * A boolean value. If set to true, an error response won't be treated + * as test failure. Default: false. + * + * @return A deferred promise. + */ + function getSettings(aKey, aAllowError) { + let request = + navigator.mozSettings.createLock().get(aKey); + return wrapDomRequestAsPromise(request) + .then(function resolve(aEvent) { + ok(true, "getSettings(" + aKey + ") - success"); + return aEvent.target.result[aKey]; + }, function reject(aEvent) { + ok(aAllowError, "getSettings(" + aKey + ") - error"); + }); + } + + + /** + * Start hostapd processes with given configuration list. + * + * For starting one hostapd, we need to generate a specific config file + * then launch a hostapd process with the confg file path passed. The + * config file is generated by two sources: one is the common + * part (HOSTAPD_COMMON_CONFIG) and the other is from the given |aConfigList|. + * Resolve when all the hostpads are requested to start. It is not guaranteed + * that all the hostapds will be up and running successfully. Never reject. + * + * Fulfill params: (none) + * + * @param aConfigList + * An array of config objects, each property in which will be + * output to the confg file with the format: [key]=[value] in one line. + * See http://hostap.epitest.fi/cgit/hostap/plain/hostapd/hostapd.conf + * for more information. + * + * @return A deferred promise. + */ + function startHostapds(aConfigList) { + + function createConfigFromCommon(aIndex) { + // Create an copy of HOSTAPD_COMMON_CONFIG. + let config = JSON.parse(JSON.stringify(HOSTAPD_COMMON_CONFIG)); + + // Add user config. + for (let key in aConfigList[aIndex]) { + config[key] = aConfigList[aIndex][key]; + } + + // 'interface' is a required field but no need of being configurable + // for a test case. So we initialize this field on our own. + config.interface = 'AP-' + aIndex; + + return config; + } + + function startOneHostapd(aIndex) { + let configFileName = HOSTAPD_CONFIG_PATH + 'ap' + aIndex + '.conf'; + return writeHostapdConfFile(configFileName, createConfigFromCommon(aIndex)) + .then(() => runEmulatorShellSafe(['hostapd', '-B', configFileName])) + .then(function (reply) { + // It may fail at the first time due to the previous ungracefully terminated one. + if (reply.length === 0) { + // The hostapd starts successfully + return; + } + + if (reply[0].indexOf('bind(PF_UNIX): Address already in use') !== -1) { + return startOneHostapd(aIndex); + } + }); + } + + return Promise.all(aConfigList.map(function(aConfig, aIndex) { + return startOneHostapd(aIndex); + })); + } + + /** + * Kill all the running hostapd processes. + * + * Use shell command 'kill -9' to kill all hostapds. Never reject. + * + * Fulfill params: (none) + * + * @return A deferred promise. + */ + function killAllHostapd() { + return getProcessDetail('hostapd') + .then(function (runningHostapds) { + let promises = runningHostapds.map(runningHostapd => { + return runEmulatorShellSafe(['kill', '-9', runningHostapd.pid]); + }); + return Promise.all(promises); + }); + } + + /** + * Write out the config file to the given path. + * + * For each key/value pair in |aConfig|, + * + * [key]=[value] + * + * will be output to one new line. Never reject. + * + * Fulfill params: (none) + * + * @param aFilePath + * The file path that we desire the config file to be located. + * + * @param aConfig + * The config object. + * + * @return A deferred promise. + */ + function writeHostapdConfFile(aFilePath, aConfig) { + let content = ''; + for (let key in aConfig) { + if (aConfig.hasOwnProperty(key)) { + content += (key + '=' + aConfig[key] + '\n'); + } + } + return writeFile(aFilePath, content); + } + + /** + * Write file to the given path filled with given content. + * + * For now it is implemented by shell command 'echo'. Also, if the + * content contains whitespace, we need to quote the content to + * avoid error. Never reject. + * + * Fulfill params: (none) + * + * @param aFilePath + * The file path that we desire the file to be located. + * + * @param aContent + * The content as string which should be written to the file. + * + * @return A deferred promise. + */ + function writeFile(aFilePath, aContent) { + const CONTENT_MAX_LENGTH = 900; + var commands = []; + for (var i = 0; i < aContent.length; i += CONTENT_MAX_LENGTH) { + var content = aContent.substr(i, CONTENT_MAX_LENGTH); + if (-1 === content.indexOf(' ')) { + content = '"' + content + '"'; + } + commands.push(['echo', '-n', content, i === 0 ? '>' : '>>', aFilePath]); + } + + let chain = Promise.resolve(); + commands.forEach(function (command) { + chain = chain.then(() => runEmulatorShellSafe(command)); + }); + return chain; + } + + /** + * Check if a init service is running or not. + * + * Check the android property 'init.svc.[aServiceName]' to determine if + * a init service is running. Reject if the propery is neither 'running' + * nor 'stopped'. + * + * Fulfill params: + * result -- |true| if the init service is running; |false| otherwise. + * Reject params: (none) + * + * @param aServiceName + * The init service name. + * + * @return A deferred promise. + */ + function isInitServiceRunning(aServiceName) { + return runEmulatorShellSafe(['getprop', 'init.svc.' + aServiceName]) + .then(function (result) { + if ('running' !== result[0] && 'stopped' !== result[0]) { + throw 'Init service running state should be "running" or "stopped".'; + } + return 'running' === result[0]; + }); + } + + /** + * Wait for timeout. + * + * Resolve when the given duration elapsed. Never reject. + * + * Fulfill params: (none) + * + * @param aTimeoutMs + * The duration after which the timeout event should occurs. + * + * @return A deferred promise. + */ + function waitForTimeout(aTimeoutMs) { + let deferred = Promise.defer(); + + setTimeout(function() { + deferred.resolve(); + }, aTimeoutMs); + + return deferred.promise; + } + + /** + * Start or stop an init service. + * + * Use shell command 'start'/'stop' to start/stop an init service. + * The running state will also be checked after we start/stop the service. + * Resolve if the service is successfully started/stopped; Reject otherwise. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @param aServiceName + * The name of the service we want to start/stop. + * + * @param aStart + * |true| for starting the init service. |false| for stopping. + * + * @return A deferred promise. + */ + function startStopInitService(aServiceName, aStart) { + let retryCnt = 5; + + return runEmulatorShellSafe([aStart ? 'start' : 'stop', aServiceName]) + .then(() => isInitServiceRunning(aServiceName)) + .then(function onIsServiceRunningResolved(aIsRunning) { + if (aStart === aIsRunning) { + return; + } + + if (retryCnt-- > 0) { + log('Failed to ' + (aStart ? 'start ' : 'stop ') + aServiceName + + '. Retry: ' + retryCnt); + + return waitForTimeout(500) + .then(() => isInitServiceRunning(aServiceName)) + .then(onIsServiceRunningResolved); + } + + throw 'Failed to ' + (aStart ? 'start' : 'stop') + ' ' + aServiceName; + }); + } + + /** + * Start the stock hostapd. + * + * Since the stock hostapd is an init service, use |startStopInitService| to + * start it. Note that we might fail to start the stock hostapd at the first time + * for unknown reason so give it the second chance to start again. + * Resolve when we are eventually successful to start the stock hostapd; Reject + * otherwise. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @return A deferred promise. + */ + function startStockHostapd() { + return startStopInitService(STOCK_HOSTAPD_NAME, true) + .then(null, function onreject() { + log('Failed to restart goldfish-hostapd at the first time. Try again!'); + return startStopInitService((STOCK_HOSTAPD_NAME), true); + }); + } + + /** + * Stop the stock hostapd. + * + * Since the stock hostapd is an init service, use |startStopInitService| to + * stop it. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @return A deferred promise. + */ + function stopStockHostapd() { + return startStopInitService(STOCK_HOSTAPD_NAME, false); + } + + /** + * Get the index of the first matching entry by |ssid|. + * + * Find the index of the first entry of |aArray| which property |ssid| + * is same as |aSsid|. + * + * @param aSsid + * The ssid that we want to match. + * @param aArray + * An array of objects, each of which should have the property |ssid|. + * + * @return The 0-based index of first matching entry if found; -1 otherwise. + */ + function getFirstIndexBySsid(aSsid, aArray) { + for (let i = 0; i < aArray.length; i++) { + if (aArray[i].ssid === aSsid) { + return i; + } + } + return -1; + } + + /** + * Count the number of running process and verify if the count is expected. + * + * Return a promise that resolves when the process has expected number + * of running instances and rejects otherwise. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @param aOrigWifiEnabled + * Boolean which indicates wifi was originally enabled. + * + * @return A deferred promise. + */ + function verifyNumOfProcesses(aProcessName, aExpectedNum) { + return getProcessDetail(aProcessName) + .then(function (detail) { + if (detail.length === aExpectedNum) { + return; + } + throw 'Unexpected number of running processes:' + aProcessName + + ', expected: ' + aExpectedNum + ', actual: ' + detail.length; + }); + } + + /** + * Execute 'netcfg' shell and parse the result. + * + * Resolve when the executing is successful and reject otherwise. + * + * Fulfill params: Command result object, each key of which is the interface + * name and value is { ip(string), prefix(string) }. + * Reject params: String that indicates the reason of rejection. + * + * @return A deferred promise. + */ + function exeAndParseNetcfg() { + return runEmulatorShellSafe(['netcfg']) + .then(function (aLines) { + // Sample output: + // + // lo UP 127.0.0.1/8 0x00000049 00:00:00:00:00:00 + // eth0 UP 10.0.2.15/24 0x00001043 52:54:00:12:34:56 + // rmnet1 DOWN 0.0.0.0/0 0x00001002 52:54:00:12:34:58 + // rmnet2 DOWN 0.0.0.0/0 0x00001002 52:54:00:12:34:59 + // rmnet3 DOWN 0.0.0.0/0 0x00001002 52:54:00:12:34:5a + // wlan0 UP 192.168.1.1/24 0x00001043 52:54:00:12:34:5b + // sit0 DOWN 0.0.0.0/0 0x00000080 00:00:00:00:00:00 + // rmnet0 UP 10.0.2.100/24 0x00001043 52:54:00:12:34:57 + // + let netcfgResult = {}; + aLines.forEach(function (aLine) { + let tokens = aLine.split(/\s+/); + if (tokens.length < 5) { + return; + } + let ifname = tokens[0]; + let [ip, prefix] = tokens[2].split('/'); + netcfgResult[ifname] = { ip: ip, prefix: prefix }; + }); + log("netcfg result:" + JSON.stringify(netcfgResult)); + + return netcfgResult; + }); + } + + /** + * Execute 'ip route' and parse the result. + * + * Resolve when the executing is successful and reject otherwise. + * + * Fulfill params: Command result object, each key of which is the interface + * name and value is { src(string), gateway(string), + * default(boolean) }. + * Reject params: String that indicates the reason of rejection. + * + * @return A deferred promise. + */ + function exeAndParseIpRoute() { + return runEmulatorShellSafe(['ip', 'route']) + .then(function (aLines) { + // Sample output: + // + // 10.0.2.4 via 10.0.2.2 dev rmnet0 + // 10.0.2.3 via 10.0.2.2 dev rmnet0 + // 192.168.1.0/24 dev wlan0 proto kernel scope link src 192.168.1.1 + // 10.0.2.0/24 dev eth0 proto kernel scope link src 10.0.2.15 + // 10.0.2.0/24 dev rmnet0 proto kernel scope link src 10.0.2.100 + // default via 10.0.2.2 dev rmnet0 + // default via 10.0.2.2 dev eth0 metric 2 + // + + let ipRouteResult = {}; + + // Parse source ip for each interface. + aLines.forEach(function (aLine) { + let tokens = aLine.trim().split(/\s+/); + let srcIndex = tokens.indexOf('src'); + if (srcIndex < 0 || srcIndex + 1 >= tokens.length) { + return; + } + let ifname = tokens[2]; + let src = tokens[srcIndex + 1]; + ipRouteResult[ifname] = { src: src, default: false, gateway: null }; + }); + + // Parse default interfaces. + aLines.forEach(function (aLine) { + let tokens = aLine.split(/\s+/); + if (tokens.length < 2) { + return; + } + if ('default' === tokens[0]) { + let ifnameIndex = tokens.indexOf('dev'); + if (ifnameIndex < 0 || ifnameIndex + 1 >= tokens.length) { + return; + } + let ifname = tokens[ifnameIndex + 1]; + if (!ipRouteResult[ifname]) { + return; + } + ipRouteResult[ifname].default = true; + let gwIndex = tokens.indexOf('via'); + if (gwIndex < 0 || gwIndex + 1 >= tokens.length) { + return; + } + ipRouteResult[ifname].gateway = tokens[gwIndex + 1]; + return; + } + }); + log("ip route result:" + JSON.stringify(ipRouteResult)); + + return ipRouteResult; + }); + } + + /** + * Verify everything about routing when the wifi tethering is either on or off. + * + * We use two unix commands to verify the routing: 'netcfg' and 'ip route'. + * For now the following two things will be checked: + * 1) The default route interface should be 'rmnet0'. + * 2) wlan0 is up and its ip is set to a private subnet. + * + * We also verify iptables output as netd's NatController will execute + * $ iptables -t nat -A POSTROUTING -o rmnet0 -j MASQUERADE + * + * Resolve when the verification is successful and reject otherwise. + * + * Fulfill params: (none) + * Reject params: String that indicates the reason of rejection. + * + * @return A deferred promise. + */ + function verifyTetheringRouting(aEnabled) { + let netcfgResult; + let ipRouteResult; + + // Find MASQUERADE in POSTROUTING section. 'MASQUERADE' should be found + // when tethering is enabled. 'MASQUERADE' shouldn't be found when tethering + // is disabled. + function verifyIptables() { + let MASQUERADE_checkSection = 'POSTROUTING'; + if (sdkVersion > 15) { + // Check 'natctrl_nat_POSTROUTING' section after ICS. + MASQUERADE_checkSection = 'natctrl_nat_POSTROUTING'; + } + + return runEmulatorShellSafe(['iptables', '-t', 'nat', '-L', MASQUERADE_checkSection]) + .then(function(aLines) { + // $ iptables -t nat -L POSTROUTING + // + // Sample output (tethering on): + // + // Chain POSTROUTING (policy ACCEPT) + // target prot opt source destination + // MASQUERADE all -- anywhere anywhere + // + let found = (function find_MASQUERADE() { + // Skip first two lines. + for (let i = 2; i < aLines.length; i++) { + if (-1 !== aLines[i].indexOf('MASQUERADE')) { + return true; + } + } + return false; + })(); + + if ((aEnabled && !found) || (!aEnabled && found)) { + throw 'MASQUERADE' + (found ? '' : ' not') + ' found while tethering is ' + + (aEnabled ? 'enabled' : 'disabled'); + } + }); + } + + function verifyDefaultRouteAndIp(aExpectedWifiTetheringIp) { + if (aEnabled) { + isOrThrow(ipRouteResult['rmnet0'].src, netcfgResult['rmnet0'].ip, 'rmnet0.ip'); + isOrThrow(ipRouteResult['rmnet0'].default, true, 'rmnet0.default'); + + isOrThrow(ipRouteResult['wlan0'].src, netcfgResult['wlan0'].ip, 'wlan0.ip'); + isOrThrow(ipRouteResult['wlan0'].src, aExpectedWifiTetheringIp, 'expected ip'); + isOrThrow(ipRouteResult['wlan0'].default, false, 'wlan0.default'); + } + } + + return verifyIptables() + .then(exeAndParseNetcfg) + .then((aResult) => { netcfgResult = aResult; }) + .then(exeAndParseIpRoute) + .then((aResult) => { ipRouteResult = aResult; }) + .then(() => getSettings(SETTINGS_TETHERING_WIFI_IP)) + .then(ip => verifyDefaultRouteAndIp(ip)); + } + + /** + * Clean up all the allocated resources and running services for the test. + * + * After the test no matter success or failure, we should + * 1) Restore to the wifi original state (enabled or disabled) + * 2) Wait until all pending emulator shell commands are done. + * + * |finsih| will be called in the end. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @return A deferred promise. + */ + function cleanUp() { + waitFor(function() { + return ensureWifiEnabled(true) + .then(forgetAllKnownNetworks) + .then(() => ensureWifiEnabled(wifiOrigEnabled)) + .then(finish); + }, function() { + return pendingEmulatorShellCount === 0; + }); + } + + /** + * Init the test environment. + * + * Mainly add the required permissions and initialize the wifiManager + * and the orignal state of wifi. Reject if failing to create + * window.navigator.mozWifiManager; resolve if all is well. + * + * |finsih| will be called in the end. + * + * Fulfill params: (none) + * Reject params: The reject reason. + * + * @return A deferred promise. + */ + function initTestEnvironment() { + return addRequiredPermissions() + .then(function() { + wifiManager = window.navigator.mozWifiManager; + if (!wifiManager) { + throw 'window.navigator.mozWifiManager is NULL'; + } + wifiOrigEnabled = wifiManager.enabled; + }) + .then(() => runEmulatorShellSafe(['getprop', 'ro.build.version.sdk'])) + .then(aLines => { + sdkVersion = parseInt(aLines[0]); + }); + } + + //--------------------------------------------------- + // Public test suite functions + //--------------------------------------------------- + suite.getWifiManager = (() => wifiManager); + suite.ensureWifiEnabled = ensureWifiEnabled; + suite.requestWifiEnabled = requestWifiEnabled; + suite.startHostapds = startHostapds; + suite.getProcessDetail = getProcessDetail; + suite.killAllHostapd = killAllHostapd; + suite.wrapDomRequestAsPromise = wrapDomRequestAsPromise; + suite.waitForWifiManagerEventOnce = waitForWifiManagerEventOnce; + suite.verifyNumOfProcesses = verifyNumOfProcesses; + suite.testWifiScanWithRetry = testWifiScanWithRetry; + suite.getFirstIndexBySsid = getFirstIndexBySsid; + suite.testAssociate = testAssociate; + suite.getKnownNetworks = getKnownNetworks; + suite.setStaticIpMode = setStaticIpMode; + suite.requestWifiScan = requestWifiScan; + suite.waitForConnected = waitForConnected; + suite.forgetNetwork = forgetNetwork; + suite.waitForTimeout = waitForTimeout; + suite.waitForRilDataConnected = waitForRilDataConnected; + suite.requestTetheringEnabled = requestTetheringEnabled; + suite.importCert = importCert; + suite.getImportedCerts = getImportedCerts; + suite.deleteCert = deleteCert; + suite.writeFile = writeFile; + suite.exeAndParseNetcfg = exeAndParseNetcfg; + suite.exeAndParseIpRoute = exeAndParseIpRoute; + + /** + * Common test routine. + * + * Start a test with the given test case chain. The test environment will be + * settled down before the test. After the test, all the affected things will + * be restored. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @param aTestCaseChain + * The test case entry point, which can be a function or a promise. + * + * @return A deferred promise. + */ + suite.doTest = function(aTestCaseChain) { + return initTestEnvironment() + .then(aTestCaseChain) + .then(function onresolve() { + cleanUp(); + }, function onreject(aReason) { + ok(false, 'Promise rejects during test' + (aReason ? '(' + aReason + ')' : '')); + cleanUp(); + }); + }; + + /** + * Common test routine without the presence of stock hostapd. + * + * Same as doTest except stopping the stock hostapd before test + * and restarting it after test. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @param aTestCaseChain + * The test case entry point, which can be a function or a promise. + * + * @return A deferred promise. + */ + suite.doTestWithoutStockAp = function(aTestCaseChain) { + return suite.doTest(function() { + return stopStockHostapd() + .then(aTestCaseChain) + .then(startStockHostapd); + }); + }; + + /** + * The common test routine for wifi tethering. + * + * Similar as doTest except that it will set 'ril.data.enabled' to true + * before testing and restore it afterward. It will also verify 'ril.data.enabled' + * and 'tethering.wifi.enabled' to be false in the beginning. Note that this routine + * will NOT change the state of 'tethering.wifi.enabled' so the user should enable + * than disable on his/her own. This routine will only check if tethering is turned + * off after testing. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @param aTestCaseChain + * The test case entry point, which can be a function or a promise. + * + * @return A deferred promise. + */ + suite.doTestTethering = function(aTestCaseChain) { + + function verifyInitialState() { + return getSettings(SETTINGS_RIL_DATA_ENABLED) + .then(enabled => isOrThrow(enabled, false, SETTINGS_RIL_DATA_ENABLED)) + .then(() => getSettings(SETTINGS_TETHERING_WIFI_ENABLED)) + .then(enabled => isOrThrow(enabled, false, SETTINGS_TETHERING_WIFI_ENABLED)); + } + + function initTetheringTestEnvironment() { + // Enable ril data. + return Promise.all([waitForRilDataConnected(true), + setSettings1(SETTINGS_RIL_DATA_ENABLED, true)]) + .then(setSettings1(SETTINGS_TETHERING_WIFI_SECURITY, 'open')); + } + + function restoreToInitialState() { + return setSettings1(SETTINGS_RIL_DATA_ENABLED, false) + .then(() => getSettings(SETTINGS_TETHERING_WIFI_ENABLED)) + .then(enabled => is(enabled, false, 'Tethering should be turned off.')); + } + + return suite.doTest(function() { + return verifyInitialState() + .then(initTetheringTestEnvironment) + // Since stock hostapd is not reliable after ICS, we just + // turn off potential stock hostapd during testing to avoid + // interference. + .then(stopStockHostapd) + .then(aTestCaseChain) + .then(startStockHostapd) + .then(restoreToInitialState, function onreject(aReason) { + return restoreToInitialState() + .then(() => { throw aReason; }); // Re-throw the orignal reject reason. + }); + }); + }; + + /** + * Run test with imported certificate. + * + * Certificate will be imported and confirmed before running test, and be + * deleted after running test. + * + * Fulfill params: (none) + * + * @param certBlob + * Certificate content as Blob. + * @param password + * Password for importing certificate, only used for importing PKCS#12. + * @param nickanem + * Nickname for imported certificate. + * @param usage + * Expected usage of imported certificate. + * @param aTestCaseChain + * The test case entry point, which can be a function or a promise. + * + * @return A deferred promise. + */ + suite.doTestWithCertificate = function(certBlob, password, nickname, usage, aTestCaseChain) { + return suite.doTestWithoutStockAp(function() { + return ensureWifiEnabled(true) + // Import test certificate. + .then(() => importCert(certBlob, password, nickname)) + .then(function(info) { + // Check import result. + is(info.nickname, nickname, "Imported nickname"); + for (let i = 0; i < usage.length; i++) { + isnot(info.usage.indexOf(usage[i]), -1, "Usage " + usage[i]); + } + }) + // Get imported certificate list. + .then(getImportedCerts) + // Check if certificate exists in imported certificate list. + .then(function(list) { + for (let i = 0; i < usage.length; i++) { + isnot(list[usage[i]].indexOf(nickname), -1, + "Certificate \"" + nickname + "\" of usage " + usage[i] + " is imported"); + } + }) + // Run test case. + .then(aTestCaseChain) + // Delete imported certificates. + .then(() => deleteCert(nickname)) + // Check if certificate doesn't exist in imported certificate list. + .then(getImportedCerts) + .then(function(list) { + for (let i = 0; i < usage.length; i++) { + is(list[usage[i]].indexOf(nickname), -1, "Certificate is deleted"); + } + }) + }); + }; + + return suite; +})(); diff --git a/dom/wifi/test/marionette/manifest.ini b/dom/wifi/test/marionette/manifest.ini new file mode 100644 index 000000000..5d719e4b6 --- /dev/null +++ b/dom/wifi/test/marionette/manifest.ini @@ -0,0 +1,22 @@ +[DEFAULT] +run-if = buildapp == 'b2g' + +[test_wifi_enable.js] +[test_wifi_scan.js] +[test_wifi_associate.js] +[test_wifi_associate_wo_connect.js] +[test_wifi_auto_connect.js] +[test_wifi_static_ip.js] +[test_wifi_tethering_wifi_disabled.js] +[test_wifi_tethering_wifi_inactive.js] +[test_wifi_tethering_wifi_active.js] +[test_wifi_manage_server_certificate.js] +[test_wifi_manage_user_certificate.js] +[test_wifi_manage_pkcs12_certificate.js] +[test_wifi_associate_WPA_EAP_PEAP.js] +skip-if = android_version < '16' # EAP test not working before KK. +[test_wifi_associate_WPA_EAP_TTLS.js] +skip-if = android_version < '16' +[test_wifi_associate_WPA_EAP_TLS.js] +skip-if = android_version < '16' +[test_wifi_enable_api.js] diff --git a/dom/wifi/test/marionette/test_wifi_associate.js b/dom/wifi/test/marionette/test_wifi_associate.js new file mode 100644 index 000000000..0c00c583b --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_associate.js @@ -0,0 +1,35 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +const SCAN_RETRY_CNT = 5; + +/** + * Convert the given MozWifiNetwork object array to testAssociate chain. + * + * @param aNetworks + * An array of MozWifiNetwork which we want to convert. + * + * @return A promise chain which "then"s testAssociate accordingly. + */ +function convertToTestAssociateChain(aNetworks) { + let chain = Promise.resolve(); + + aNetworks.forEach(function (aNetwork) { + chain = chain.then(() => gTestSuite.testAssociate(aNetwork)); + }); + + return chain; +} + +gTestSuite.doTestWithoutStockAp(function() { + return gTestSuite.ensureWifiEnabled(true) + .then(() => gTestSuite.startHostapds(HOSTAPD_CONFIG_LIST)) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', HOSTAPD_CONFIG_LIST.length)) + .then(() => gTestSuite.testWifiScanWithRetry(SCAN_RETRY_CNT, HOSTAPD_CONFIG_LIST)) + .then(networks => convertToTestAssociateChain(networks)) + .then(gTestSuite.killAllHostapd) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', 0)); +}); diff --git a/dom/wifi/test/marionette/test_wifi_associate_WPA_EAP_PEAP.js b/dom/wifi/test/marionette/test_wifi_associate_WPA_EAP_PEAP.js new file mode 100644 index 000000000..ce53da2d7 --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_associate_WPA_EAP_PEAP.js @@ -0,0 +1,623 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +const SCAN_RETRY_CNT = 5; + +const EAP_USERNAME = 'username'; +const EAP_PASSWORD = 'password'; + +const SERVER_EAP_USER_CONF = { + path: HOSTAPD_CONFIG_PATH + 'hostapd.eap_user', + content: '* PEAP,TTLS,TLS\n' + + '"' + EAP_USERNAME + '" MSCHAPV2,TTLS-MSCHAPV2 "' + EAP_PASSWORD + '" [2]\n' +}; +const CA_CERT = { + path: HOSTAPD_CONFIG_PATH + 'ca.pem', + content: '-----BEGIN CERTIFICATE-----\n' + + 'MIIDsTCCApmgAwIBAgIJAKxTf+8X8qngMA0GCSqGSIb3DQEBCwUAMG4xCzAJBgNV\n' + + 'BAYTAlRXMRMwEQYDVQQIDApTb21lLVN0YXRlMREwDwYDVQQKDAhjaHVja2xlZTER\n' + + 'MA8GA1UEAwwIY2h1Y2tsZWUxJDAiBgkqhkiG9w0BCQEWFWNodWNrbGkwNzA2QGdt\n' + + 'YWlsLmNvbTAgFw0xNDEyMjQxMTI4NTBaGA8yMjg4MTAwNzExMjg1MFowbjELMAkG\n' + + 'A1UEBhMCVFcxEzARBgNVBAgMClNvbWUtU3RhdGUxETAPBgNVBAoMCGNodWNrbGVl\n' + + 'MREwDwYDVQQDDAhjaHVja2xlZTEkMCIGCSqGSIb3DQEJARYVY2h1Y2tsaTA3MDZA\n' + + 'Z21haWwuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAo3c2yFxY\n' + + 'o6gGg0I83jy00ME+MAfzCd+4ShL45ZLqysQP93jRBfPzU9ZuZ29ysVwgWIdqkZao\n' + + 'XTuV/NAW2GMGd8W1jQJ3J81fjb9wvhlny3rrACwvUn1N1S1BnM+BAAiDLGxEmvAQ\n' + + 'onp2aaa6HsHsYS8ONX+d2Qh4LEA4vupeSGAqJychCZv/l+aq/ErFZhFYB3CPUQEt\n' + + 'cClO24ucsIYP95lA0zhscnmAj06qplFD4Bv6IVrdDqujy1zNwCQwsJq/8OQdaTN/\n' + + 'h3y9pWvNKMBMM2niOUAjtuNpqsSK/lTS1WAT3PdtVECX9fYBi0Bg+HM92xs/6gt6\n' + + 'kh9jPV8keXHvSwIDAQABo1AwTjAdBgNVHQ4EFgQU7hBqhuG04xeCzrQ3ngx18ZJ3\n' + + 'lUswHwYDVR0jBBgwFoAU7hBqhuG04xeCzrQ3ngx18ZJ3lUswDAYDVR0TBAUwAwEB\n' + + '/zANBgkqhkiG9w0BAQsFAAOCAQEAFYX2iy680GAnBTttk0gyX6gk+8pYr3D22k/G\n' + + '6rvcjefzS7ELQPRKr6mfmwXq3mMf/4jiS2zI5zmXsestPYzHYxf2viQ6t7vr9XiJ\n' + + '3WfFjNw4ERlRisAvg0aqqTNNQq5v2VME4sdFZagy217f73C7azwCHl0bqOLH05rl\n' + + '8RubOxiHEj7ZybJqnRciK/bht4D+rZkwf4bBBmoloqH7xT0+rFQclpYXDGGjNUQB\n' + + 'LcHLF10xcr7g3ZVVu82fe6+d85gIGOIMR9+TKhdw6gO3CNcnDAj6gxksghgtcxmh\n' + + 'OzOggCn7nlIwImtsg2sZkpWB4lEi9hdv4lkNuyFjOL3bnuc+NA==\n' + + '-----END CERTIFICATE-----\n' +}; + +const SERVER_CERT = { + path: HOSTAPD_CONFIG_PATH + 'server.pem', + content: '-----BEGIN CERTIFICATE-----\n' + + 'MIID1DCCArygAwIBAgIBADANBgkqhkiG9w0BAQsFADBuMQswCQYDVQQGEwJUVzET\n' + + 'MBEGA1UECAwKU29tZS1TdGF0ZTERMA8GA1UECgwIY2h1Y2tsZWUxETAPBgNVBAMM\n' + + 'CGNodWNrbGVlMSQwIgYJKoZIhvcNAQkBFhVjaHVja2xpMDcwNkBnbWFpbC5jb20w\n' + + 'IBcNMTQxMjI0MTEyOTQ5WhgPMjI4ODEwMDcxMTI5NDlaMG4xCzAJBgNVBAYTAlRX\n' + + 'MRMwEQYDVQQIDApTb21lLVN0YXRlMREwDwYDVQQKDAhjaHVja2xlZTERMA8GA1UE\n' + + 'AwwIY2h1Y2tsZWUxJDAiBgkqhkiG9w0BCQEWFWNodWNrbGkwNzA2QGdtYWlsLmNv\n' + + 'bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMdhQmKilTJbWZRxTiSV\n' + + 'rqIU+LYW1RKghx5o+0JpNRJVLuz5kBMaNskbbfUSNuHbEq0QA9BDKAZWIc4LSotk\n' + + 'lCo8TbcO9CJvJPQGGjGdHcohWX5vy6BE/OVE46CUteMFyZF6F8R2fNUww08iR/u1\n' + + 'YZebL5pWO1j43sPpAzEy6Tij2ACPt6EZcFaZG3SF2mVJWkCQnBqrojP65WUvZQqp\n' + + 'seUhW2YAS8Nu0Yrohgxz6VYk+cNDuDZVGs6qWRStZzJfYrfc76DtkHof5B14M+xp\n' + + 'XJaBLxN+whvnYkDTfinaCxnW1O7eXUltr87fLc5zmeBkgwaiaQuIdcfZm7vDUiz8\n' + + 'vnUCAwEAAaN7MHkwCQYDVR0TBAIwADAsBglghkgBhvhCAQ0EHxYdT3BlblNTTCBH\n' + + 'ZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFKK4f9/YavTHOfEiAB83Deac\n' + + '6gT5MB8GA1UdIwQYMBaAFO4QaobhtOMXgs60N54MdfGSd5VLMA0GCSqGSIb3DQEB\n' + + 'CwUAA4IBAQBWnO9o9KSJIqjoz5Nwll63ULOdcvgGdOeJIw1fcKQ817Rsp+TVcjcH\n' + + 'IrIADsT/QZGXRO/l6p1750e2iFtJEo1hsRaxtA1wWn2I9HO3+av2spQhr3jpYGPf\n' + + 'zpsMTp4RNYV7Q8+q1kZIz9PY4V1T0p6lveK8+fUj2hSLnxSj0QiGSJJtnEC3w4Rv\n' + + 'C9T6oUwIeToULmi+8FXQFdEqwKRU98DPq3eLzN28ZxUgoPE1C8+42D2UW8uyp/Gm\n' + + 'tGOa/k7nzkCdVqZI7lX7f0AjEvQgjtAMQ/k7Mhxx7TzW2HO+1YPMoKji6Z4WkNwt\n' + + 'JEj9ZUBSNt8B26UksJMBDkcvSegF3a7o\n' + + '-----END CERTIFICATE-----\n' +}; + +const SERVER_KEY = { + path: HOSTAPD_CONFIG_PATH + 'server.key', + content: '-----BEGIN RSA PRIVATE KEY-----\n' + + 'MIIEpAIBAAKCAQEAx2FCYqKVMltZlHFOJJWuohT4thbVEqCHHmj7Qmk1ElUu7PmQ\n' + + 'Exo2yRtt9RI24dsSrRAD0EMoBlYhzgtKi2SUKjxNtw70Im8k9AYaMZ0dyiFZfm/L\n' + + 'oET85UTjoJS14wXJkXoXxHZ81TDDTyJH+7Vhl5svmlY7WPjew+kDMTLpOKPYAI+3\n' + + 'oRlwVpkbdIXaZUlaQJCcGquiM/rlZS9lCqmx5SFbZgBLw27RiuiGDHPpViT5w0O4\n' + + 'NlUazqpZFK1nMl9it9zvoO2Qeh/kHXgz7GlcloEvE37CG+diQNN+KdoLGdbU7t5d\n' + + 'SW2vzt8tznOZ4GSDBqJpC4h1x9mbu8NSLPy+dQIDAQABAoIBAASG4Mr8hgaurEoC\n' + + 'iJOsElr7vunjetMBcg/uskW/vcS8ymP3Bp5oafYG+WgnEbfvEW18f5mq7K24JuxW\n' + + 'tUqU7ghHdjxByqk9fMlNmiqmNpbwSufkAeuRpWxPNBvhRH/zEbCL5R5A0nTEtqqF\n' + + 'TL0aUSzwCRSoAJD0lZo9ICVt0n3GsDyM9rqQg/uZmh1qsRdwPsRuYORND9g48rKq\n' + + '6WN9leskSxhhsYE2D9ocOFd9bNt8Zxejh9ppVSnG/KsIdt18iBzcabatgAQ046fb\n' + + 'Z3vprcZJLg93Sg2gSuVqlSTs3M2W8VQnm22/EBMb1y0M48MSRCgnbPLG/CcCLLfF\n' + + 'LwxCOgECgYEA/eYt67xyJ6JeAdxdwOZuT1WWGbFpLiG9+2OgiHumyRQ5969XMTWo\n' + + 'fIhMKchDdjoy9RR236\/\/EFCs7UEyB7+a7ODRzNiK2zCD8Smjp+21fUPSthEeQesk\n' + + 'eiMYICIu5Ay35x9sxIX+XOUVvRhPOGcD29GVeRnKh1inTHOz2dje8LkCgYEAyQeY\n' + + 'STi9jjCEcHkM1E/UeDiLfHHepLXi8wS41JNRHl5Jacp7XB5djAjKu/jf367/VpFy\n' + + 'GDDMetE7n8eWkrnAvovxOwZ000YDMtL1sUYSjL+XtBS5s6VY1p4qaSAY9nUUGrJh\n' + + 'JvtvsuI7SKTtL+60vjBOH7zDnvOdBgAp0utLhZ0CgYEAuLzzqrPKB8afShFSchn4\n' + + 'J2dpuLYahsNsXW7HDqeR2nsKFosRETAusLXnXPtnAq4kB6jlOarwFqnsuRCX24Vx\n' + + 'r2uBm9/vYL7zMdUPTA+s30ErHuhjsKjsOKYyVqcooSwT32pBFNk+E89nutfmRG7I\n' + + 'IvhjHuNCNqqtx/Xj5d1jkZkCgYBQicppC2Jl5OoqZVTOem0U/RJk+PnJ41TZJ7sk\n' + + '7yBAmmWvDH\/\/l+rCf4M5a6vFYcbKV9rt9h711X2dtciNX/3oWQh8LUoAmrwNUJc+\n' + + 'PmSQHvIYI3WCk2vUD+nN1B4sHxu+1lg11eYaNKiroeeknG2tBI1ICcgVlmQCU25u\n' + + 'IfZPwQKBgQCdO6QHhPLtcHUDNFA6FQ1jKL1iEd7G0JLVRz4Xkpkn1Vrr5MD6JFDa\n' + + '5ccabADyl0lpFqDIVJQIzLku2hOD2i9aBNCY0pL391HeOS7CkZX+TdOY1tquoBq5\n' + + 'MnmixZjDCVd2VcrVyTA6ntOBoharKFW0rH1PqU+qu7dZF7CBPbAdEw==\n' + + '-----END RSA PRIVATE KEY-----\n' +}; + +const WPA_EAP_AP_LIST = [ + { + ssid: 'WPA-EAP-PEAP', + ieee8021x: 1, + eapol_version: 1, + eap_server: 1, + eapol_key_index_workaround: 0, + eap_user_file: SERVER_EAP_USER_CONF.path, + ca_cert: CA_CERT.path, + server_cert: SERVER_CERT.path, + private_key: SERVER_KEY.path, + wpa: 3, + wpa_key_mgmt: 'WPA-EAP' + } +]; + +const CLIENT_PKCS12_CERT = { + nickname: 'client', + password: 'password', + usage: ['UserCert', 'ServerCert'], + content: [0x30, 0x82, 0x0E, 0x01, 0x02, 0x01, 0x03, 0x30, + 0x82, 0x0D, 0xC7, 0x06, 0x09, 0x2A, 0x86, 0x48, + 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01, 0xA0, 0x82, + 0x0D, 0xB8, 0x04, 0x82, 0x0D, 0xB4, 0x30, 0x82, + 0x0D, 0xB0, 0x30, 0x82, 0x08, 0x67, 0x06, 0x09, + 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, + 0x06, 0xA0, 0x82, 0x08, 0x58, 0x30, 0x82, 0x08, + 0x54, 0x02, 0x01, 0x00, 0x30, 0x82, 0x08, 0x4D, + 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, + 0x01, 0x07, 0x01, 0x30, 0x1C, 0x06, 0x0A, 0x2A, + 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, + 0x06, 0x30, 0x0E, 0x04, 0x08, 0x67, 0x7A, 0xF3, + 0x61, 0xBE, 0xE0, 0x51, 0xC1, 0x02, 0x02, 0x08, + 0x00, 0x80, 0x82, 0x08, 0x20, 0xFC, 0x6A, 0x79, + 0xA1, 0x6C, 0xAF, 0xBE, 0xEE, 0x62, 0x45, 0x33, + 0xB8, 0x48, 0xE1, 0x68, 0xA1, 0x15, 0x11, 0x4B, + 0x95, 0xCB, 0x77, 0xC0, 0x5D, 0xA2, 0xCB, 0xDB, + 0xD1, 0x83, 0x74, 0x60, 0xD7, 0xEC, 0x42, 0xA6, + 0x3A, 0x23, 0xF7, 0x85, 0xEB, 0xC1, 0xFE, 0x6A, + 0x57, 0x8E, 0xC1, 0x44, 0xF3, 0x1F, 0xFE, 0xB8, + 0x2D, 0x8C, 0x4D, 0xC9, 0x5B, 0xAE, 0x21, 0x2E, + 0x4C, 0x1A, 0xEB, 0x84, 0x09, 0xF3, 0x40, 0x92, + 0x39, 0x7F, 0x56, 0x02, 0x46, 0x61, 0x16, 0xDE, + 0x5C, 0x48, 0xB6, 0x0C, 0x1D, 0xD3, 0x5F, 0x10, + 0x9A, 0x39, 0xB8, 0x66, 0x31, 0xFC, 0x39, 0x71, + 0x87, 0x23, 0x46, 0x9D, 0xE8, 0x3C, 0x2B, 0xA1, + 0x39, 0x8A, 0xD3, 0xFF, 0xD9, 0x43, 0xB6, 0x61, + 0xC6, 0x67, 0x70, 0x40, 0xBD, 0xFE, 0xD3, 0xC1, + 0x68, 0xF5, 0xF7, 0xC8, 0x89, 0xD8, 0x17, 0xC5, + 0xE8, 0x3D, 0x29, 0xD5, 0x91, 0xDF, 0x1F, 0x56, + 0x74, 0x5A, 0xC4, 0xA8, 0x14, 0xBA, 0xD4, 0xFA, + 0x13, 0x49, 0x2A, 0x9F, 0x63, 0xF1, 0xB2, 0x45, + 0xF1, 0xF0, 0x2A, 0xDD, 0x75, 0x66, 0x8A, 0xF7, + 0xAB, 0x73, 0x86, 0x26, 0x9D, 0x1F, 0x07, 0xAD, + 0xD3, 0xFE, 0xE0, 0xA3, 0xED, 0xA0, 0x96, 0x3E, + 0x1E, 0x89, 0x86, 0x02, 0x4C, 0x28, 0xFD, 0x57, + 0xA1, 0x67, 0x55, 0xF0, 0x82, 0x3B, 0x7F, 0xCC, + 0x2A, 0x32, 0x01, 0x93, 0x1D, 0x8B, 0x66, 0x8A, + 0x20, 0x52, 0x84, 0xDD, 0x2C, 0xFD, 0xEE, 0x72, + 0xF3, 0x8C, 0x58, 0xB9, 0x99, 0xE5, 0xC1, 0x22, + 0x63, 0x59, 0x00, 0xE2, 0x76, 0xC5, 0x3A, 0x17, + 0x7F, 0x93, 0xE9, 0x67, 0x61, 0xAA, 0x10, 0xC3, + 0xD9, 0xC8, 0x24, 0x46, 0x5B, 0xBE, 0x8C, 0x1F, + 0x2D, 0x66, 0x48, 0xD2, 0x02, 0x11, 0xFB, 0x74, + 0x14, 0x76, 0x76, 0x5A, 0x98, 0x54, 0x35, 0xA7, + 0x85, 0x66, 0x20, 0x26, 0x8B, 0x13, 0x6F, 0x68, + 0xE3, 0xC9, 0x58, 0x7D, 0x1C, 0x3E, 0x01, 0x8D, + 0xF8, 0xD6, 0x7F, 0xCF, 0xA2, 0x07, 0xB7, 0x95, + 0xFD, 0xF0, 0x02, 0x34, 0x32, 0x30, 0xE8, 0xD4, + 0x57, 0x5E, 0x53, 0xFB, 0x54, 0xE2, 0x03, 0x32, + 0xCC, 0x52, 0x2E, 0xD2, 0x35, 0xD9, 0x58, 0x85, + 0x2D, 0xEC, 0x2D, 0x71, 0xD1, 0x8A, 0x29, 0xD0, + 0xB0, 0x24, 0xBD, 0x24, 0xDC, 0x1A, 0x28, 0x3F, + 0xA0, 0x12, 0x81, 0x15, 0x24, 0xC9, 0xB5, 0x4A, + 0x23, 0xB6, 0xA3, 0x45, 0x50, 0x2D, 0x73, 0x99, + 0x6B, 0x1C, 0xFB, 0xA4, 0x53, 0xD7, 0x5C, 0xF4, + 0x6C, 0xB0, 0xE5, 0x74, 0xB3, 0x76, 0xF8, 0xB1, + 0x0D, 0x59, 0x70, 0x9F, 0xCA, 0xDE, 0xF2, 0xAA, + 0x4C, 0x7D, 0x11, 0x54, 0xC4, 0x19, 0x0F, 0x36, + 0x4A, 0x62, 0xFF, 0x8B, 0x10, 0xCB, 0x93, 0x50, + 0xDA, 0x79, 0x5E, 0x4E, 0x09, 0x1F, 0x22, 0xC8, + 0x19, 0x85, 0xE9, 0xEE, 0xB7, 0x71, 0x65, 0xB9, + 0x10, 0xD2, 0x0A, 0x73, 0x5B, 0xA6, 0xDA, 0x37, + 0x46, 0x02, 0x00, 0x98, 0x9E, 0x20, 0x6C, 0x7D, + 0xC7, 0x69, 0xBB, 0xC2, 0x00, 0x40, 0x9C, 0x57, + 0x00, 0xC2, 0x36, 0x76, 0xE8, 0x2A, 0x8D, 0xAD, + 0x62, 0x57, 0xC8, 0xD0, 0x9D, 0x66, 0x27, 0x5A, + 0xD8, 0x0D, 0x35, 0x60, 0x28, 0x38, 0x62, 0x94, + 0x78, 0x36, 0x25, 0x58, 0xFD, 0xF8, 0x66, 0x1F, + 0x68, 0x04, 0x0F, 0xD8, 0x00, 0xDF, 0xA0, 0x6C, + 0x25, 0x42, 0x9A, 0x4C, 0xEB, 0x80, 0x13, 0x51, + 0x7D, 0x2D, 0xA8, 0x89, 0xD6, 0x1B, 0x67, 0x72, + 0x01, 0xF3, 0x2D, 0x16, 0x77, 0xFE, 0x22, 0xBC, + 0x8A, 0x45, 0x09, 0x1F, 0x9C, 0x2F, 0x2A, 0xA9, + 0x61, 0x5B, 0x4A, 0xE6, 0x64, 0x2C, 0x62, 0x1A, + 0x3A, 0x96, 0xE6, 0x0A, 0xAE, 0x05, 0x1A, 0xC8, + 0xCB, 0xD6, 0x8F, 0x3A, 0x4B, 0xE0, 0x7F, 0x82, + 0xB4, 0x98, 0xF1, 0x9D, 0xD7, 0x14, 0x76, 0x5E, + 0x77, 0x85, 0x87, 0xEC, 0x13, 0xDA, 0xFD, 0xAF, + 0xCB, 0xA3, 0x1C, 0x99, 0xC1, 0xFE, 0x17, 0x0C, + 0x40, 0x4D, 0x3C, 0x8F, 0x70, 0x86, 0x63, 0x64, + 0xB7, 0x75, 0xA8, 0x71, 0x36, 0xDC, 0x54, 0x10, + 0x57, 0x0C, 0xA8, 0xF2, 0xA1, 0xBB, 0xED, 0x03, + 0x41, 0x57, 0x34, 0x2C, 0x8F, 0x7C, 0xA0, 0x09, + 0xF3, 0x9E, 0x41, 0xB7, 0xA8, 0xD4, 0x66, 0x0D, + 0x0D, 0xC0, 0x6A, 0xFC, 0x6A, 0xA2, 0xAC, 0xE2, + 0x60, 0x00, 0xE3, 0xF7, 0x75, 0x43, 0x23, 0xEB, + 0xC8, 0x61, 0xFA, 0xB3, 0xB8, 0x28, 0xCE, 0xCA, + 0xF4, 0x47, 0x7F, 0x30, 0x6D, 0x61, 0x89, 0x47, + 0xA1, 0x4A, 0xFE, 0xD1, 0x21, 0x0B, 0x6D, 0xF4, + 0x3F, 0x00, 0x86, 0x30, 0x8E, 0x33, 0x21, 0x6F, + 0xDA, 0x15, 0xFD, 0x5F, 0xEC, 0x8E, 0xF1, 0x12, + 0x3F, 0xC9, 0x83, 0x0C, 0xCA, 0x22, 0x01, 0xF1, + 0x70, 0x5F, 0x1F, 0x66, 0xB5, 0xF8, 0x3E, 0x7A, + 0x6F, 0xDE, 0xDB, 0xA7, 0x8D, 0x18, 0x9E, 0xBE, + 0xDB, 0xAD, 0x3D, 0x66, 0x30, 0xC1, 0x6C, 0x0C, + 0x87, 0xB4, 0x65, 0x75, 0xE0, 0x9D, 0xEA, 0x16, + 0x0D, 0x07, 0x37, 0x33, 0xC5, 0xEC, 0x97, 0x93, + 0x37, 0xEB, 0x8E, 0x65, 0x9C, 0x40, 0x63, 0x6C, + 0x43, 0x60, 0xB0, 0x40, 0x4D, 0x85, 0xEF, 0xC2, + 0x47, 0x5F, 0xE7, 0x6B, 0xCB, 0x40, 0xE8, 0xEA, + 0xD8, 0xAB, 0xB1, 0x9A, 0x72, 0xDC, 0x4C, 0x14, + 0xFA, 0x43, 0x61, 0x5F, 0xA6, 0x5C, 0x3A, 0x05, + 0x17, 0x2E, 0x74, 0xF3, 0x5E, 0x45, 0xD9, 0x47, + 0xAA, 0x59, 0xB6, 0x8F, 0x42, 0x66, 0x42, 0x29, + 0x90, 0x95, 0x48, 0x46, 0x91, 0x88, 0x3C, 0x8C, + 0xDE, 0xCC, 0xED, 0xB3, 0xAA, 0x62, 0xEA, 0xBC, + 0xB4, 0x0C, 0x48, 0x4C, 0x53, 0x23, 0x5E, 0x24, + 0x85, 0xBF, 0x92, 0xDA, 0x14, 0xDB, 0x1A, 0x3D, + 0xEF, 0x30, 0xD9, 0x49, 0x64, 0x4D, 0xE5, 0x01, + 0xFC, 0xA4, 0x4B, 0xD1, 0x9F, 0xDE, 0x96, 0x7F, + 0x50, 0xBC, 0x4D, 0x38, 0x44, 0xE9, 0x23, 0x5F, + 0x37, 0x57, 0x1A, 0xA6, 0x52, 0x5A, 0x0F, 0x4F, + 0x87, 0x33, 0x4A, 0x7B, 0x66, 0xEE, 0x3D, 0x66, + 0x0A, 0x63, 0x39, 0x1F, 0x23, 0x38, 0x35, 0x73, + 0x60, 0x5E, 0x47, 0x20, 0x4F, 0xC0, 0xC8, 0x3C, + 0x09, 0xF9, 0x29, 0x4F, 0x5E, 0x55, 0x69, 0xC4, + 0x6B, 0xE8, 0xF8, 0x91, 0xC0, 0x22, 0x65, 0x15, + 0x1E, 0xFB, 0xB9, 0x61, 0xCE, 0x45, 0xBE, 0x2B, + 0xEE, 0xB9, 0x04, 0x2B, 0xFD, 0xAE, 0x61, 0x1C, + 0x3D, 0x3D, 0x7C, 0xBF, 0xC1, 0xF7, 0x3C, 0x4E, + 0x9E, 0x0E, 0x54, 0xC8, 0xAD, 0xA9, 0xDF, 0x43, + 0x49, 0xB9, 0x41, 0x05, 0xE5, 0xF1, 0x49, 0xAA, + 0x77, 0x6C, 0x34, 0x5B, 0x93, 0x24, 0x24, 0x23, + 0x74, 0x68, 0x11, 0xCE, 0x15, 0x80, 0xA1, 0xA4, + 0x1F, 0x8D, 0x81, 0xCD, 0xB2, 0x98, 0xCA, 0x14, + 0x0B, 0x0C, 0x61, 0x50, 0x69, 0x72, 0xAE, 0xFA, + 0x8B, 0xC0, 0x3F, 0x0D, 0xE7, 0xF2, 0x0F, 0xEB, + 0xC1, 0x11, 0xB9, 0x10, 0x03, 0x6A, 0xF5, 0x97, + 0x3C, 0x53, 0x2F, 0x67, 0x86, 0x09, 0x6A, 0xE3, + 0x28, 0xC0, 0x78, 0xC8, 0xB4, 0x39, 0x8E, 0xD1, + 0xCE, 0x25, 0xE8, 0x66, 0xF7, 0x09, 0x40, 0x7D, + 0x81, 0xFB, 0xAF, 0xFA, 0x59, 0xC4, 0x9B, 0x2B, + 0x83, 0x45, 0x5B, 0xA8, 0x66, 0x9E, 0x38, 0xC8, + 0xFD, 0xAC, 0xF2, 0x2D, 0x21, 0xDE, 0x50, 0x4C, + 0x03, 0xCB, 0x88, 0x42, 0xDD, 0x84, 0x09, 0x99, + 0x8E, 0x8B, 0x40, 0x97, 0x1B, 0x14, 0x85, 0x37, + 0x11, 0x01, 0xE0, 0x74, 0x6B, 0x33, 0x52, 0x8C, + 0x68, 0x3A, 0x89, 0xB2, 0xAF, 0x35, 0xE6, 0x65, + 0xC3, 0x58, 0x70, 0xD2, 0xE7, 0x1F, 0x1F, 0xF6, + 0xE5, 0x0A, 0xB1, 0xFE, 0xD0, 0xC9, 0x51, 0x50, + 0xE7, 0xFD, 0x58, 0xF5, 0xC4, 0x58, 0x65, 0x94, + 0xD1, 0x57, 0x55, 0x5E, 0xD2, 0x27, 0x98, 0xAF, + 0xE7, 0x55, 0x0B, 0x87, 0x50, 0x9B, 0xEF, 0xE8, + 0x2B, 0xFC, 0xE7, 0x3B, 0x4E, 0xD7, 0xB7, 0x4D, + 0xF4, 0xBC, 0xF4, 0x88, 0x63, 0xE4, 0x8A, 0x20, + 0x4B, 0x22, 0xB0, 0xA0, 0x53, 0x7F, 0xA8, 0xC9, + 0x0C, 0xF8, 0xD7, 0xBD, 0x46, 0x39, 0xA7, 0x7D, + 0xDD, 0x10, 0x91, 0x50, 0x54, 0x06, 0x47, 0xF0, + 0x3C, 0xAA, 0x43, 0x40, 0xF8, 0x54, 0xDD, 0x8A, + 0xEA, 0x8A, 0x0B, 0xA5, 0x7F, 0xCD, 0x5E, 0xAA, + 0x02, 0x2E, 0x1F, 0xC6, 0x50, 0x15, 0xF8, 0x0A, + 0x0C, 0x1B, 0x3C, 0x55, 0x3A, 0xC3, 0x6F, 0x88, + 0xD7, 0xBF, 0xB1, 0x02, 0xCC, 0xE0, 0x08, 0x29, + 0x97, 0xD2, 0xAA, 0x23, 0xC4, 0x6D, 0xE3, 0xE3, + 0x76, 0x39, 0x92, 0xC3, 0x2E, 0x7A, 0xE2, 0x98, + 0xD1, 0xFC, 0xAE, 0xCC, 0x95, 0xD8, 0xB4, 0xDC, + 0x92, 0xEA, 0x6A, 0x5F, 0xF2, 0x92, 0x17, 0x0B, + 0x8D, 0xC3, 0xFA, 0x9C, 0x62, 0xCE, 0x44, 0x8D, + 0xC3, 0x1E, 0xC3, 0xB2, 0xD5, 0x00, 0xCD, 0xB4, + 0x9E, 0x2D, 0x7B, 0xF2, 0x98, 0xA3, 0x00, 0x8B, + 0x81, 0x30, 0x77, 0x5B, 0x02, 0x99, 0xB1, 0xCD, + 0xC3, 0x1D, 0x74, 0x74, 0xEF, 0x41, 0xCB, 0x69, + 0x63, 0x8E, 0xA6, 0xD3, 0x2D, 0x3E, 0x1F, 0x1D, + 0x12, 0x9E, 0xD9, 0x18, 0x67, 0x06, 0xAF, 0x37, + 0x29, 0xAD, 0x65, 0xD8, 0xEB, 0x71, 0xC4, 0x7D, + 0x94, 0x3D, 0xEA, 0xCC, 0xDF, 0x72, 0x41, 0x51, + 0x3C, 0xA1, 0x66, 0x98, 0x32, 0x32, 0x40, 0x54, + 0xB0, 0x2F, 0xEB, 0xCE, 0xDF, 0x4A, 0x64, 0xFB, + 0x9A, 0x90, 0xDC, 0xF6, 0x6F, 0xA9, 0xD4, 0xCA, + 0xCB, 0x91, 0xC4, 0xFE, 0xEE, 0x9C, 0x01, 0x50, + 0x2E, 0xAC, 0xCC, 0x5F, 0x89, 0xD0, 0x91, 0xA3, + 0xD9, 0xF9, 0x4B, 0x8D, 0xDE, 0x6C, 0x60, 0x21, + 0x19, 0xB1, 0xD3, 0x4D, 0x75, 0x56, 0x6F, 0xB8, + 0x25, 0xA4, 0x92, 0x4F, 0x12, 0xF5, 0x8F, 0xC1, + 0x17, 0x4B, 0xB3, 0x34, 0x21, 0x22, 0xAC, 0x52, + 0xD2, 0x64, 0xC9, 0x9A, 0x7D, 0xFC, 0xC0, 0x0A, + 0x89, 0x34, 0xFF, 0x08, 0xD3, 0x04, 0xDC, 0xFE, + 0x7C, 0xB3, 0xB8, 0xFD, 0x85, 0xDD, 0x79, 0x51, + 0xA7, 0x89, 0xE8, 0xF1, 0x23, 0xB1, 0xDF, 0xD7, + 0x1F, 0x7B, 0xB1, 0x5D, 0x42, 0xF9, 0x61, 0xF8, + 0xDC, 0x81, 0x04, 0xF1, 0xCC, 0xFA, 0xD7, 0xED, + 0xBF, 0x47, 0xAC, 0xBD, 0xE5, 0xFA, 0xAC, 0xB3, + 0x1C, 0xD9, 0xA1, 0xB3, 0x60, 0xEE, 0x9C, 0x8A, + 0x36, 0x57, 0xB4, 0x2F, 0xA1, 0xA2, 0xF3, 0xE2, + 0x09, 0x9A, 0x6E, 0x43, 0x9B, 0xE5, 0x93, 0xB8, + 0x3D, 0x9E, 0x9F, 0xC1, 0xC6, 0x0D, 0x02, 0xEB, + 0x4D, 0x38, 0xE9, 0xB4, 0x9F, 0xEA, 0x33, 0x8C, + 0x07, 0xD8, 0xB4, 0x71, 0xAD, 0xE5, 0x43, 0xB2, + 0xCC, 0x55, 0x93, 0x6A, 0xDB, 0x1E, 0x80, 0xDB, + 0xC2, 0xEA, 0x42, 0x8E, 0xFC, 0x86, 0x44, 0xC9, + 0x8A, 0xC4, 0xF2, 0x46, 0xA7, 0x39, 0x50, 0x0D, + 0x1A, 0xAA, 0x07, 0x04, 0xBE, 0xD4, 0xCE, 0x62, + 0x4D, 0x0F, 0x91, 0x7D, 0x29, 0x88, 0x9C, 0x4C, + 0xAF, 0xF7, 0xD8, 0x40, 0x93, 0x88, 0xC7, 0x20, + 0xD2, 0x17, 0x2A, 0xC4, 0x92, 0x72, 0xD0, 0xC0, + 0x4E, 0x56, 0x47, 0xB1, 0x27, 0x02, 0xE6, 0x61, + 0x82, 0x5E, 0xC8, 0x2E, 0x90, 0xD2, 0x31, 0x22, + 0xE2, 0xA9, 0x4A, 0x91, 0x45, 0x69, 0xB1, 0xA5, + 0x0F, 0x66, 0x2C, 0x30, 0xAD, 0x7F, 0x1B, 0x0E, + 0x22, 0x17, 0x60, 0x2E, 0x3D, 0x7F, 0x7F, 0x8C, + 0x33, 0x51, 0xA0, 0x25, 0xDE, 0xFD, 0x75, 0xBC, + 0xEF, 0xE6, 0xE7, 0x20, 0x04, 0x5A, 0xEC, 0x50, + 0x21, 0x48, 0x56, 0x98, 0xE2, 0x33, 0x6D, 0x22, + 0x5C, 0xC3, 0xFB, 0xFC, 0x6F, 0xB3, 0xA7, 0x8E, + 0x6F, 0x67, 0x70, 0x9D, 0xDA, 0x02, 0x01, 0x59, + 0x7B, 0x3D, 0x2B, 0x38, 0xCC, 0x0F, 0x44, 0x3D, + 0xFB, 0x9A, 0xB3, 0x23, 0x15, 0x50, 0x6E, 0xBF, + 0x8B, 0xA1, 0x94, 0x33, 0xE5, 0x7B, 0x88, 0x4E, + 0xCB, 0x6D, 0x9F, 0xBF, 0xBC, 0x7A, 0xA8, 0x1E, + 0x68, 0x25, 0xED, 0x8E, 0x53, 0x21, 0x72, 0xC5, + 0x70, 0xB3, 0xE4, 0xA6, 0xA1, 0x5A, 0x2D, 0xC8, + 0x43, 0x9D, 0x60, 0x77, 0x78, 0xE0, 0xC4, 0xAF, + 0xC8, 0x29, 0xBA, 0xD0, 0x4D, 0x39, 0x83, 0x51, + 0xA7, 0x10, 0x7F, 0x0C, 0x34, 0x0E, 0x6C, 0x75, + 0x26, 0xD7, 0xD6, 0xC7, 0x32, 0x53, 0xAF, 0x4E, + 0xBE, 0xF2, 0xC2, 0x0F, 0x99, 0x23, 0xB9, 0xE1, + 0xC8, 0xB4, 0xBC, 0x5A, 0xC6, 0xCB, 0xEB, 0x4D, + 0x28, 0x56, 0x72, 0xFE, 0x1B, 0x2C, 0x5D, 0xE3, + 0xBC, 0xC7, 0xA3, 0xC0, 0x7D, 0x27, 0xF0, 0xD0, + 0x4F, 0x3F, 0x1F, 0xF7, 0x87, 0x15, 0xF2, 0xEA, + 0xD4, 0x03, 0x6D, 0x2F, 0xD4, 0x8E, 0x50, 0x4B, + 0x05, 0xBF, 0xF7, 0x8C, 0x67, 0x5A, 0xDC, 0x4D, + 0xCD, 0xCF, 0x9D, 0x02, 0xB6, 0xE7, 0xAE, 0x49, + 0xD1, 0x7C, 0x00, 0xE7, 0x3B, 0xEA, 0xFB, 0x0D, + 0x2A, 0x7B, 0x41, 0x33, 0x66, 0xD0, 0x29, 0x9F, + 0xB3, 0x8A, 0x71, 0xB0, 0xE2, 0x76, 0xA9, 0xDB, + 0xFD, 0x64, 0x04, 0x69, 0xDF, 0x89, 0x1F, 0x56, + 0x86, 0x92, 0xD9, 0xD9, 0xB9, 0xF3, 0x4F, 0xAC, + 0xAE, 0x61, 0x48, 0x20, 0xCE, 0x3C, 0x2B, 0x44, + 0xAB, 0x42, 0xFA, 0xAB, 0x2E, 0x94, 0x82, 0xC8, + 0xD9, 0x97, 0xCF, 0x27, 0xDF, 0xAC, 0xAC, 0xE7, + 0xCA, 0xB2, 0x84, 0xAB, 0xF2, 0x5D, 0xDF, 0x56, + 0x0C, 0x8C, 0x07, 0x3C, 0x3D, 0xA8, 0xDD, 0xBE, + 0xFF, 0x4E, 0x28, 0x0D, 0xB2, 0x2D, 0xE6, 0x9D, + 0x44, 0x21, 0xCB, 0xE7, 0x33, 0x63, 0x22, 0x8F, + 0x4C, 0xFF, 0xB6, 0x1D, 0x9A, 0x71, 0x3F, 0xB1, + 0x29, 0xAE, 0x3A, 0x35, 0xEE, 0x9C, 0x97, 0x68, + 0xA7, 0x52, 0x66, 0x01, 0xD8, 0x9A, 0x5D, 0xF4, + 0xB3, 0x2F, 0x5C, 0xD4, 0x0E, 0xF9, 0xCF, 0x07, + 0xF6, 0x8C, 0xBA, 0xA6, 0x8D, 0x6B, 0xC6, 0x01, + 0xC2, 0x69, 0xAE, 0x60, 0x08, 0x1A, 0x0E, 0x3F, + 0xAE, 0x60, 0x29, 0xF3, 0x48, 0x0D, 0xE0, 0xD0, + 0xAE, 0x52, 0x44, 0xE9, 0x7F, 0x1F, 0x92, 0x5F, + 0x71, 0xAD, 0xEC, 0x6B, 0x47, 0x66, 0x92, 0x22, + 0x27, 0xAE, 0x6E, 0x25, 0xCD, 0xF3, 0x5F, 0x55, + 0x59, 0xBD, 0x73, 0xCE, 0x2B, 0x7E, 0x99, 0x44, + 0x56, 0x70, 0xA3, 0xE7, 0x7A, 0x59, 0x75, 0xD8, + 0x48, 0x0C, 0x39, 0x2B, 0xD7, 0x53, 0xC6, 0xAD, + 0x4A, 0x6F, 0xB4, 0x14, 0x96, 0xDF, 0xF2, 0x4A, + 0x0C, 0xA2, 0xD5, 0x29, 0x98, 0x7C, 0x42, 0x87, + 0xD9, 0x1F, 0x97, 0x61, 0xD9, 0xBF, 0x99, 0x4F, + 0x2C, 0x4C, 0x75, 0xAC, 0xB8, 0x06, 0x75, 0xD6, + 0x87, 0x76, 0x7E, 0xE3, 0x23, 0x4B, 0xEA, 0x1A, + 0x1A, 0xF4, 0xB7, 0x09, 0xAF, 0x53, 0xEB, 0xA6, + 0x39, 0x10, 0xFE, 0xD4, 0xEB, 0x1B, 0xAE, 0x38, + 0x31, 0x33, 0xBA, 0x68, 0xEE, 0xC7, 0x65, 0x76, + 0xFB, 0x49, 0x77, 0xD4, 0x19, 0xC4, 0xE6, 0xA7, + 0x05, 0xFE, 0x2A, 0xDA, 0x39, 0x99, 0x1A, 0x92, + 0xD2, 0xF0, 0x61, 0x97, 0xF6, 0x06, 0x6C, 0x88, + 0x7B, 0x6F, 0x60, 0xE6, 0x70, 0x08, 0xF0, 0xB4, + 0x6B, 0x39, 0x6F, 0x05, 0x41, 0x81, 0xF9, 0xBE, + 0x7A, 0x51, 0xC4, 0x75, 0xB0, 0x6A, 0x89, 0xA0, + 0xA6, 0x9A, 0x5B, 0xEE, 0x7D, 0x78, 0x17, 0x5F, + 0x9F, 0x3B, 0x7D, 0xDD, 0x8A, 0x9E, 0xAA, 0x1A, + 0xDA, 0x49, 0x08, 0xE9, 0xFD, 0x91, 0xA6, 0xFA, + 0xCE, 0xCF, 0x67, 0xDF, 0x0F, 0xC9, 0xD6, 0x38, + 0xD9, 0xD5, 0xD1, 0xC0, 0x76, 0x59, 0x42, 0x53, + 0xBF, 0x48, 0xE9, 0x11, 0x74, 0xC7, 0x11, 0xD8, + 0xE7, 0x8E, 0xD3, 0xC8, 0x25, 0xA1, 0x26, 0x50, + 0xBB, 0xB4, 0x35, 0xAF, 0xAF, 0x06, 0x23, 0x69, + 0x3E, 0x30, 0xFD, 0x7B, 0x34, 0x83, 0x07, 0xD0, + 0xF0, 0x0F, 0x6C, 0x9A, 0x13, 0x5D, 0xC2, 0x7B, + 0xDF, 0x6F, 0xDD, 0x8E, 0xF4, 0x30, 0x82, 0x05, + 0x41, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, + 0x0D, 0x01, 0x07, 0x01, 0xA0, 0x82, 0x05, 0x32, + 0x04, 0x82, 0x05, 0x2E, 0x30, 0x82, 0x05, 0x2A, + 0x30, 0x82, 0x05, 0x26, 0x06, 0x0B, 0x2A, 0x86, + 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, + 0x02, 0xA0, 0x82, 0x04, 0xEE, 0x30, 0x82, 0x04, + 0xEA, 0x30, 0x1C, 0x06, 0x0A, 0x2A, 0x86, 0x48, + 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x03, 0x30, + 0x0E, 0x04, 0x08, 0x74, 0xC0, 0x84, 0x8F, 0xC7, + 0x74, 0x5E, 0x21, 0x02, 0x02, 0x08, 0x00, 0x04, + 0x82, 0x04, 0xC8, 0x1E, 0xF4, 0xE9, 0x07, 0x27, + 0x9E, 0x5A, 0xC9, 0x39, 0x1D, 0x37, 0x2C, 0x06, + 0x4B, 0x57, 0xEA, 0xC5, 0x42, 0x9A, 0x60, 0xD5, + 0x42, 0xB2, 0x34, 0x2D, 0xD3, 0x88, 0x7C, 0x78, + 0x87, 0xB6, 0xE9, 0x42, 0x44, 0x1F, 0x67, 0x32, + 0x92, 0x54, 0x22, 0xDA, 0xB2, 0x43, 0xE7, 0x40, + 0xBE, 0x1F, 0xAF, 0x3A, 0xCD, 0x2A, 0x9F, 0xD7, + 0x44, 0x5B, 0x37, 0x69, 0x85, 0xDF, 0xEB, 0x2A, + 0xB9, 0xE2, 0x92, 0x3B, 0xEA, 0xD5, 0x42, 0x53, + 0x95, 0x4A, 0xB0, 0x1B, 0xA5, 0xEF, 0xA6, 0x0D, + 0x29, 0xF4, 0x33, 0xFE, 0xD7, 0x49, 0x04, 0x1E, + 0x8C, 0xAD, 0x63, 0x1E, 0x79, 0x63, 0x74, 0x0C, + 0xE5, 0x5E, 0xA2, 0x2C, 0xBE, 0xB8, 0x90, 0xCE, + 0x06, 0x25, 0xBF, 0xD1, 0x5A, 0x50, 0xCF, 0x3B, + 0x52, 0xE2, 0xA7, 0xFF, 0x19, 0x02, 0xCF, 0xD0, + 0x9B, 0xD9, 0xF7, 0x28, 0x07, 0x38, 0x1F, 0xF2, + 0xAF, 0x44, 0x91, 0x3F, 0x0F, 0xB6, 0x6E, 0x8C, + 0xC0, 0x32, 0x92, 0xC0, 0xCD, 0x25, 0x98, 0x67, + 0xF1, 0x47, 0x52, 0x50, 0xF0, 0xA3, 0x7B, 0xE6, + 0x74, 0xDC, 0x72, 0x28, 0xC8, 0xAB, 0xB3, 0x31, + 0x7D, 0xA3, 0xF7, 0xC7, 0xD1, 0xE6, 0x99, 0xB4, + 0xB6, 0x5A, 0x3A, 0x4D, 0x83, 0x4F, 0xB8, 0xB5, + 0x86, 0xF8, 0x37, 0x7F, 0xA0, 0x16, 0x2F, 0x3C, + 0x62, 0x7A, 0xD4, 0x3A, 0xEB, 0xC2, 0xE8, 0x03, + 0x49, 0x17, 0x9E, 0xFB, 0xD7, 0xAF, 0x91, 0x32, + 0xFD, 0xEA, 0x4F, 0x64, 0xC6, 0x6E, 0x02, 0xEA, + 0xC4, 0xC8, 0x1F, 0x16, 0xC5, 0x4C, 0xFB, 0xC5, + 0x42, 0xF5, 0x85, 0x05, 0x92, 0x59, 0x4B, 0x31, + 0xE5, 0xE9, 0x69, 0xE7, 0x02, 0x98, 0x33, 0xBA, + 0x4C, 0x17, 0x09, 0xEF, 0x89, 0x20, 0xFA, 0x83, + 0x9F, 0xAE, 0x0E, 0x1B, 0x7D, 0x98, 0xB9, 0xF2, + 0x3C, 0x0F, 0xB7, 0x1C, 0x72, 0xDF, 0x17, 0x84, + 0x7F, 0x0A, 0xFD, 0x12, 0x3C, 0x6F, 0x68, 0x5D, + 0x45, 0xEB, 0xB8, 0xD6, 0x24, 0x65, 0x42, 0x75, + 0x5C, 0xC2, 0xF3, 0x3A, 0x6A, 0x4E, 0x51, 0x34, + 0x1B, 0xB6, 0x81, 0xB2, 0x8A, 0xEF, 0x28, 0xA4, + 0xC5, 0x88, 0x9A, 0x97, 0xE0, 0xEF, 0x31, 0x12, + 0x01, 0x7E, 0x1B, 0x43, 0x0F, 0x27, 0x80, 0x87, + 0x98, 0xC5, 0xD5, 0x83, 0xCB, 0x4B, 0xB7, 0x01, + 0x79, 0x60, 0xA1, 0x1A, 0x03, 0x05, 0xC6, 0x36, + 0x04, 0x31, 0x3C, 0x06, 0xDB, 0x08, 0xA8, 0xDA, + 0x8E, 0x32, 0x19, 0x91, 0xF1, 0x0D, 0x61, 0x6F, + 0xE4, 0xB2, 0x79, 0x8A, 0xDE, 0xF4, 0xF7, 0xFB, + 0x2C, 0x23, 0x5B, 0xD9, 0x64, 0x2F, 0xB7, 0xB3, + 0x8B, 0xCA, 0xB8, 0x8C, 0x1D, 0x3B, 0x49, 0x05, + 0x38, 0xA1, 0xE5, 0x8C, 0x1A, 0xDC, 0xA5, 0x61, + 0xFE, 0xF4, 0x2B, 0xDC, 0x77, 0x28, 0xF6, 0x19, + 0xE7, 0xB7, 0x8F, 0x4D, 0x27, 0x2D, 0xED, 0x8A, + 0x3F, 0x3D, 0xDC, 0x9F, 0xD1, 0x30, 0xFF, 0xD6, + 0xC3, 0xBE, 0x41, 0x25, 0xE3, 0xA5, 0x9B, 0x73, + 0xDF, 0x6A, 0xD9, 0xF9, 0x70, 0x84, 0x02, 0x4C, + 0x35, 0xD4, 0x3E, 0x05, 0x76, 0x3A, 0xDC, 0x6D, + 0x5A, 0x81, 0xB3, 0x94, 0xF7, 0x22, 0xF7, 0xDC, + 0xC1, 0x43, 0x31, 0x57, 0x5B, 0x42, 0x9A, 0x0B, + 0xF4, 0x95, 0x30, 0xA9, 0xBB, 0xD8, 0x06, 0xFB, + 0x1D, 0x6F, 0x9B, 0xC3, 0xBB, 0xF3, 0xBF, 0xFB, + 0xB4, 0x9F, 0x35, 0x64, 0x0A, 0x69, 0xB7, 0xD1, + 0x3E, 0xCA, 0x78, 0x07, 0x04, 0x03, 0x79, 0xD4, + 0xF3, 0xA8, 0xEC, 0x18, 0xDB, 0x03, 0x5E, 0x47, + 0xD7, 0xD0, 0x56, 0x2C, 0x74, 0x94, 0x86, 0x04, + 0x46, 0xB8, 0xD4, 0x35, 0x0A, 0x7B, 0xE6, 0x78, + 0xC4, 0x43, 0x3C, 0x56, 0xCC, 0x37, 0x8B, 0xFD, + 0xE8, 0xF4, 0x57, 0xEA, 0xAE, 0xCF, 0x36, 0x97, + 0x12, 0xAC, 0x39, 0xCF, 0x7C, 0xEF, 0x22, 0x67, + 0x01, 0xEC, 0xD8, 0x09, 0x49, 0x4E, 0xE3, 0x74, + 0xDD, 0x39, 0xE1, 0x39, 0xD7, 0x0C, 0x5F, 0x1B, + 0xCE, 0x69, 0xBC, 0x72, 0x44, 0x87, 0x64, 0x1C, + 0x08, 0x05, 0x93, 0x69, 0x6D, 0x7F, 0x90, 0x0A, + 0x2C, 0xCB, 0x8A, 0xBB, 0x7F, 0xE3, 0xE0, 0x80, + 0x31, 0xD0, 0x0A, 0x3A, 0x95, 0xFF, 0xF7, 0xB4, + 0x36, 0x38, 0x93, 0xE0, 0x0C, 0x11, 0x37, 0x12, + 0x06, 0xF6, 0xAD, 0xE9, 0xB1, 0x7A, 0x00, 0xF5, + 0xD2, 0x32, 0x6B, 0xD0, 0x27, 0xA5, 0x1B, 0x3D, + 0xE8, 0xDB, 0xCC, 0xA9, 0x1F, 0x1F, 0xB1, 0x99, + 0x3D, 0x7C, 0xB7, 0xCA, 0xDA, 0x27, 0x2C, 0x64, + 0x1C, 0x49, 0xB6, 0x87, 0x44, 0x06, 0x94, 0x9D, + 0xBC, 0x6B, 0x20, 0xA2, 0x68, 0x15, 0x1F, 0xE2, + 0xF2, 0xAD, 0x6D, 0x23, 0x2E, 0x2B, 0x74, 0xE2, + 0x5D, 0xE4, 0xB0, 0xC7, 0x84, 0xCB, 0x64, 0xBF, + 0xE0, 0xA8, 0x18, 0x83, 0xB4, 0xC9, 0xD9, 0x73, + 0xA8, 0xE6, 0xA9, 0x36, 0xD5, 0x63, 0x1E, 0x2C, + 0x2A, 0x55, 0x09, 0x77, 0x5E, 0xB3, 0x4B, 0xEA, + 0xB5, 0xD0, 0x14, 0x5F, 0xEB, 0x50, 0x7B, 0xAA, + 0xEF, 0x94, 0xBA, 0x2B, 0xD7, 0x8A, 0x07, 0xF1, + 0xF9, 0x5E, 0x12, 0x12, 0x21, 0x52, 0xE5, 0x0A, + 0x3E, 0xC0, 0xBC, 0x5D, 0x4C, 0xE2, 0x12, 0x7C, + 0x39, 0xF9, 0x16, 0x9D, 0xBD, 0x96, 0x83, 0x3B, + 0x7F, 0x3D, 0x6A, 0xEC, 0xF1, 0x25, 0xD2, 0xB0, + 0xB0, 0xEB, 0x20, 0x06, 0x07, 0xD6, 0xD9, 0x4C, + 0x07, 0x9A, 0x82, 0xC1, 0xFC, 0xF7, 0x66, 0x15, + 0xBD, 0x62, 0x65, 0xD8, 0x6C, 0xF6, 0x33, 0x7B, + 0x5A, 0x28, 0xEC, 0x90, 0xA1, 0x26, 0x9F, 0xC3, + 0x28, 0x4A, 0x64, 0x50, 0x5F, 0xCA, 0xE2, 0x6D, + 0xB8, 0x0F, 0xE2, 0x94, 0xB5, 0x8E, 0x1F, 0x8A, + 0x8F, 0x6B, 0xA6, 0x86, 0x1F, 0xEE, 0xDC, 0x24, + 0xB4, 0xB8, 0x25, 0xEC, 0x28, 0x2D, 0xF9, 0xCB, + 0x7D, 0x38, 0xFF, 0xC7, 0x74, 0x2E, 0xD3, 0x10, + 0xEC, 0x03, 0x31, 0xEE, 0x83, 0xE7, 0xA4, 0xF7, + 0xBA, 0x28, 0x21, 0xE0, 0x7F, 0xB4, 0xB7, 0xE1, + 0x7A, 0xF9, 0x2B, 0xB0, 0x2C, 0x3B, 0x80, 0x5F, + 0xE0, 0x5D, 0xB2, 0x7E, 0x59, 0xFF, 0x59, 0x07, + 0x58, 0x42, 0x57, 0xEE, 0x44, 0xF1, 0xB1, 0xAD, + 0xBA, 0xDE, 0xCB, 0x1D, 0x8A, 0x36, 0x67, 0xE8, + 0x45, 0xFF, 0x07, 0x8D, 0xEE, 0xA4, 0x51, 0x9C, + 0x4C, 0x83, 0x5D, 0x2E, 0x2F, 0xE1, 0x5B, 0x75, + 0xE8, 0x29, 0xCD, 0x0B, 0x07, 0x62, 0xE0, 0xC3, + 0x0D, 0x1D, 0xEA, 0xCF, 0xF0, 0x8A, 0x65, 0x27, + 0x70, 0x42, 0x9F, 0x26, 0x00, 0x15, 0x70, 0xC5, + 0x4A, 0xF6, 0x25, 0xD0, 0x40, 0x72, 0xE9, 0xC1, + 0x73, 0xFD, 0x48, 0x94, 0xA3, 0x8D, 0x66, 0x63, + 0x96, 0x4F, 0xF7, 0xEE, 0xFB, 0x4C, 0xC7, 0xB8, + 0x6B, 0xE9, 0x90, 0xE1, 0x2A, 0x66, 0x80, 0x99, + 0x3B, 0xB0, 0x1A, 0x6C, 0xF9, 0x0E, 0x72, 0xDA, + 0x8E, 0x4F, 0x46, 0xC2, 0x6A, 0x4B, 0x7A, 0x16, + 0xE5, 0x26, 0x0B, 0x5C, 0xD4, 0x47, 0x34, 0xE5, + 0x37, 0xBE, 0x68, 0x6C, 0xDA, 0xD3, 0x9B, 0x6F, + 0xAE, 0x51, 0x9C, 0x99, 0x0A, 0x5B, 0xF8, 0x37, + 0xBC, 0xDE, 0xFC, 0x93, 0xC5, 0xE7, 0x0F, 0xEF, + 0x0B, 0xA6, 0x07, 0xC2, 0xA6, 0xE6, 0xDA, 0x2D, + 0x1B, 0x49, 0xC9, 0xDE, 0x6B, 0x27, 0xDC, 0x00, + 0xEF, 0x23, 0x87, 0x0E, 0xEB, 0xD1, 0x48, 0x7D, + 0xB4, 0xF2, 0x58, 0xC6, 0x3C, 0xE2, 0x89, 0xBA, + 0xB0, 0x05, 0xAC, 0x94, 0x41, 0x9A, 0xA8, 0xFF, + 0x3E, 0xBC, 0x3A, 0x52, 0x9C, 0xF9, 0x7F, 0x07, + 0x8B, 0xB0, 0x2C, 0x71, 0x83, 0x7B, 0xCF, 0x2E, + 0x7F, 0x7C, 0x96, 0x65, 0xD9, 0x08, 0x17, 0xEC, + 0xFA, 0xDE, 0x4E, 0x40, 0x12, 0x26, 0x70, 0x71, + 0x65, 0xA5, 0xDC, 0x98, 0x47, 0xA3, 0xFC, 0xE0, + 0x9A, 0x16, 0xED, 0x45, 0x56, 0x72, 0x50, 0x05, + 0x28, 0x2C, 0x99, 0xEC, 0x20, 0x2E, 0x40, 0xC0, + 0x26, 0x69, 0xCD, 0x49, 0x45, 0x17, 0xA4, 0xA3, + 0x42, 0x0D, 0x14, 0x65, 0x87, 0x33, 0x8C, 0x92, + 0xC5, 0xC4, 0x61, 0xFD, 0xE8, 0x68, 0x56, 0x20, + 0x57, 0xF5, 0x8E, 0x5F, 0xCF, 0x7E, 0x97, 0xF6, + 0x49, 0x97, 0x0A, 0xFE, 0xD3, 0x60, 0x1A, 0x5B, + 0x0C, 0x75, 0xDD, 0x8E, 0x31, 0x78, 0x29, 0xA6, + 0xB1, 0x4D, 0xAA, 0xDF, 0x8A, 0xD1, 0xE6, 0x91, + 0xE3, 0x32, 0x3F, 0xEC, 0x8A, 0x1F, 0x0E, 0x35, + 0x07, 0x6E, 0x4B, 0x83, 0x3B, 0xE5, 0x67, 0x34, + 0x1F, 0x0C, 0x81, 0xD8, 0xD5, 0x25, 0x68, 0xE5, + 0x28, 0x1B, 0x5C, 0x81, 0x3E, 0xE3, 0x5C, 0xB4, + 0xB6, 0xBD, 0x62, 0x6A, 0x70, 0x33, 0xC2, 0xC5, + 0x75, 0x27, 0xF4, 0x30, 0xE1, 0x1D, 0xC1, 0x4C, + 0xC5, 0x02, 0x12, 0x46, 0xAC, 0xEC, 0xF9, 0xE8, + 0xE7, 0x58, 0x24, 0x11, 0xB1, 0xF3, 0xB7, 0x8C, + 0x3C, 0xA4, 0x0A, 0x94, 0xA6, 0x7C, 0x68, 0x54, + 0x5B, 0xB9, 0x4D, 0x57, 0x9C, 0xE7, 0x28, 0x09, + 0x6B, 0x89, 0x26, 0x5D, 0xE7, 0x50, 0xA9, 0x95, + 0x90, 0x91, 0x8E, 0x00, 0x59, 0xF8, 0x3A, 0x70, + 0xAF, 0x48, 0x2E, 0xE8, 0xC4, 0x34, 0x8C, 0xF4, + 0x5F, 0x7F, 0xCB, 0x07, 0xAA, 0xF0, 0xD9, 0xFB, + 0x5C, 0x32, 0x90, 0x22, 0x1A, 0xD2, 0x1A, 0xCF, + 0x92, 0x06, 0x02, 0xCF, 0x10, 0x18, 0x7B, 0x93, + 0xCC, 0x07, 0x4A, 0x31, 0x25, 0x30, 0x23, 0x06, + 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, + 0x09, 0x15, 0x31, 0x16, 0x04, 0x14, 0xD1, 0xDE, + 0x23, 0x16, 0x9F, 0x6E, 0xF4, 0x42, 0x21, 0x23, + 0xE1, 0x11, 0xAA, 0xC8, 0x7C, 0x60, 0x4A, 0x78, + 0x9D, 0x24, 0x30, 0x31, 0x30, 0x21, 0x30, 0x09, + 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x05, + 0x00, 0x04, 0x14, 0xD6, 0x4A, 0xBB, 0x75, 0xB1, + 0xF9, 0x9E, 0xD3, 0x58, 0x6D, 0xD1, 0x74, 0x9F, + 0x00, 0x8A, 0xF2, 0xC8, 0xAA, 0x52, 0x4D, 0x04, + 0x08, 0x77, 0x46, 0xE7, 0xBA, 0x25, 0x4B, 0xDA, + 0x41, 0x02, 0x02, 0x08, 0x00] +}; + +const WPA_EAP_CLIENT_LIST = [ + { + ssid: 'WPA-EAP-PEAP', + keyManagement: 'WPA-EAP', + eap: 'PEAP', + identity: EAP_USERNAME, + password: EAP_PASSWORD, + serverCertificate: CLIENT_PKCS12_CERT.nickname, + phase2: 'MSCHAPV2' + } +]; + +/** + * Convert the given MozWifiNetwork object array to testAssociate chain. + * + * @param aNetworks + * An array of MozWifiNetwork which we want to convert. + * + * @return A promise chain which "then"s testAssociate accordingly. + */ +function convertToTestAssociateChain(aNetworks) { + let chain = Promise.resolve(); + + aNetworks.forEach(function (aNetwork) { + network = new window.MozWifiNetwork(aNetwork); + chain = chain.then(() => gTestSuite.testAssociate(network)); + }); + + return chain; +} + +gTestSuite.doTestWithCertificate( + new Blob([new Uint8Array(CLIENT_PKCS12_CERT.content)]), + CLIENT_PKCS12_CERT.password, + CLIENT_PKCS12_CERT.nickname, + CLIENT_PKCS12_CERT.usage, + function() { + return gTestSuite.ensureWifiEnabled(true) + // Load required server files. + .then(() => gTestSuite.writeFile(SERVER_EAP_USER_CONF.path, SERVER_EAP_USER_CONF.content)) + .then(() => gTestSuite.writeFile(CA_CERT.path, CA_CERT.content)) + .then(() => gTestSuite.writeFile(SERVER_CERT.path, SERVER_CERT.content)) + .then(() => gTestSuite.writeFile(SERVER_KEY.path, SERVER_KEY.content)) + // Start AP. + .then(() => gTestSuite.startHostapds(WPA_EAP_AP_LIST)) + // Scan test. + .then(() => gTestSuite.testWifiScanWithRetry(SCAN_RETRY_CNT, WPA_EAP_AP_LIST)) + // Associate test. + .then(() => convertToTestAssociateChain(WPA_EAP_CLIENT_LIST)) + // Tear down. + .then(gTestSuite.killAllHostapd) +}); diff --git a/dom/wifi/test/marionette/test_wifi_associate_WPA_EAP_TLS.js b/dom/wifi/test/marionette/test_wifi_associate_WPA_EAP_TLS.js new file mode 100644 index 000000000..35b942f8e --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_associate_WPA_EAP_TLS.js @@ -0,0 +1,622 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +const SCAN_RETRY_CNT = 5; + +const EAP_USERNAME = 'username'; +const EAP_PASSWORD = 'password'; + +const SERVER_EAP_USER_CONF = { + path: HOSTAPD_CONFIG_PATH + 'hostapd.eap_user', + content: '* PEAP,TTLS,TLS\n' + + '"' + EAP_USERNAME + '" MSCHAPV2,TTLS-MSCHAPV2 "' + EAP_PASSWORD + '" [2]\n' +}; +const CA_CERT = { + path: HOSTAPD_CONFIG_PATH + 'ca.pem', + content: '-----BEGIN CERTIFICATE-----\n' + + 'MIIDsTCCApmgAwIBAgIJAKxTf+8X8qngMA0GCSqGSIb3DQEBCwUAMG4xCzAJBgNV\n' + + 'BAYTAlRXMRMwEQYDVQQIDApTb21lLVN0YXRlMREwDwYDVQQKDAhjaHVja2xlZTER\n' + + 'MA8GA1UEAwwIY2h1Y2tsZWUxJDAiBgkqhkiG9w0BCQEWFWNodWNrbGkwNzA2QGdt\n' + + 'YWlsLmNvbTAgFw0xNDEyMjQxMTI4NTBaGA8yMjg4MTAwNzExMjg1MFowbjELMAkG\n' + + 'A1UEBhMCVFcxEzARBgNVBAgMClNvbWUtU3RhdGUxETAPBgNVBAoMCGNodWNrbGVl\n' + + 'MREwDwYDVQQDDAhjaHVja2xlZTEkMCIGCSqGSIb3DQEJARYVY2h1Y2tsaTA3MDZA\n' + + 'Z21haWwuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAo3c2yFxY\n' + + 'o6gGg0I83jy00ME+MAfzCd+4ShL45ZLqysQP93jRBfPzU9ZuZ29ysVwgWIdqkZao\n' + + 'XTuV/NAW2GMGd8W1jQJ3J81fjb9wvhlny3rrACwvUn1N1S1BnM+BAAiDLGxEmvAQ\n' + + 'onp2aaa6HsHsYS8ONX+d2Qh4LEA4vupeSGAqJychCZv/l+aq/ErFZhFYB3CPUQEt\n' + + 'cClO24ucsIYP95lA0zhscnmAj06qplFD4Bv6IVrdDqujy1zNwCQwsJq/8OQdaTN/\n' + + 'h3y9pWvNKMBMM2niOUAjtuNpqsSK/lTS1WAT3PdtVECX9fYBi0Bg+HM92xs/6gt6\n' + + 'kh9jPV8keXHvSwIDAQABo1AwTjAdBgNVHQ4EFgQU7hBqhuG04xeCzrQ3ngx18ZJ3\n' + + 'lUswHwYDVR0jBBgwFoAU7hBqhuG04xeCzrQ3ngx18ZJ3lUswDAYDVR0TBAUwAwEB\n' + + '/zANBgkqhkiG9w0BAQsFAAOCAQEAFYX2iy680GAnBTttk0gyX6gk+8pYr3D22k/G\n' + + '6rvcjefzS7ELQPRKr6mfmwXq3mMf/4jiS2zI5zmXsestPYzHYxf2viQ6t7vr9XiJ\n' + + '3WfFjNw4ERlRisAvg0aqqTNNQq5v2VME4sdFZagy217f73C7azwCHl0bqOLH05rl\n' + + '8RubOxiHEj7ZybJqnRciK/bht4D+rZkwf4bBBmoloqH7xT0+rFQclpYXDGGjNUQB\n' + + 'LcHLF10xcr7g3ZVVu82fe6+d85gIGOIMR9+TKhdw6gO3CNcnDAj6gxksghgtcxmh\n' + + 'OzOggCn7nlIwImtsg2sZkpWB4lEi9hdv4lkNuyFjOL3bnuc+NA==\n' + + '-----END CERTIFICATE-----\n' +}; + +const SERVER_CERT = { + path: HOSTAPD_CONFIG_PATH + 'server.pem', + content: '-----BEGIN CERTIFICATE-----\n' + + 'MIID1DCCArygAwIBAgIBADANBgkqhkiG9w0BAQsFADBuMQswCQYDVQQGEwJUVzET\n' + + 'MBEGA1UECAwKU29tZS1TdGF0ZTERMA8GA1UECgwIY2h1Y2tsZWUxETAPBgNVBAMM\n' + + 'CGNodWNrbGVlMSQwIgYJKoZIhvcNAQkBFhVjaHVja2xpMDcwNkBnbWFpbC5jb20w\n' + + 'IBcNMTQxMjI0MTEyOTQ5WhgPMjI4ODEwMDcxMTI5NDlaMG4xCzAJBgNVBAYTAlRX\n' + + 'MRMwEQYDVQQIDApTb21lLVN0YXRlMREwDwYDVQQKDAhjaHVja2xlZTERMA8GA1UE\n' + + 'AwwIY2h1Y2tsZWUxJDAiBgkqhkiG9w0BCQEWFWNodWNrbGkwNzA2QGdtYWlsLmNv\n' + + 'bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMdhQmKilTJbWZRxTiSV\n' + + 'rqIU+LYW1RKghx5o+0JpNRJVLuz5kBMaNskbbfUSNuHbEq0QA9BDKAZWIc4LSotk\n' + + 'lCo8TbcO9CJvJPQGGjGdHcohWX5vy6BE/OVE46CUteMFyZF6F8R2fNUww08iR/u1\n' + + 'YZebL5pWO1j43sPpAzEy6Tij2ACPt6EZcFaZG3SF2mVJWkCQnBqrojP65WUvZQqp\n' + + 'seUhW2YAS8Nu0Yrohgxz6VYk+cNDuDZVGs6qWRStZzJfYrfc76DtkHof5B14M+xp\n' + + 'XJaBLxN+whvnYkDTfinaCxnW1O7eXUltr87fLc5zmeBkgwaiaQuIdcfZm7vDUiz8\n' + + 'vnUCAwEAAaN7MHkwCQYDVR0TBAIwADAsBglghkgBhvhCAQ0EHxYdT3BlblNTTCBH\n' + + 'ZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFKK4f9/YavTHOfEiAB83Deac\n' + + '6gT5MB8GA1UdIwQYMBaAFO4QaobhtOMXgs60N54MdfGSd5VLMA0GCSqGSIb3DQEB\n' + + 'CwUAA4IBAQBWnO9o9KSJIqjoz5Nwll63ULOdcvgGdOeJIw1fcKQ817Rsp+TVcjcH\n' + + 'IrIADsT/QZGXRO/l6p1750e2iFtJEo1hsRaxtA1wWn2I9HO3+av2spQhr3jpYGPf\n' + + 'zpsMTp4RNYV7Q8+q1kZIz9PY4V1T0p6lveK8+fUj2hSLnxSj0QiGSJJtnEC3w4Rv\n' + + 'C9T6oUwIeToULmi+8FXQFdEqwKRU98DPq3eLzN28ZxUgoPE1C8+42D2UW8uyp/Gm\n' + + 'tGOa/k7nzkCdVqZI7lX7f0AjEvQgjtAMQ/k7Mhxx7TzW2HO+1YPMoKji6Z4WkNwt\n' + + 'JEj9ZUBSNt8B26UksJMBDkcvSegF3a7o\n' + + '-----END CERTIFICATE-----\n' +}; + +const SERVER_KEY = { + path: HOSTAPD_CONFIG_PATH + 'server.key', + content: '-----BEGIN RSA PRIVATE KEY-----\n' + + 'MIIEpAIBAAKCAQEAx2FCYqKVMltZlHFOJJWuohT4thbVEqCHHmj7Qmk1ElUu7PmQ\n' + + 'Exo2yRtt9RI24dsSrRAD0EMoBlYhzgtKi2SUKjxNtw70Im8k9AYaMZ0dyiFZfm/L\n' + + 'oET85UTjoJS14wXJkXoXxHZ81TDDTyJH+7Vhl5svmlY7WPjew+kDMTLpOKPYAI+3\n' + + 'oRlwVpkbdIXaZUlaQJCcGquiM/rlZS9lCqmx5SFbZgBLw27RiuiGDHPpViT5w0O4\n' + + 'NlUazqpZFK1nMl9it9zvoO2Qeh/kHXgz7GlcloEvE37CG+diQNN+KdoLGdbU7t5d\n' + + 'SW2vzt8tznOZ4GSDBqJpC4h1x9mbu8NSLPy+dQIDAQABAoIBAASG4Mr8hgaurEoC\n' + + 'iJOsElr7vunjetMBcg/uskW/vcS8ymP3Bp5oafYG+WgnEbfvEW18f5mq7K24JuxW\n' + + 'tUqU7ghHdjxByqk9fMlNmiqmNpbwSufkAeuRpWxPNBvhRH/zEbCL5R5A0nTEtqqF\n' + + 'TL0aUSzwCRSoAJD0lZo9ICVt0n3GsDyM9rqQg/uZmh1qsRdwPsRuYORND9g48rKq\n' + + '6WN9leskSxhhsYE2D9ocOFd9bNt8Zxejh9ppVSnG/KsIdt18iBzcabatgAQ046fb\n' + + 'Z3vprcZJLg93Sg2gSuVqlSTs3M2W8VQnm22/EBMb1y0M48MSRCgnbPLG/CcCLLfF\n' + + 'LwxCOgECgYEA/eYt67xyJ6JeAdxdwOZuT1WWGbFpLiG9+2OgiHumyRQ5969XMTWo\n' + + 'fIhMKchDdjoy9RR236\/\/EFCs7UEyB7+a7ODRzNiK2zCD8Smjp+21fUPSthEeQesk\n' + + 'eiMYICIu5Ay35x9sxIX+XOUVvRhPOGcD29GVeRnKh1inTHOz2dje8LkCgYEAyQeY\n' + + 'STi9jjCEcHkM1E/UeDiLfHHepLXi8wS41JNRHl5Jacp7XB5djAjKu/jf367/VpFy\n' + + 'GDDMetE7n8eWkrnAvovxOwZ000YDMtL1sUYSjL+XtBS5s6VY1p4qaSAY9nUUGrJh\n' + + 'JvtvsuI7SKTtL+60vjBOH7zDnvOdBgAp0utLhZ0CgYEAuLzzqrPKB8afShFSchn4\n' + + 'J2dpuLYahsNsXW7HDqeR2nsKFosRETAusLXnXPtnAq4kB6jlOarwFqnsuRCX24Vx\n' + + 'r2uBm9/vYL7zMdUPTA+s30ErHuhjsKjsOKYyVqcooSwT32pBFNk+E89nutfmRG7I\n' + + 'IvhjHuNCNqqtx/Xj5d1jkZkCgYBQicppC2Jl5OoqZVTOem0U/RJk+PnJ41TZJ7sk\n' + + '7yBAmmWvDH\/\/l+rCf4M5a6vFYcbKV9rt9h711X2dtciNX/3oWQh8LUoAmrwNUJc+\n' + + 'PmSQHvIYI3WCk2vUD+nN1B4sHxu+1lg11eYaNKiroeeknG2tBI1ICcgVlmQCU25u\n' + + 'IfZPwQKBgQCdO6QHhPLtcHUDNFA6FQ1jKL1iEd7G0JLVRz4Xkpkn1Vrr5MD6JFDa\n' + + '5ccabADyl0lpFqDIVJQIzLku2hOD2i9aBNCY0pL391HeOS7CkZX+TdOY1tquoBq5\n' + + 'MnmixZjDCVd2VcrVyTA6ntOBoharKFW0rH1PqU+qu7dZF7CBPbAdEw==\n' + + '-----END RSA PRIVATE KEY-----\n' +}; + +const WPA_EAP_AP_LIST = [ + { + ssid: 'WPA-EAP-TLS', + ieee8021x: 1, + eapol_version: 1, + eap_server: 1, + eapol_key_index_workaround: 0, + eap_user_file: SERVER_EAP_USER_CONF.path, + ca_cert: CA_CERT.path, + server_cert: SERVER_CERT.path, + private_key: SERVER_KEY.path, + wpa: 2, + wpa_key_mgmt: 'WPA-EAP' + } +]; + +const CLIENT_PKCS12_CERT = { + nickname: 'client', + password: 'password', + usage: ['UserCert', 'ServerCert'], + content: [0x30, 0x82, 0x0E, 0x01, 0x02, 0x01, 0x03, 0x30, + 0x82, 0x0D, 0xC7, 0x06, 0x09, 0x2A, 0x86, 0x48, + 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01, 0xA0, 0x82, + 0x0D, 0xB8, 0x04, 0x82, 0x0D, 0xB4, 0x30, 0x82, + 0x0D, 0xB0, 0x30, 0x82, 0x08, 0x67, 0x06, 0x09, + 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, + 0x06, 0xA0, 0x82, 0x08, 0x58, 0x30, 0x82, 0x08, + 0x54, 0x02, 0x01, 0x00, 0x30, 0x82, 0x08, 0x4D, + 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, + 0x01, 0x07, 0x01, 0x30, 0x1C, 0x06, 0x0A, 0x2A, + 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, + 0x06, 0x30, 0x0E, 0x04, 0x08, 0x67, 0x7A, 0xF3, + 0x61, 0xBE, 0xE0, 0x51, 0xC1, 0x02, 0x02, 0x08, + 0x00, 0x80, 0x82, 0x08, 0x20, 0xFC, 0x6A, 0x79, + 0xA1, 0x6C, 0xAF, 0xBE, 0xEE, 0x62, 0x45, 0x33, + 0xB8, 0x48, 0xE1, 0x68, 0xA1, 0x15, 0x11, 0x4B, + 0x95, 0xCB, 0x77, 0xC0, 0x5D, 0xA2, 0xCB, 0xDB, + 0xD1, 0x83, 0x74, 0x60, 0xD7, 0xEC, 0x42, 0xA6, + 0x3A, 0x23, 0xF7, 0x85, 0xEB, 0xC1, 0xFE, 0x6A, + 0x57, 0x8E, 0xC1, 0x44, 0xF3, 0x1F, 0xFE, 0xB8, + 0x2D, 0x8C, 0x4D, 0xC9, 0x5B, 0xAE, 0x21, 0x2E, + 0x4C, 0x1A, 0xEB, 0x84, 0x09, 0xF3, 0x40, 0x92, + 0x39, 0x7F, 0x56, 0x02, 0x46, 0x61, 0x16, 0xDE, + 0x5C, 0x48, 0xB6, 0x0C, 0x1D, 0xD3, 0x5F, 0x10, + 0x9A, 0x39, 0xB8, 0x66, 0x31, 0xFC, 0x39, 0x71, + 0x87, 0x23, 0x46, 0x9D, 0xE8, 0x3C, 0x2B, 0xA1, + 0x39, 0x8A, 0xD3, 0xFF, 0xD9, 0x43, 0xB6, 0x61, + 0xC6, 0x67, 0x70, 0x40, 0xBD, 0xFE, 0xD3, 0xC1, + 0x68, 0xF5, 0xF7, 0xC8, 0x89, 0xD8, 0x17, 0xC5, + 0xE8, 0x3D, 0x29, 0xD5, 0x91, 0xDF, 0x1F, 0x56, + 0x74, 0x5A, 0xC4, 0xA8, 0x14, 0xBA, 0xD4, 0xFA, + 0x13, 0x49, 0x2A, 0x9F, 0x63, 0xF1, 0xB2, 0x45, + 0xF1, 0xF0, 0x2A, 0xDD, 0x75, 0x66, 0x8A, 0xF7, + 0xAB, 0x73, 0x86, 0x26, 0x9D, 0x1F, 0x07, 0xAD, + 0xD3, 0xFE, 0xE0, 0xA3, 0xED, 0xA0, 0x96, 0x3E, + 0x1E, 0x89, 0x86, 0x02, 0x4C, 0x28, 0xFD, 0x57, + 0xA1, 0x67, 0x55, 0xF0, 0x82, 0x3B, 0x7F, 0xCC, + 0x2A, 0x32, 0x01, 0x93, 0x1D, 0x8B, 0x66, 0x8A, + 0x20, 0x52, 0x84, 0xDD, 0x2C, 0xFD, 0xEE, 0x72, + 0xF3, 0x8C, 0x58, 0xB9, 0x99, 0xE5, 0xC1, 0x22, + 0x63, 0x59, 0x00, 0xE2, 0x76, 0xC5, 0x3A, 0x17, + 0x7F, 0x93, 0xE9, 0x67, 0x61, 0xAA, 0x10, 0xC3, + 0xD9, 0xC8, 0x24, 0x46, 0x5B, 0xBE, 0x8C, 0x1F, + 0x2D, 0x66, 0x48, 0xD2, 0x02, 0x11, 0xFB, 0x74, + 0x14, 0x76, 0x76, 0x5A, 0x98, 0x54, 0x35, 0xA7, + 0x85, 0x66, 0x20, 0x26, 0x8B, 0x13, 0x6F, 0x68, + 0xE3, 0xC9, 0x58, 0x7D, 0x1C, 0x3E, 0x01, 0x8D, + 0xF8, 0xD6, 0x7F, 0xCF, 0xA2, 0x07, 0xB7, 0x95, + 0xFD, 0xF0, 0x02, 0x34, 0x32, 0x30, 0xE8, 0xD4, + 0x57, 0x5E, 0x53, 0xFB, 0x54, 0xE2, 0x03, 0x32, + 0xCC, 0x52, 0x2E, 0xD2, 0x35, 0xD9, 0x58, 0x85, + 0x2D, 0xEC, 0x2D, 0x71, 0xD1, 0x8A, 0x29, 0xD0, + 0xB0, 0x24, 0xBD, 0x24, 0xDC, 0x1A, 0x28, 0x3F, + 0xA0, 0x12, 0x81, 0x15, 0x24, 0xC9, 0xB5, 0x4A, + 0x23, 0xB6, 0xA3, 0x45, 0x50, 0x2D, 0x73, 0x99, + 0x6B, 0x1C, 0xFB, 0xA4, 0x53, 0xD7, 0x5C, 0xF4, + 0x6C, 0xB0, 0xE5, 0x74, 0xB3, 0x76, 0xF8, 0xB1, + 0x0D, 0x59, 0x70, 0x9F, 0xCA, 0xDE, 0xF2, 0xAA, + 0x4C, 0x7D, 0x11, 0x54, 0xC4, 0x19, 0x0F, 0x36, + 0x4A, 0x62, 0xFF, 0x8B, 0x10, 0xCB, 0x93, 0x50, + 0xDA, 0x79, 0x5E, 0x4E, 0x09, 0x1F, 0x22, 0xC8, + 0x19, 0x85, 0xE9, 0xEE, 0xB7, 0x71, 0x65, 0xB9, + 0x10, 0xD2, 0x0A, 0x73, 0x5B, 0xA6, 0xDA, 0x37, + 0x46, 0x02, 0x00, 0x98, 0x9E, 0x20, 0x6C, 0x7D, + 0xC7, 0x69, 0xBB, 0xC2, 0x00, 0x40, 0x9C, 0x57, + 0x00, 0xC2, 0x36, 0x76, 0xE8, 0x2A, 0x8D, 0xAD, + 0x62, 0x57, 0xC8, 0xD0, 0x9D, 0x66, 0x27, 0x5A, + 0xD8, 0x0D, 0x35, 0x60, 0x28, 0x38, 0x62, 0x94, + 0x78, 0x36, 0x25, 0x58, 0xFD, 0xF8, 0x66, 0x1F, + 0x68, 0x04, 0x0F, 0xD8, 0x00, 0xDF, 0xA0, 0x6C, + 0x25, 0x42, 0x9A, 0x4C, 0xEB, 0x80, 0x13, 0x51, + 0x7D, 0x2D, 0xA8, 0x89, 0xD6, 0x1B, 0x67, 0x72, + 0x01, 0xF3, 0x2D, 0x16, 0x77, 0xFE, 0x22, 0xBC, + 0x8A, 0x45, 0x09, 0x1F, 0x9C, 0x2F, 0x2A, 0xA9, + 0x61, 0x5B, 0x4A, 0xE6, 0x64, 0x2C, 0x62, 0x1A, + 0x3A, 0x96, 0xE6, 0x0A, 0xAE, 0x05, 0x1A, 0xC8, + 0xCB, 0xD6, 0x8F, 0x3A, 0x4B, 0xE0, 0x7F, 0x82, + 0xB4, 0x98, 0xF1, 0x9D, 0xD7, 0x14, 0x76, 0x5E, + 0x77, 0x85, 0x87, 0xEC, 0x13, 0xDA, 0xFD, 0xAF, + 0xCB, 0xA3, 0x1C, 0x99, 0xC1, 0xFE, 0x17, 0x0C, + 0x40, 0x4D, 0x3C, 0x8F, 0x70, 0x86, 0x63, 0x64, + 0xB7, 0x75, 0xA8, 0x71, 0x36, 0xDC, 0x54, 0x10, + 0x57, 0x0C, 0xA8, 0xF2, 0xA1, 0xBB, 0xED, 0x03, + 0x41, 0x57, 0x34, 0x2C, 0x8F, 0x7C, 0xA0, 0x09, + 0xF3, 0x9E, 0x41, 0xB7, 0xA8, 0xD4, 0x66, 0x0D, + 0x0D, 0xC0, 0x6A, 0xFC, 0x6A, 0xA2, 0xAC, 0xE2, + 0x60, 0x00, 0xE3, 0xF7, 0x75, 0x43, 0x23, 0xEB, + 0xC8, 0x61, 0xFA, 0xB3, 0xB8, 0x28, 0xCE, 0xCA, + 0xF4, 0x47, 0x7F, 0x30, 0x6D, 0x61, 0x89, 0x47, + 0xA1, 0x4A, 0xFE, 0xD1, 0x21, 0x0B, 0x6D, 0xF4, + 0x3F, 0x00, 0x86, 0x30, 0x8E, 0x33, 0x21, 0x6F, + 0xDA, 0x15, 0xFD, 0x5F, 0xEC, 0x8E, 0xF1, 0x12, + 0x3F, 0xC9, 0x83, 0x0C, 0xCA, 0x22, 0x01, 0xF1, + 0x70, 0x5F, 0x1F, 0x66, 0xB5, 0xF8, 0x3E, 0x7A, + 0x6F, 0xDE, 0xDB, 0xA7, 0x8D, 0x18, 0x9E, 0xBE, + 0xDB, 0xAD, 0x3D, 0x66, 0x30, 0xC1, 0x6C, 0x0C, + 0x87, 0xB4, 0x65, 0x75, 0xE0, 0x9D, 0xEA, 0x16, + 0x0D, 0x07, 0x37, 0x33, 0xC5, 0xEC, 0x97, 0x93, + 0x37, 0xEB, 0x8E, 0x65, 0x9C, 0x40, 0x63, 0x6C, + 0x43, 0x60, 0xB0, 0x40, 0x4D, 0x85, 0xEF, 0xC2, + 0x47, 0x5F, 0xE7, 0x6B, 0xCB, 0x40, 0xE8, 0xEA, + 0xD8, 0xAB, 0xB1, 0x9A, 0x72, 0xDC, 0x4C, 0x14, + 0xFA, 0x43, 0x61, 0x5F, 0xA6, 0x5C, 0x3A, 0x05, + 0x17, 0x2E, 0x74, 0xF3, 0x5E, 0x45, 0xD9, 0x47, + 0xAA, 0x59, 0xB6, 0x8F, 0x42, 0x66, 0x42, 0x29, + 0x90, 0x95, 0x48, 0x46, 0x91, 0x88, 0x3C, 0x8C, + 0xDE, 0xCC, 0xED, 0xB3, 0xAA, 0x62, 0xEA, 0xBC, + 0xB4, 0x0C, 0x48, 0x4C, 0x53, 0x23, 0x5E, 0x24, + 0x85, 0xBF, 0x92, 0xDA, 0x14, 0xDB, 0x1A, 0x3D, + 0xEF, 0x30, 0xD9, 0x49, 0x64, 0x4D, 0xE5, 0x01, + 0xFC, 0xA4, 0x4B, 0xD1, 0x9F, 0xDE, 0x96, 0x7F, + 0x50, 0xBC, 0x4D, 0x38, 0x44, 0xE9, 0x23, 0x5F, + 0x37, 0x57, 0x1A, 0xA6, 0x52, 0x5A, 0x0F, 0x4F, + 0x87, 0x33, 0x4A, 0x7B, 0x66, 0xEE, 0x3D, 0x66, + 0x0A, 0x63, 0x39, 0x1F, 0x23, 0x38, 0x35, 0x73, + 0x60, 0x5E, 0x47, 0x20, 0x4F, 0xC0, 0xC8, 0x3C, + 0x09, 0xF9, 0x29, 0x4F, 0x5E, 0x55, 0x69, 0xC4, + 0x6B, 0xE8, 0xF8, 0x91, 0xC0, 0x22, 0x65, 0x15, + 0x1E, 0xFB, 0xB9, 0x61, 0xCE, 0x45, 0xBE, 0x2B, + 0xEE, 0xB9, 0x04, 0x2B, 0xFD, 0xAE, 0x61, 0x1C, + 0x3D, 0x3D, 0x7C, 0xBF, 0xC1, 0xF7, 0x3C, 0x4E, + 0x9E, 0x0E, 0x54, 0xC8, 0xAD, 0xA9, 0xDF, 0x43, + 0x49, 0xB9, 0x41, 0x05, 0xE5, 0xF1, 0x49, 0xAA, + 0x77, 0x6C, 0x34, 0x5B, 0x93, 0x24, 0x24, 0x23, + 0x74, 0x68, 0x11, 0xCE, 0x15, 0x80, 0xA1, 0xA4, + 0x1F, 0x8D, 0x81, 0xCD, 0xB2, 0x98, 0xCA, 0x14, + 0x0B, 0x0C, 0x61, 0x50, 0x69, 0x72, 0xAE, 0xFA, + 0x8B, 0xC0, 0x3F, 0x0D, 0xE7, 0xF2, 0x0F, 0xEB, + 0xC1, 0x11, 0xB9, 0x10, 0x03, 0x6A, 0xF5, 0x97, + 0x3C, 0x53, 0x2F, 0x67, 0x86, 0x09, 0x6A, 0xE3, + 0x28, 0xC0, 0x78, 0xC8, 0xB4, 0x39, 0x8E, 0xD1, + 0xCE, 0x25, 0xE8, 0x66, 0xF7, 0x09, 0x40, 0x7D, + 0x81, 0xFB, 0xAF, 0xFA, 0x59, 0xC4, 0x9B, 0x2B, + 0x83, 0x45, 0x5B, 0xA8, 0x66, 0x9E, 0x38, 0xC8, + 0xFD, 0xAC, 0xF2, 0x2D, 0x21, 0xDE, 0x50, 0x4C, + 0x03, 0xCB, 0x88, 0x42, 0xDD, 0x84, 0x09, 0x99, + 0x8E, 0x8B, 0x40, 0x97, 0x1B, 0x14, 0x85, 0x37, + 0x11, 0x01, 0xE0, 0x74, 0x6B, 0x33, 0x52, 0x8C, + 0x68, 0x3A, 0x89, 0xB2, 0xAF, 0x35, 0xE6, 0x65, + 0xC3, 0x58, 0x70, 0xD2, 0xE7, 0x1F, 0x1F, 0xF6, + 0xE5, 0x0A, 0xB1, 0xFE, 0xD0, 0xC9, 0x51, 0x50, + 0xE7, 0xFD, 0x58, 0xF5, 0xC4, 0x58, 0x65, 0x94, + 0xD1, 0x57, 0x55, 0x5E, 0xD2, 0x27, 0x98, 0xAF, + 0xE7, 0x55, 0x0B, 0x87, 0x50, 0x9B, 0xEF, 0xE8, + 0x2B, 0xFC, 0xE7, 0x3B, 0x4E, 0xD7, 0xB7, 0x4D, + 0xF4, 0xBC, 0xF4, 0x88, 0x63, 0xE4, 0x8A, 0x20, + 0x4B, 0x22, 0xB0, 0xA0, 0x53, 0x7F, 0xA8, 0xC9, + 0x0C, 0xF8, 0xD7, 0xBD, 0x46, 0x39, 0xA7, 0x7D, + 0xDD, 0x10, 0x91, 0x50, 0x54, 0x06, 0x47, 0xF0, + 0x3C, 0xAA, 0x43, 0x40, 0xF8, 0x54, 0xDD, 0x8A, + 0xEA, 0x8A, 0x0B, 0xA5, 0x7F, 0xCD, 0x5E, 0xAA, + 0x02, 0x2E, 0x1F, 0xC6, 0x50, 0x15, 0xF8, 0x0A, + 0x0C, 0x1B, 0x3C, 0x55, 0x3A, 0xC3, 0x6F, 0x88, + 0xD7, 0xBF, 0xB1, 0x02, 0xCC, 0xE0, 0x08, 0x29, + 0x97, 0xD2, 0xAA, 0x23, 0xC4, 0x6D, 0xE3, 0xE3, + 0x76, 0x39, 0x92, 0xC3, 0x2E, 0x7A, 0xE2, 0x98, + 0xD1, 0xFC, 0xAE, 0xCC, 0x95, 0xD8, 0xB4, 0xDC, + 0x92, 0xEA, 0x6A, 0x5F, 0xF2, 0x92, 0x17, 0x0B, + 0x8D, 0xC3, 0xFA, 0x9C, 0x62, 0xCE, 0x44, 0x8D, + 0xC3, 0x1E, 0xC3, 0xB2, 0xD5, 0x00, 0xCD, 0xB4, + 0x9E, 0x2D, 0x7B, 0xF2, 0x98, 0xA3, 0x00, 0x8B, + 0x81, 0x30, 0x77, 0x5B, 0x02, 0x99, 0xB1, 0xCD, + 0xC3, 0x1D, 0x74, 0x74, 0xEF, 0x41, 0xCB, 0x69, + 0x63, 0x8E, 0xA6, 0xD3, 0x2D, 0x3E, 0x1F, 0x1D, + 0x12, 0x9E, 0xD9, 0x18, 0x67, 0x06, 0xAF, 0x37, + 0x29, 0xAD, 0x65, 0xD8, 0xEB, 0x71, 0xC4, 0x7D, + 0x94, 0x3D, 0xEA, 0xCC, 0xDF, 0x72, 0x41, 0x51, + 0x3C, 0xA1, 0x66, 0x98, 0x32, 0x32, 0x40, 0x54, + 0xB0, 0x2F, 0xEB, 0xCE, 0xDF, 0x4A, 0x64, 0xFB, + 0x9A, 0x90, 0xDC, 0xF6, 0x6F, 0xA9, 0xD4, 0xCA, + 0xCB, 0x91, 0xC4, 0xFE, 0xEE, 0x9C, 0x01, 0x50, + 0x2E, 0xAC, 0xCC, 0x5F, 0x89, 0xD0, 0x91, 0xA3, + 0xD9, 0xF9, 0x4B, 0x8D, 0xDE, 0x6C, 0x60, 0x21, + 0x19, 0xB1, 0xD3, 0x4D, 0x75, 0x56, 0x6F, 0xB8, + 0x25, 0xA4, 0x92, 0x4F, 0x12, 0xF5, 0x8F, 0xC1, + 0x17, 0x4B, 0xB3, 0x34, 0x21, 0x22, 0xAC, 0x52, + 0xD2, 0x64, 0xC9, 0x9A, 0x7D, 0xFC, 0xC0, 0x0A, + 0x89, 0x34, 0xFF, 0x08, 0xD3, 0x04, 0xDC, 0xFE, + 0x7C, 0xB3, 0xB8, 0xFD, 0x85, 0xDD, 0x79, 0x51, + 0xA7, 0x89, 0xE8, 0xF1, 0x23, 0xB1, 0xDF, 0xD7, + 0x1F, 0x7B, 0xB1, 0x5D, 0x42, 0xF9, 0x61, 0xF8, + 0xDC, 0x81, 0x04, 0xF1, 0xCC, 0xFA, 0xD7, 0xED, + 0xBF, 0x47, 0xAC, 0xBD, 0xE5, 0xFA, 0xAC, 0xB3, + 0x1C, 0xD9, 0xA1, 0xB3, 0x60, 0xEE, 0x9C, 0x8A, + 0x36, 0x57, 0xB4, 0x2F, 0xA1, 0xA2, 0xF3, 0xE2, + 0x09, 0x9A, 0x6E, 0x43, 0x9B, 0xE5, 0x93, 0xB8, + 0x3D, 0x9E, 0x9F, 0xC1, 0xC6, 0x0D, 0x02, 0xEB, + 0x4D, 0x38, 0xE9, 0xB4, 0x9F, 0xEA, 0x33, 0x8C, + 0x07, 0xD8, 0xB4, 0x71, 0xAD, 0xE5, 0x43, 0xB2, + 0xCC, 0x55, 0x93, 0x6A, 0xDB, 0x1E, 0x80, 0xDB, + 0xC2, 0xEA, 0x42, 0x8E, 0xFC, 0x86, 0x44, 0xC9, + 0x8A, 0xC4, 0xF2, 0x46, 0xA7, 0x39, 0x50, 0x0D, + 0x1A, 0xAA, 0x07, 0x04, 0xBE, 0xD4, 0xCE, 0x62, + 0x4D, 0x0F, 0x91, 0x7D, 0x29, 0x88, 0x9C, 0x4C, + 0xAF, 0xF7, 0xD8, 0x40, 0x93, 0x88, 0xC7, 0x20, + 0xD2, 0x17, 0x2A, 0xC4, 0x92, 0x72, 0xD0, 0xC0, + 0x4E, 0x56, 0x47, 0xB1, 0x27, 0x02, 0xE6, 0x61, + 0x82, 0x5E, 0xC8, 0x2E, 0x90, 0xD2, 0x31, 0x22, + 0xE2, 0xA9, 0x4A, 0x91, 0x45, 0x69, 0xB1, 0xA5, + 0x0F, 0x66, 0x2C, 0x30, 0xAD, 0x7F, 0x1B, 0x0E, + 0x22, 0x17, 0x60, 0x2E, 0x3D, 0x7F, 0x7F, 0x8C, + 0x33, 0x51, 0xA0, 0x25, 0xDE, 0xFD, 0x75, 0xBC, + 0xEF, 0xE6, 0xE7, 0x20, 0x04, 0x5A, 0xEC, 0x50, + 0x21, 0x48, 0x56, 0x98, 0xE2, 0x33, 0x6D, 0x22, + 0x5C, 0xC3, 0xFB, 0xFC, 0x6F, 0xB3, 0xA7, 0x8E, + 0x6F, 0x67, 0x70, 0x9D, 0xDA, 0x02, 0x01, 0x59, + 0x7B, 0x3D, 0x2B, 0x38, 0xCC, 0x0F, 0x44, 0x3D, + 0xFB, 0x9A, 0xB3, 0x23, 0x15, 0x50, 0x6E, 0xBF, + 0x8B, 0xA1, 0x94, 0x33, 0xE5, 0x7B, 0x88, 0x4E, + 0xCB, 0x6D, 0x9F, 0xBF, 0xBC, 0x7A, 0xA8, 0x1E, + 0x68, 0x25, 0xED, 0x8E, 0x53, 0x21, 0x72, 0xC5, + 0x70, 0xB3, 0xE4, 0xA6, 0xA1, 0x5A, 0x2D, 0xC8, + 0x43, 0x9D, 0x60, 0x77, 0x78, 0xE0, 0xC4, 0xAF, + 0xC8, 0x29, 0xBA, 0xD0, 0x4D, 0x39, 0x83, 0x51, + 0xA7, 0x10, 0x7F, 0x0C, 0x34, 0x0E, 0x6C, 0x75, + 0x26, 0xD7, 0xD6, 0xC7, 0x32, 0x53, 0xAF, 0x4E, + 0xBE, 0xF2, 0xC2, 0x0F, 0x99, 0x23, 0xB9, 0xE1, + 0xC8, 0xB4, 0xBC, 0x5A, 0xC6, 0xCB, 0xEB, 0x4D, + 0x28, 0x56, 0x72, 0xFE, 0x1B, 0x2C, 0x5D, 0xE3, + 0xBC, 0xC7, 0xA3, 0xC0, 0x7D, 0x27, 0xF0, 0xD0, + 0x4F, 0x3F, 0x1F, 0xF7, 0x87, 0x15, 0xF2, 0xEA, + 0xD4, 0x03, 0x6D, 0x2F, 0xD4, 0x8E, 0x50, 0x4B, + 0x05, 0xBF, 0xF7, 0x8C, 0x67, 0x5A, 0xDC, 0x4D, + 0xCD, 0xCF, 0x9D, 0x02, 0xB6, 0xE7, 0xAE, 0x49, + 0xD1, 0x7C, 0x00, 0xE7, 0x3B, 0xEA, 0xFB, 0x0D, + 0x2A, 0x7B, 0x41, 0x33, 0x66, 0xD0, 0x29, 0x9F, + 0xB3, 0x8A, 0x71, 0xB0, 0xE2, 0x76, 0xA9, 0xDB, + 0xFD, 0x64, 0x04, 0x69, 0xDF, 0x89, 0x1F, 0x56, + 0x86, 0x92, 0xD9, 0xD9, 0xB9, 0xF3, 0x4F, 0xAC, + 0xAE, 0x61, 0x48, 0x20, 0xCE, 0x3C, 0x2B, 0x44, + 0xAB, 0x42, 0xFA, 0xAB, 0x2E, 0x94, 0x82, 0xC8, + 0xD9, 0x97, 0xCF, 0x27, 0xDF, 0xAC, 0xAC, 0xE7, + 0xCA, 0xB2, 0x84, 0xAB, 0xF2, 0x5D, 0xDF, 0x56, + 0x0C, 0x8C, 0x07, 0x3C, 0x3D, 0xA8, 0xDD, 0xBE, + 0xFF, 0x4E, 0x28, 0x0D, 0xB2, 0x2D, 0xE6, 0x9D, + 0x44, 0x21, 0xCB, 0xE7, 0x33, 0x63, 0x22, 0x8F, + 0x4C, 0xFF, 0xB6, 0x1D, 0x9A, 0x71, 0x3F, 0xB1, + 0x29, 0xAE, 0x3A, 0x35, 0xEE, 0x9C, 0x97, 0x68, + 0xA7, 0x52, 0x66, 0x01, 0xD8, 0x9A, 0x5D, 0xF4, + 0xB3, 0x2F, 0x5C, 0xD4, 0x0E, 0xF9, 0xCF, 0x07, + 0xF6, 0x8C, 0xBA, 0xA6, 0x8D, 0x6B, 0xC6, 0x01, + 0xC2, 0x69, 0xAE, 0x60, 0x08, 0x1A, 0x0E, 0x3F, + 0xAE, 0x60, 0x29, 0xF3, 0x48, 0x0D, 0xE0, 0xD0, + 0xAE, 0x52, 0x44, 0xE9, 0x7F, 0x1F, 0x92, 0x5F, + 0x71, 0xAD, 0xEC, 0x6B, 0x47, 0x66, 0x92, 0x22, + 0x27, 0xAE, 0x6E, 0x25, 0xCD, 0xF3, 0x5F, 0x55, + 0x59, 0xBD, 0x73, 0xCE, 0x2B, 0x7E, 0x99, 0x44, + 0x56, 0x70, 0xA3, 0xE7, 0x7A, 0x59, 0x75, 0xD8, + 0x48, 0x0C, 0x39, 0x2B, 0xD7, 0x53, 0xC6, 0xAD, + 0x4A, 0x6F, 0xB4, 0x14, 0x96, 0xDF, 0xF2, 0x4A, + 0x0C, 0xA2, 0xD5, 0x29, 0x98, 0x7C, 0x42, 0x87, + 0xD9, 0x1F, 0x97, 0x61, 0xD9, 0xBF, 0x99, 0x4F, + 0x2C, 0x4C, 0x75, 0xAC, 0xB8, 0x06, 0x75, 0xD6, + 0x87, 0x76, 0x7E, 0xE3, 0x23, 0x4B, 0xEA, 0x1A, + 0x1A, 0xF4, 0xB7, 0x09, 0xAF, 0x53, 0xEB, 0xA6, + 0x39, 0x10, 0xFE, 0xD4, 0xEB, 0x1B, 0xAE, 0x38, + 0x31, 0x33, 0xBA, 0x68, 0xEE, 0xC7, 0x65, 0x76, + 0xFB, 0x49, 0x77, 0xD4, 0x19, 0xC4, 0xE6, 0xA7, + 0x05, 0xFE, 0x2A, 0xDA, 0x39, 0x99, 0x1A, 0x92, + 0xD2, 0xF0, 0x61, 0x97, 0xF6, 0x06, 0x6C, 0x88, + 0x7B, 0x6F, 0x60, 0xE6, 0x70, 0x08, 0xF0, 0xB4, + 0x6B, 0x39, 0x6F, 0x05, 0x41, 0x81, 0xF9, 0xBE, + 0x7A, 0x51, 0xC4, 0x75, 0xB0, 0x6A, 0x89, 0xA0, + 0xA6, 0x9A, 0x5B, 0xEE, 0x7D, 0x78, 0x17, 0x5F, + 0x9F, 0x3B, 0x7D, 0xDD, 0x8A, 0x9E, 0xAA, 0x1A, + 0xDA, 0x49, 0x08, 0xE9, 0xFD, 0x91, 0xA6, 0xFA, + 0xCE, 0xCF, 0x67, 0xDF, 0x0F, 0xC9, 0xD6, 0x38, + 0xD9, 0xD5, 0xD1, 0xC0, 0x76, 0x59, 0x42, 0x53, + 0xBF, 0x48, 0xE9, 0x11, 0x74, 0xC7, 0x11, 0xD8, + 0xE7, 0x8E, 0xD3, 0xC8, 0x25, 0xA1, 0x26, 0x50, + 0xBB, 0xB4, 0x35, 0xAF, 0xAF, 0x06, 0x23, 0x69, + 0x3E, 0x30, 0xFD, 0x7B, 0x34, 0x83, 0x07, 0xD0, + 0xF0, 0x0F, 0x6C, 0x9A, 0x13, 0x5D, 0xC2, 0x7B, + 0xDF, 0x6F, 0xDD, 0x8E, 0xF4, 0x30, 0x82, 0x05, + 0x41, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, + 0x0D, 0x01, 0x07, 0x01, 0xA0, 0x82, 0x05, 0x32, + 0x04, 0x82, 0x05, 0x2E, 0x30, 0x82, 0x05, 0x2A, + 0x30, 0x82, 0x05, 0x26, 0x06, 0x0B, 0x2A, 0x86, + 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, + 0x02, 0xA0, 0x82, 0x04, 0xEE, 0x30, 0x82, 0x04, + 0xEA, 0x30, 0x1C, 0x06, 0x0A, 0x2A, 0x86, 0x48, + 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x03, 0x30, + 0x0E, 0x04, 0x08, 0x74, 0xC0, 0x84, 0x8F, 0xC7, + 0x74, 0x5E, 0x21, 0x02, 0x02, 0x08, 0x00, 0x04, + 0x82, 0x04, 0xC8, 0x1E, 0xF4, 0xE9, 0x07, 0x27, + 0x9E, 0x5A, 0xC9, 0x39, 0x1D, 0x37, 0x2C, 0x06, + 0x4B, 0x57, 0xEA, 0xC5, 0x42, 0x9A, 0x60, 0xD5, + 0x42, 0xB2, 0x34, 0x2D, 0xD3, 0x88, 0x7C, 0x78, + 0x87, 0xB6, 0xE9, 0x42, 0x44, 0x1F, 0x67, 0x32, + 0x92, 0x54, 0x22, 0xDA, 0xB2, 0x43, 0xE7, 0x40, + 0xBE, 0x1F, 0xAF, 0x3A, 0xCD, 0x2A, 0x9F, 0xD7, + 0x44, 0x5B, 0x37, 0x69, 0x85, 0xDF, 0xEB, 0x2A, + 0xB9, 0xE2, 0x92, 0x3B, 0xEA, 0xD5, 0x42, 0x53, + 0x95, 0x4A, 0xB0, 0x1B, 0xA5, 0xEF, 0xA6, 0x0D, + 0x29, 0xF4, 0x33, 0xFE, 0xD7, 0x49, 0x04, 0x1E, + 0x8C, 0xAD, 0x63, 0x1E, 0x79, 0x63, 0x74, 0x0C, + 0xE5, 0x5E, 0xA2, 0x2C, 0xBE, 0xB8, 0x90, 0xCE, + 0x06, 0x25, 0xBF, 0xD1, 0x5A, 0x50, 0xCF, 0x3B, + 0x52, 0xE2, 0xA7, 0xFF, 0x19, 0x02, 0xCF, 0xD0, + 0x9B, 0xD9, 0xF7, 0x28, 0x07, 0x38, 0x1F, 0xF2, + 0xAF, 0x44, 0x91, 0x3F, 0x0F, 0xB6, 0x6E, 0x8C, + 0xC0, 0x32, 0x92, 0xC0, 0xCD, 0x25, 0x98, 0x67, + 0xF1, 0x47, 0x52, 0x50, 0xF0, 0xA3, 0x7B, 0xE6, + 0x74, 0xDC, 0x72, 0x28, 0xC8, 0xAB, 0xB3, 0x31, + 0x7D, 0xA3, 0xF7, 0xC7, 0xD1, 0xE6, 0x99, 0xB4, + 0xB6, 0x5A, 0x3A, 0x4D, 0x83, 0x4F, 0xB8, 0xB5, + 0x86, 0xF8, 0x37, 0x7F, 0xA0, 0x16, 0x2F, 0x3C, + 0x62, 0x7A, 0xD4, 0x3A, 0xEB, 0xC2, 0xE8, 0x03, + 0x49, 0x17, 0x9E, 0xFB, 0xD7, 0xAF, 0x91, 0x32, + 0xFD, 0xEA, 0x4F, 0x64, 0xC6, 0x6E, 0x02, 0xEA, + 0xC4, 0xC8, 0x1F, 0x16, 0xC5, 0x4C, 0xFB, 0xC5, + 0x42, 0xF5, 0x85, 0x05, 0x92, 0x59, 0x4B, 0x31, + 0xE5, 0xE9, 0x69, 0xE7, 0x02, 0x98, 0x33, 0xBA, + 0x4C, 0x17, 0x09, 0xEF, 0x89, 0x20, 0xFA, 0x83, + 0x9F, 0xAE, 0x0E, 0x1B, 0x7D, 0x98, 0xB9, 0xF2, + 0x3C, 0x0F, 0xB7, 0x1C, 0x72, 0xDF, 0x17, 0x84, + 0x7F, 0x0A, 0xFD, 0x12, 0x3C, 0x6F, 0x68, 0x5D, + 0x45, 0xEB, 0xB8, 0xD6, 0x24, 0x65, 0x42, 0x75, + 0x5C, 0xC2, 0xF3, 0x3A, 0x6A, 0x4E, 0x51, 0x34, + 0x1B, 0xB6, 0x81, 0xB2, 0x8A, 0xEF, 0x28, 0xA4, + 0xC5, 0x88, 0x9A, 0x97, 0xE0, 0xEF, 0x31, 0x12, + 0x01, 0x7E, 0x1B, 0x43, 0x0F, 0x27, 0x80, 0x87, + 0x98, 0xC5, 0xD5, 0x83, 0xCB, 0x4B, 0xB7, 0x01, + 0x79, 0x60, 0xA1, 0x1A, 0x03, 0x05, 0xC6, 0x36, + 0x04, 0x31, 0x3C, 0x06, 0xDB, 0x08, 0xA8, 0xDA, + 0x8E, 0x32, 0x19, 0x91, 0xF1, 0x0D, 0x61, 0x6F, + 0xE4, 0xB2, 0x79, 0x8A, 0xDE, 0xF4, 0xF7, 0xFB, + 0x2C, 0x23, 0x5B, 0xD9, 0x64, 0x2F, 0xB7, 0xB3, + 0x8B, 0xCA, 0xB8, 0x8C, 0x1D, 0x3B, 0x49, 0x05, + 0x38, 0xA1, 0xE5, 0x8C, 0x1A, 0xDC, 0xA5, 0x61, + 0xFE, 0xF4, 0x2B, 0xDC, 0x77, 0x28, 0xF6, 0x19, + 0xE7, 0xB7, 0x8F, 0x4D, 0x27, 0x2D, 0xED, 0x8A, + 0x3F, 0x3D, 0xDC, 0x9F, 0xD1, 0x30, 0xFF, 0xD6, + 0xC3, 0xBE, 0x41, 0x25, 0xE3, 0xA5, 0x9B, 0x73, + 0xDF, 0x6A, 0xD9, 0xF9, 0x70, 0x84, 0x02, 0x4C, + 0x35, 0xD4, 0x3E, 0x05, 0x76, 0x3A, 0xDC, 0x6D, + 0x5A, 0x81, 0xB3, 0x94, 0xF7, 0x22, 0xF7, 0xDC, + 0xC1, 0x43, 0x31, 0x57, 0x5B, 0x42, 0x9A, 0x0B, + 0xF4, 0x95, 0x30, 0xA9, 0xBB, 0xD8, 0x06, 0xFB, + 0x1D, 0x6F, 0x9B, 0xC3, 0xBB, 0xF3, 0xBF, 0xFB, + 0xB4, 0x9F, 0x35, 0x64, 0x0A, 0x69, 0xB7, 0xD1, + 0x3E, 0xCA, 0x78, 0x07, 0x04, 0x03, 0x79, 0xD4, + 0xF3, 0xA8, 0xEC, 0x18, 0xDB, 0x03, 0x5E, 0x47, + 0xD7, 0xD0, 0x56, 0x2C, 0x74, 0x94, 0x86, 0x04, + 0x46, 0xB8, 0xD4, 0x35, 0x0A, 0x7B, 0xE6, 0x78, + 0xC4, 0x43, 0x3C, 0x56, 0xCC, 0x37, 0x8B, 0xFD, + 0xE8, 0xF4, 0x57, 0xEA, 0xAE, 0xCF, 0x36, 0x97, + 0x12, 0xAC, 0x39, 0xCF, 0x7C, 0xEF, 0x22, 0x67, + 0x01, 0xEC, 0xD8, 0x09, 0x49, 0x4E, 0xE3, 0x74, + 0xDD, 0x39, 0xE1, 0x39, 0xD7, 0x0C, 0x5F, 0x1B, + 0xCE, 0x69, 0xBC, 0x72, 0x44, 0x87, 0x64, 0x1C, + 0x08, 0x05, 0x93, 0x69, 0x6D, 0x7F, 0x90, 0x0A, + 0x2C, 0xCB, 0x8A, 0xBB, 0x7F, 0xE3, 0xE0, 0x80, + 0x31, 0xD0, 0x0A, 0x3A, 0x95, 0xFF, 0xF7, 0xB4, + 0x36, 0x38, 0x93, 0xE0, 0x0C, 0x11, 0x37, 0x12, + 0x06, 0xF6, 0xAD, 0xE9, 0xB1, 0x7A, 0x00, 0xF5, + 0xD2, 0x32, 0x6B, 0xD0, 0x27, 0xA5, 0x1B, 0x3D, + 0xE8, 0xDB, 0xCC, 0xA9, 0x1F, 0x1F, 0xB1, 0x99, + 0x3D, 0x7C, 0xB7, 0xCA, 0xDA, 0x27, 0x2C, 0x64, + 0x1C, 0x49, 0xB6, 0x87, 0x44, 0x06, 0x94, 0x9D, + 0xBC, 0x6B, 0x20, 0xA2, 0x68, 0x15, 0x1F, 0xE2, + 0xF2, 0xAD, 0x6D, 0x23, 0x2E, 0x2B, 0x74, 0xE2, + 0x5D, 0xE4, 0xB0, 0xC7, 0x84, 0xCB, 0x64, 0xBF, + 0xE0, 0xA8, 0x18, 0x83, 0xB4, 0xC9, 0xD9, 0x73, + 0xA8, 0xE6, 0xA9, 0x36, 0xD5, 0x63, 0x1E, 0x2C, + 0x2A, 0x55, 0x09, 0x77, 0x5E, 0xB3, 0x4B, 0xEA, + 0xB5, 0xD0, 0x14, 0x5F, 0xEB, 0x50, 0x7B, 0xAA, + 0xEF, 0x94, 0xBA, 0x2B, 0xD7, 0x8A, 0x07, 0xF1, + 0xF9, 0x5E, 0x12, 0x12, 0x21, 0x52, 0xE5, 0x0A, + 0x3E, 0xC0, 0xBC, 0x5D, 0x4C, 0xE2, 0x12, 0x7C, + 0x39, 0xF9, 0x16, 0x9D, 0xBD, 0x96, 0x83, 0x3B, + 0x7F, 0x3D, 0x6A, 0xEC, 0xF1, 0x25, 0xD2, 0xB0, + 0xB0, 0xEB, 0x20, 0x06, 0x07, 0xD6, 0xD9, 0x4C, + 0x07, 0x9A, 0x82, 0xC1, 0xFC, 0xF7, 0x66, 0x15, + 0xBD, 0x62, 0x65, 0xD8, 0x6C, 0xF6, 0x33, 0x7B, + 0x5A, 0x28, 0xEC, 0x90, 0xA1, 0x26, 0x9F, 0xC3, + 0x28, 0x4A, 0x64, 0x50, 0x5F, 0xCA, 0xE2, 0x6D, + 0xB8, 0x0F, 0xE2, 0x94, 0xB5, 0x8E, 0x1F, 0x8A, + 0x8F, 0x6B, 0xA6, 0x86, 0x1F, 0xEE, 0xDC, 0x24, + 0xB4, 0xB8, 0x25, 0xEC, 0x28, 0x2D, 0xF9, 0xCB, + 0x7D, 0x38, 0xFF, 0xC7, 0x74, 0x2E, 0xD3, 0x10, + 0xEC, 0x03, 0x31, 0xEE, 0x83, 0xE7, 0xA4, 0xF7, + 0xBA, 0x28, 0x21, 0xE0, 0x7F, 0xB4, 0xB7, 0xE1, + 0x7A, 0xF9, 0x2B, 0xB0, 0x2C, 0x3B, 0x80, 0x5F, + 0xE0, 0x5D, 0xB2, 0x7E, 0x59, 0xFF, 0x59, 0x07, + 0x58, 0x42, 0x57, 0xEE, 0x44, 0xF1, 0xB1, 0xAD, + 0xBA, 0xDE, 0xCB, 0x1D, 0x8A, 0x36, 0x67, 0xE8, + 0x45, 0xFF, 0x07, 0x8D, 0xEE, 0xA4, 0x51, 0x9C, + 0x4C, 0x83, 0x5D, 0x2E, 0x2F, 0xE1, 0x5B, 0x75, + 0xE8, 0x29, 0xCD, 0x0B, 0x07, 0x62, 0xE0, 0xC3, + 0x0D, 0x1D, 0xEA, 0xCF, 0xF0, 0x8A, 0x65, 0x27, + 0x70, 0x42, 0x9F, 0x26, 0x00, 0x15, 0x70, 0xC5, + 0x4A, 0xF6, 0x25, 0xD0, 0x40, 0x72, 0xE9, 0xC1, + 0x73, 0xFD, 0x48, 0x94, 0xA3, 0x8D, 0x66, 0x63, + 0x96, 0x4F, 0xF7, 0xEE, 0xFB, 0x4C, 0xC7, 0xB8, + 0x6B, 0xE9, 0x90, 0xE1, 0x2A, 0x66, 0x80, 0x99, + 0x3B, 0xB0, 0x1A, 0x6C, 0xF9, 0x0E, 0x72, 0xDA, + 0x8E, 0x4F, 0x46, 0xC2, 0x6A, 0x4B, 0x7A, 0x16, + 0xE5, 0x26, 0x0B, 0x5C, 0xD4, 0x47, 0x34, 0xE5, + 0x37, 0xBE, 0x68, 0x6C, 0xDA, 0xD3, 0x9B, 0x6F, + 0xAE, 0x51, 0x9C, 0x99, 0x0A, 0x5B, 0xF8, 0x37, + 0xBC, 0xDE, 0xFC, 0x93, 0xC5, 0xE7, 0x0F, 0xEF, + 0x0B, 0xA6, 0x07, 0xC2, 0xA6, 0xE6, 0xDA, 0x2D, + 0x1B, 0x49, 0xC9, 0xDE, 0x6B, 0x27, 0xDC, 0x00, + 0xEF, 0x23, 0x87, 0x0E, 0xEB, 0xD1, 0x48, 0x7D, + 0xB4, 0xF2, 0x58, 0xC6, 0x3C, 0xE2, 0x89, 0xBA, + 0xB0, 0x05, 0xAC, 0x94, 0x41, 0x9A, 0xA8, 0xFF, + 0x3E, 0xBC, 0x3A, 0x52, 0x9C, 0xF9, 0x7F, 0x07, + 0x8B, 0xB0, 0x2C, 0x71, 0x83, 0x7B, 0xCF, 0x2E, + 0x7F, 0x7C, 0x96, 0x65, 0xD9, 0x08, 0x17, 0xEC, + 0xFA, 0xDE, 0x4E, 0x40, 0x12, 0x26, 0x70, 0x71, + 0x65, 0xA5, 0xDC, 0x98, 0x47, 0xA3, 0xFC, 0xE0, + 0x9A, 0x16, 0xED, 0x45, 0x56, 0x72, 0x50, 0x05, + 0x28, 0x2C, 0x99, 0xEC, 0x20, 0x2E, 0x40, 0xC0, + 0x26, 0x69, 0xCD, 0x49, 0x45, 0x17, 0xA4, 0xA3, + 0x42, 0x0D, 0x14, 0x65, 0x87, 0x33, 0x8C, 0x92, + 0xC5, 0xC4, 0x61, 0xFD, 0xE8, 0x68, 0x56, 0x20, + 0x57, 0xF5, 0x8E, 0x5F, 0xCF, 0x7E, 0x97, 0xF6, + 0x49, 0x97, 0x0A, 0xFE, 0xD3, 0x60, 0x1A, 0x5B, + 0x0C, 0x75, 0xDD, 0x8E, 0x31, 0x78, 0x29, 0xA6, + 0xB1, 0x4D, 0xAA, 0xDF, 0x8A, 0xD1, 0xE6, 0x91, + 0xE3, 0x32, 0x3F, 0xEC, 0x8A, 0x1F, 0x0E, 0x35, + 0x07, 0x6E, 0x4B, 0x83, 0x3B, 0xE5, 0x67, 0x34, + 0x1F, 0x0C, 0x81, 0xD8, 0xD5, 0x25, 0x68, 0xE5, + 0x28, 0x1B, 0x5C, 0x81, 0x3E, 0xE3, 0x5C, 0xB4, + 0xB6, 0xBD, 0x62, 0x6A, 0x70, 0x33, 0xC2, 0xC5, + 0x75, 0x27, 0xF4, 0x30, 0xE1, 0x1D, 0xC1, 0x4C, + 0xC5, 0x02, 0x12, 0x46, 0xAC, 0xEC, 0xF9, 0xE8, + 0xE7, 0x58, 0x24, 0x11, 0xB1, 0xF3, 0xB7, 0x8C, + 0x3C, 0xA4, 0x0A, 0x94, 0xA6, 0x7C, 0x68, 0x54, + 0x5B, 0xB9, 0x4D, 0x57, 0x9C, 0xE7, 0x28, 0x09, + 0x6B, 0x89, 0x26, 0x5D, 0xE7, 0x50, 0xA9, 0x95, + 0x90, 0x91, 0x8E, 0x00, 0x59, 0xF8, 0x3A, 0x70, + 0xAF, 0x48, 0x2E, 0xE8, 0xC4, 0x34, 0x8C, 0xF4, + 0x5F, 0x7F, 0xCB, 0x07, 0xAA, 0xF0, 0xD9, 0xFB, + 0x5C, 0x32, 0x90, 0x22, 0x1A, 0xD2, 0x1A, 0xCF, + 0x92, 0x06, 0x02, 0xCF, 0x10, 0x18, 0x7B, 0x93, + 0xCC, 0x07, 0x4A, 0x31, 0x25, 0x30, 0x23, 0x06, + 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, + 0x09, 0x15, 0x31, 0x16, 0x04, 0x14, 0xD1, 0xDE, + 0x23, 0x16, 0x9F, 0x6E, 0xF4, 0x42, 0x21, 0x23, + 0xE1, 0x11, 0xAA, 0xC8, 0x7C, 0x60, 0x4A, 0x78, + 0x9D, 0x24, 0x30, 0x31, 0x30, 0x21, 0x30, 0x09, + 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x05, + 0x00, 0x04, 0x14, 0xD6, 0x4A, 0xBB, 0x75, 0xB1, + 0xF9, 0x9E, 0xD3, 0x58, 0x6D, 0xD1, 0x74, 0x9F, + 0x00, 0x8A, 0xF2, 0xC8, 0xAA, 0x52, 0x4D, 0x04, + 0x08, 0x77, 0x46, 0xE7, 0xBA, 0x25, 0x4B, 0xDA, + 0x41, 0x02, 0x02, 0x08, 0x00] +}; + +const WPA_EAP_CLIENT_LIST = [ + { + ssid: 'WPA-EAP-TLS', + keyManagement: 'WPA-EAP', + eap: 'TLS', + identity: EAP_USERNAME, + serverCertificate: CLIENT_PKCS12_CERT.nickname, + userCertificate: CLIENT_PKCS12_CERT.nickname + } +]; + +/** + * Convert the given MozWifiNetwork object array to testAssociate chain. + * + * @param aNetworks + * An array of MozWifiNetwork which we want to convert. + * + * @return A promise chain which "then"s testAssociate accordingly. + */ +function convertToTestAssociateChain(aNetworks) { + let chain = Promise.resolve(); + + aNetworks.forEach(function (aNetwork) { + network = new window.MozWifiNetwork(aNetwork); + chain = chain.then(() => gTestSuite.testAssociate(network)); + }); + + return chain; +} + +gTestSuite.doTestWithCertificate( + new Blob([new Uint8Array(CLIENT_PKCS12_CERT.content)]), + CLIENT_PKCS12_CERT.password, + CLIENT_PKCS12_CERT.nickname, + CLIENT_PKCS12_CERT.usage, + function() { + return gTestSuite.ensureWifiEnabled(true) + // Load required server files. + .then(() => gTestSuite.writeFile(SERVER_EAP_USER_CONF.path, SERVER_EAP_USER_CONF.content)) + .then(() => gTestSuite.writeFile(CA_CERT.path, CA_CERT.content)) + .then(() => gTestSuite.writeFile(SERVER_CERT.path, SERVER_CERT.content)) + .then(() => gTestSuite.writeFile(SERVER_KEY.path, SERVER_KEY.content)) + // Start AP. + .then(() => gTestSuite.startHostapds(WPA_EAP_AP_LIST)) + // Scan test. + .then(() => gTestSuite.testWifiScanWithRetry(SCAN_RETRY_CNT, WPA_EAP_AP_LIST)) + // Associate test. + .then(() => convertToTestAssociateChain(WPA_EAP_CLIENT_LIST)) + // Tear down. + .then(gTestSuite.killAllHostapd) +}); diff --git a/dom/wifi/test/marionette/test_wifi_associate_WPA_EAP_TTLS.js b/dom/wifi/test/marionette/test_wifi_associate_WPA_EAP_TTLS.js new file mode 100644 index 000000000..06e052909 --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_associate_WPA_EAP_TTLS.js @@ -0,0 +1,623 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +const SCAN_RETRY_CNT = 5; + +const EAP_USERNAME = 'username'; +const EAP_PASSWORD = 'password'; + +const SERVER_EAP_USER_CONF = { + path: HOSTAPD_CONFIG_PATH + 'hostapd.eap_user', + content: '* PEAP,TTLS,TLS\n' + + '"' + EAP_USERNAME + '" MSCHAPV2,TTLS-MSCHAPV2 "' + EAP_PASSWORD + '" [2]\n' +}; +const CA_CERT = { + path: HOSTAPD_CONFIG_PATH + 'ca.pem', + content: '-----BEGIN CERTIFICATE-----\n' + + 'MIIDsTCCApmgAwIBAgIJAKxTf+8X8qngMA0GCSqGSIb3DQEBCwUAMG4xCzAJBgNV\n' + + 'BAYTAlRXMRMwEQYDVQQIDApTb21lLVN0YXRlMREwDwYDVQQKDAhjaHVja2xlZTER\n' + + 'MA8GA1UEAwwIY2h1Y2tsZWUxJDAiBgkqhkiG9w0BCQEWFWNodWNrbGkwNzA2QGdt\n' + + 'YWlsLmNvbTAgFw0xNDEyMjQxMTI4NTBaGA8yMjg4MTAwNzExMjg1MFowbjELMAkG\n' + + 'A1UEBhMCVFcxEzARBgNVBAgMClNvbWUtU3RhdGUxETAPBgNVBAoMCGNodWNrbGVl\n' + + 'MREwDwYDVQQDDAhjaHVja2xlZTEkMCIGCSqGSIb3DQEJARYVY2h1Y2tsaTA3MDZA\n' + + 'Z21haWwuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAo3c2yFxY\n' + + 'o6gGg0I83jy00ME+MAfzCd+4ShL45ZLqysQP93jRBfPzU9ZuZ29ysVwgWIdqkZao\n' + + 'XTuV/NAW2GMGd8W1jQJ3J81fjb9wvhlny3rrACwvUn1N1S1BnM+BAAiDLGxEmvAQ\n' + + 'onp2aaa6HsHsYS8ONX+d2Qh4LEA4vupeSGAqJychCZv/l+aq/ErFZhFYB3CPUQEt\n' + + 'cClO24ucsIYP95lA0zhscnmAj06qplFD4Bv6IVrdDqujy1zNwCQwsJq/8OQdaTN/\n' + + 'h3y9pWvNKMBMM2niOUAjtuNpqsSK/lTS1WAT3PdtVECX9fYBi0Bg+HM92xs/6gt6\n' + + 'kh9jPV8keXHvSwIDAQABo1AwTjAdBgNVHQ4EFgQU7hBqhuG04xeCzrQ3ngx18ZJ3\n' + + 'lUswHwYDVR0jBBgwFoAU7hBqhuG04xeCzrQ3ngx18ZJ3lUswDAYDVR0TBAUwAwEB\n' + + '/zANBgkqhkiG9w0BAQsFAAOCAQEAFYX2iy680GAnBTttk0gyX6gk+8pYr3D22k/G\n' + + '6rvcjefzS7ELQPRKr6mfmwXq3mMf/4jiS2zI5zmXsestPYzHYxf2viQ6t7vr9XiJ\n' + + '3WfFjNw4ERlRisAvg0aqqTNNQq5v2VME4sdFZagy217f73C7azwCHl0bqOLH05rl\n' + + '8RubOxiHEj7ZybJqnRciK/bht4D+rZkwf4bBBmoloqH7xT0+rFQclpYXDGGjNUQB\n' + + 'LcHLF10xcr7g3ZVVu82fe6+d85gIGOIMR9+TKhdw6gO3CNcnDAj6gxksghgtcxmh\n' + + 'OzOggCn7nlIwImtsg2sZkpWB4lEi9hdv4lkNuyFjOL3bnuc+NA==\n' + + '-----END CERTIFICATE-----\n' +}; + +const SERVER_CERT = { + path: HOSTAPD_CONFIG_PATH + 'server.pem', + content: '-----BEGIN CERTIFICATE-----\n' + + 'MIID1DCCArygAwIBAgIBADANBgkqhkiG9w0BAQsFADBuMQswCQYDVQQGEwJUVzET\n' + + 'MBEGA1UECAwKU29tZS1TdGF0ZTERMA8GA1UECgwIY2h1Y2tsZWUxETAPBgNVBAMM\n' + + 'CGNodWNrbGVlMSQwIgYJKoZIhvcNAQkBFhVjaHVja2xpMDcwNkBnbWFpbC5jb20w\n' + + 'IBcNMTQxMjI0MTEyOTQ5WhgPMjI4ODEwMDcxMTI5NDlaMG4xCzAJBgNVBAYTAlRX\n' + + 'MRMwEQYDVQQIDApTb21lLVN0YXRlMREwDwYDVQQKDAhjaHVja2xlZTERMA8GA1UE\n' + + 'AwwIY2h1Y2tsZWUxJDAiBgkqhkiG9w0BCQEWFWNodWNrbGkwNzA2QGdtYWlsLmNv\n' + + 'bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMdhQmKilTJbWZRxTiSV\n' + + 'rqIU+LYW1RKghx5o+0JpNRJVLuz5kBMaNskbbfUSNuHbEq0QA9BDKAZWIc4LSotk\n' + + 'lCo8TbcO9CJvJPQGGjGdHcohWX5vy6BE/OVE46CUteMFyZF6F8R2fNUww08iR/u1\n' + + 'YZebL5pWO1j43sPpAzEy6Tij2ACPt6EZcFaZG3SF2mVJWkCQnBqrojP65WUvZQqp\n' + + 'seUhW2YAS8Nu0Yrohgxz6VYk+cNDuDZVGs6qWRStZzJfYrfc76DtkHof5B14M+xp\n' + + 'XJaBLxN+whvnYkDTfinaCxnW1O7eXUltr87fLc5zmeBkgwaiaQuIdcfZm7vDUiz8\n' + + 'vnUCAwEAAaN7MHkwCQYDVR0TBAIwADAsBglghkgBhvhCAQ0EHxYdT3BlblNTTCBH\n' + + 'ZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFKK4f9/YavTHOfEiAB83Deac\n' + + '6gT5MB8GA1UdIwQYMBaAFO4QaobhtOMXgs60N54MdfGSd5VLMA0GCSqGSIb3DQEB\n' + + 'CwUAA4IBAQBWnO9o9KSJIqjoz5Nwll63ULOdcvgGdOeJIw1fcKQ817Rsp+TVcjcH\n' + + 'IrIADsT/QZGXRO/l6p1750e2iFtJEo1hsRaxtA1wWn2I9HO3+av2spQhr3jpYGPf\n' + + 'zpsMTp4RNYV7Q8+q1kZIz9PY4V1T0p6lveK8+fUj2hSLnxSj0QiGSJJtnEC3w4Rv\n' + + 'C9T6oUwIeToULmi+8FXQFdEqwKRU98DPq3eLzN28ZxUgoPE1C8+42D2UW8uyp/Gm\n' + + 'tGOa/k7nzkCdVqZI7lX7f0AjEvQgjtAMQ/k7Mhxx7TzW2HO+1YPMoKji6Z4WkNwt\n' + + 'JEj9ZUBSNt8B26UksJMBDkcvSegF3a7o\n' + + '-----END CERTIFICATE-----\n' +}; + +const SERVER_KEY = { + path: HOSTAPD_CONFIG_PATH + 'server.key', + content: '-----BEGIN RSA PRIVATE KEY-----\n' + + 'MIIEpAIBAAKCAQEAx2FCYqKVMltZlHFOJJWuohT4thbVEqCHHmj7Qmk1ElUu7PmQ\n' + + 'Exo2yRtt9RI24dsSrRAD0EMoBlYhzgtKi2SUKjxNtw70Im8k9AYaMZ0dyiFZfm/L\n' + + 'oET85UTjoJS14wXJkXoXxHZ81TDDTyJH+7Vhl5svmlY7WPjew+kDMTLpOKPYAI+3\n' + + 'oRlwVpkbdIXaZUlaQJCcGquiM/rlZS9lCqmx5SFbZgBLw27RiuiGDHPpViT5w0O4\n' + + 'NlUazqpZFK1nMl9it9zvoO2Qeh/kHXgz7GlcloEvE37CG+diQNN+KdoLGdbU7t5d\n' + + 'SW2vzt8tznOZ4GSDBqJpC4h1x9mbu8NSLPy+dQIDAQABAoIBAASG4Mr8hgaurEoC\n' + + 'iJOsElr7vunjetMBcg/uskW/vcS8ymP3Bp5oafYG+WgnEbfvEW18f5mq7K24JuxW\n' + + 'tUqU7ghHdjxByqk9fMlNmiqmNpbwSufkAeuRpWxPNBvhRH/zEbCL5R5A0nTEtqqF\n' + + 'TL0aUSzwCRSoAJD0lZo9ICVt0n3GsDyM9rqQg/uZmh1qsRdwPsRuYORND9g48rKq\n' + + '6WN9leskSxhhsYE2D9ocOFd9bNt8Zxejh9ppVSnG/KsIdt18iBzcabatgAQ046fb\n' + + 'Z3vprcZJLg93Sg2gSuVqlSTs3M2W8VQnm22/EBMb1y0M48MSRCgnbPLG/CcCLLfF\n' + + 'LwxCOgECgYEA/eYt67xyJ6JeAdxdwOZuT1WWGbFpLiG9+2OgiHumyRQ5969XMTWo\n' + + 'fIhMKchDdjoy9RR236\/\/EFCs7UEyB7+a7ODRzNiK2zCD8Smjp+21fUPSthEeQesk\n' + + 'eiMYICIu5Ay35x9sxIX+XOUVvRhPOGcD29GVeRnKh1inTHOz2dje8LkCgYEAyQeY\n' + + 'STi9jjCEcHkM1E/UeDiLfHHepLXi8wS41JNRHl5Jacp7XB5djAjKu/jf367/VpFy\n' + + 'GDDMetE7n8eWkrnAvovxOwZ000YDMtL1sUYSjL+XtBS5s6VY1p4qaSAY9nUUGrJh\n' + + 'JvtvsuI7SKTtL+60vjBOH7zDnvOdBgAp0utLhZ0CgYEAuLzzqrPKB8afShFSchn4\n' + + 'J2dpuLYahsNsXW7HDqeR2nsKFosRETAusLXnXPtnAq4kB6jlOarwFqnsuRCX24Vx\n' + + 'r2uBm9/vYL7zMdUPTA+s30ErHuhjsKjsOKYyVqcooSwT32pBFNk+E89nutfmRG7I\n' + + 'IvhjHuNCNqqtx/Xj5d1jkZkCgYBQicppC2Jl5OoqZVTOem0U/RJk+PnJ41TZJ7sk\n' + + '7yBAmmWvDH\/\/l+rCf4M5a6vFYcbKV9rt9h711X2dtciNX/3oWQh8LUoAmrwNUJc+\n' + + 'PmSQHvIYI3WCk2vUD+nN1B4sHxu+1lg11eYaNKiroeeknG2tBI1ICcgVlmQCU25u\n' + + 'IfZPwQKBgQCdO6QHhPLtcHUDNFA6FQ1jKL1iEd7G0JLVRz4Xkpkn1Vrr5MD6JFDa\n' + + '5ccabADyl0lpFqDIVJQIzLku2hOD2i9aBNCY0pL391HeOS7CkZX+TdOY1tquoBq5\n' + + 'MnmixZjDCVd2VcrVyTA6ntOBoharKFW0rH1PqU+qu7dZF7CBPbAdEw==\n' + + '-----END RSA PRIVATE KEY-----\n' +}; + +const WPA_EAP_AP_LIST = [ + { + ssid: 'WPA-EAP-TTLS', + ieee8021x: 1, + eapol_version: 1, + eap_server: 1, + eapol_key_index_workaround: 0, + eap_user_file: SERVER_EAP_USER_CONF.path, + ca_cert: CA_CERT.path, + server_cert: SERVER_CERT.path, + private_key: SERVER_KEY.path, + wpa: 3, + wpa_key_mgmt: 'WPA-EAP' + } +]; + +const CLIENT_PKCS12_CERT = { + nickname: 'client', + password: 'password', + usage: ['UserCert', 'ServerCert'], + content: [0x30, 0x82, 0x0E, 0x01, 0x02, 0x01, 0x03, 0x30, + 0x82, 0x0D, 0xC7, 0x06, 0x09, 0x2A, 0x86, 0x48, + 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01, 0xA0, 0x82, + 0x0D, 0xB8, 0x04, 0x82, 0x0D, 0xB4, 0x30, 0x82, + 0x0D, 0xB0, 0x30, 0x82, 0x08, 0x67, 0x06, 0x09, + 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, + 0x06, 0xA0, 0x82, 0x08, 0x58, 0x30, 0x82, 0x08, + 0x54, 0x02, 0x01, 0x00, 0x30, 0x82, 0x08, 0x4D, + 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, + 0x01, 0x07, 0x01, 0x30, 0x1C, 0x06, 0x0A, 0x2A, + 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, + 0x06, 0x30, 0x0E, 0x04, 0x08, 0x67, 0x7A, 0xF3, + 0x61, 0xBE, 0xE0, 0x51, 0xC1, 0x02, 0x02, 0x08, + 0x00, 0x80, 0x82, 0x08, 0x20, 0xFC, 0x6A, 0x79, + 0xA1, 0x6C, 0xAF, 0xBE, 0xEE, 0x62, 0x45, 0x33, + 0xB8, 0x48, 0xE1, 0x68, 0xA1, 0x15, 0x11, 0x4B, + 0x95, 0xCB, 0x77, 0xC0, 0x5D, 0xA2, 0xCB, 0xDB, + 0xD1, 0x83, 0x74, 0x60, 0xD7, 0xEC, 0x42, 0xA6, + 0x3A, 0x23, 0xF7, 0x85, 0xEB, 0xC1, 0xFE, 0x6A, + 0x57, 0x8E, 0xC1, 0x44, 0xF3, 0x1F, 0xFE, 0xB8, + 0x2D, 0x8C, 0x4D, 0xC9, 0x5B, 0xAE, 0x21, 0x2E, + 0x4C, 0x1A, 0xEB, 0x84, 0x09, 0xF3, 0x40, 0x92, + 0x39, 0x7F, 0x56, 0x02, 0x46, 0x61, 0x16, 0xDE, + 0x5C, 0x48, 0xB6, 0x0C, 0x1D, 0xD3, 0x5F, 0x10, + 0x9A, 0x39, 0xB8, 0x66, 0x31, 0xFC, 0x39, 0x71, + 0x87, 0x23, 0x46, 0x9D, 0xE8, 0x3C, 0x2B, 0xA1, + 0x39, 0x8A, 0xD3, 0xFF, 0xD9, 0x43, 0xB6, 0x61, + 0xC6, 0x67, 0x70, 0x40, 0xBD, 0xFE, 0xD3, 0xC1, + 0x68, 0xF5, 0xF7, 0xC8, 0x89, 0xD8, 0x17, 0xC5, + 0xE8, 0x3D, 0x29, 0xD5, 0x91, 0xDF, 0x1F, 0x56, + 0x74, 0x5A, 0xC4, 0xA8, 0x14, 0xBA, 0xD4, 0xFA, + 0x13, 0x49, 0x2A, 0x9F, 0x63, 0xF1, 0xB2, 0x45, + 0xF1, 0xF0, 0x2A, 0xDD, 0x75, 0x66, 0x8A, 0xF7, + 0xAB, 0x73, 0x86, 0x26, 0x9D, 0x1F, 0x07, 0xAD, + 0xD3, 0xFE, 0xE0, 0xA3, 0xED, 0xA0, 0x96, 0x3E, + 0x1E, 0x89, 0x86, 0x02, 0x4C, 0x28, 0xFD, 0x57, + 0xA1, 0x67, 0x55, 0xF0, 0x82, 0x3B, 0x7F, 0xCC, + 0x2A, 0x32, 0x01, 0x93, 0x1D, 0x8B, 0x66, 0x8A, + 0x20, 0x52, 0x84, 0xDD, 0x2C, 0xFD, 0xEE, 0x72, + 0xF3, 0x8C, 0x58, 0xB9, 0x99, 0xE5, 0xC1, 0x22, + 0x63, 0x59, 0x00, 0xE2, 0x76, 0xC5, 0x3A, 0x17, + 0x7F, 0x93, 0xE9, 0x67, 0x61, 0xAA, 0x10, 0xC3, + 0xD9, 0xC8, 0x24, 0x46, 0x5B, 0xBE, 0x8C, 0x1F, + 0x2D, 0x66, 0x48, 0xD2, 0x02, 0x11, 0xFB, 0x74, + 0x14, 0x76, 0x76, 0x5A, 0x98, 0x54, 0x35, 0xA7, + 0x85, 0x66, 0x20, 0x26, 0x8B, 0x13, 0x6F, 0x68, + 0xE3, 0xC9, 0x58, 0x7D, 0x1C, 0x3E, 0x01, 0x8D, + 0xF8, 0xD6, 0x7F, 0xCF, 0xA2, 0x07, 0xB7, 0x95, + 0xFD, 0xF0, 0x02, 0x34, 0x32, 0x30, 0xE8, 0xD4, + 0x57, 0x5E, 0x53, 0xFB, 0x54, 0xE2, 0x03, 0x32, + 0xCC, 0x52, 0x2E, 0xD2, 0x35, 0xD9, 0x58, 0x85, + 0x2D, 0xEC, 0x2D, 0x71, 0xD1, 0x8A, 0x29, 0xD0, + 0xB0, 0x24, 0xBD, 0x24, 0xDC, 0x1A, 0x28, 0x3F, + 0xA0, 0x12, 0x81, 0x15, 0x24, 0xC9, 0xB5, 0x4A, + 0x23, 0xB6, 0xA3, 0x45, 0x50, 0x2D, 0x73, 0x99, + 0x6B, 0x1C, 0xFB, 0xA4, 0x53, 0xD7, 0x5C, 0xF4, + 0x6C, 0xB0, 0xE5, 0x74, 0xB3, 0x76, 0xF8, 0xB1, + 0x0D, 0x59, 0x70, 0x9F, 0xCA, 0xDE, 0xF2, 0xAA, + 0x4C, 0x7D, 0x11, 0x54, 0xC4, 0x19, 0x0F, 0x36, + 0x4A, 0x62, 0xFF, 0x8B, 0x10, 0xCB, 0x93, 0x50, + 0xDA, 0x79, 0x5E, 0x4E, 0x09, 0x1F, 0x22, 0xC8, + 0x19, 0x85, 0xE9, 0xEE, 0xB7, 0x71, 0x65, 0xB9, + 0x10, 0xD2, 0x0A, 0x73, 0x5B, 0xA6, 0xDA, 0x37, + 0x46, 0x02, 0x00, 0x98, 0x9E, 0x20, 0x6C, 0x7D, + 0xC7, 0x69, 0xBB, 0xC2, 0x00, 0x40, 0x9C, 0x57, + 0x00, 0xC2, 0x36, 0x76, 0xE8, 0x2A, 0x8D, 0xAD, + 0x62, 0x57, 0xC8, 0xD0, 0x9D, 0x66, 0x27, 0x5A, + 0xD8, 0x0D, 0x35, 0x60, 0x28, 0x38, 0x62, 0x94, + 0x78, 0x36, 0x25, 0x58, 0xFD, 0xF8, 0x66, 0x1F, + 0x68, 0x04, 0x0F, 0xD8, 0x00, 0xDF, 0xA0, 0x6C, + 0x25, 0x42, 0x9A, 0x4C, 0xEB, 0x80, 0x13, 0x51, + 0x7D, 0x2D, 0xA8, 0x89, 0xD6, 0x1B, 0x67, 0x72, + 0x01, 0xF3, 0x2D, 0x16, 0x77, 0xFE, 0x22, 0xBC, + 0x8A, 0x45, 0x09, 0x1F, 0x9C, 0x2F, 0x2A, 0xA9, + 0x61, 0x5B, 0x4A, 0xE6, 0x64, 0x2C, 0x62, 0x1A, + 0x3A, 0x96, 0xE6, 0x0A, 0xAE, 0x05, 0x1A, 0xC8, + 0xCB, 0xD6, 0x8F, 0x3A, 0x4B, 0xE0, 0x7F, 0x82, + 0xB4, 0x98, 0xF1, 0x9D, 0xD7, 0x14, 0x76, 0x5E, + 0x77, 0x85, 0x87, 0xEC, 0x13, 0xDA, 0xFD, 0xAF, + 0xCB, 0xA3, 0x1C, 0x99, 0xC1, 0xFE, 0x17, 0x0C, + 0x40, 0x4D, 0x3C, 0x8F, 0x70, 0x86, 0x63, 0x64, + 0xB7, 0x75, 0xA8, 0x71, 0x36, 0xDC, 0x54, 0x10, + 0x57, 0x0C, 0xA8, 0xF2, 0xA1, 0xBB, 0xED, 0x03, + 0x41, 0x57, 0x34, 0x2C, 0x8F, 0x7C, 0xA0, 0x09, + 0xF3, 0x9E, 0x41, 0xB7, 0xA8, 0xD4, 0x66, 0x0D, + 0x0D, 0xC0, 0x6A, 0xFC, 0x6A, 0xA2, 0xAC, 0xE2, + 0x60, 0x00, 0xE3, 0xF7, 0x75, 0x43, 0x23, 0xEB, + 0xC8, 0x61, 0xFA, 0xB3, 0xB8, 0x28, 0xCE, 0xCA, + 0xF4, 0x47, 0x7F, 0x30, 0x6D, 0x61, 0x89, 0x47, + 0xA1, 0x4A, 0xFE, 0xD1, 0x21, 0x0B, 0x6D, 0xF4, + 0x3F, 0x00, 0x86, 0x30, 0x8E, 0x33, 0x21, 0x6F, + 0xDA, 0x15, 0xFD, 0x5F, 0xEC, 0x8E, 0xF1, 0x12, + 0x3F, 0xC9, 0x83, 0x0C, 0xCA, 0x22, 0x01, 0xF1, + 0x70, 0x5F, 0x1F, 0x66, 0xB5, 0xF8, 0x3E, 0x7A, + 0x6F, 0xDE, 0xDB, 0xA7, 0x8D, 0x18, 0x9E, 0xBE, + 0xDB, 0xAD, 0x3D, 0x66, 0x30, 0xC1, 0x6C, 0x0C, + 0x87, 0xB4, 0x65, 0x75, 0xE0, 0x9D, 0xEA, 0x16, + 0x0D, 0x07, 0x37, 0x33, 0xC5, 0xEC, 0x97, 0x93, + 0x37, 0xEB, 0x8E, 0x65, 0x9C, 0x40, 0x63, 0x6C, + 0x43, 0x60, 0xB0, 0x40, 0x4D, 0x85, 0xEF, 0xC2, + 0x47, 0x5F, 0xE7, 0x6B, 0xCB, 0x40, 0xE8, 0xEA, + 0xD8, 0xAB, 0xB1, 0x9A, 0x72, 0xDC, 0x4C, 0x14, + 0xFA, 0x43, 0x61, 0x5F, 0xA6, 0x5C, 0x3A, 0x05, + 0x17, 0x2E, 0x74, 0xF3, 0x5E, 0x45, 0xD9, 0x47, + 0xAA, 0x59, 0xB6, 0x8F, 0x42, 0x66, 0x42, 0x29, + 0x90, 0x95, 0x48, 0x46, 0x91, 0x88, 0x3C, 0x8C, + 0xDE, 0xCC, 0xED, 0xB3, 0xAA, 0x62, 0xEA, 0xBC, + 0xB4, 0x0C, 0x48, 0x4C, 0x53, 0x23, 0x5E, 0x24, + 0x85, 0xBF, 0x92, 0xDA, 0x14, 0xDB, 0x1A, 0x3D, + 0xEF, 0x30, 0xD9, 0x49, 0x64, 0x4D, 0xE5, 0x01, + 0xFC, 0xA4, 0x4B, 0xD1, 0x9F, 0xDE, 0x96, 0x7F, + 0x50, 0xBC, 0x4D, 0x38, 0x44, 0xE9, 0x23, 0x5F, + 0x37, 0x57, 0x1A, 0xA6, 0x52, 0x5A, 0x0F, 0x4F, + 0x87, 0x33, 0x4A, 0x7B, 0x66, 0xEE, 0x3D, 0x66, + 0x0A, 0x63, 0x39, 0x1F, 0x23, 0x38, 0x35, 0x73, + 0x60, 0x5E, 0x47, 0x20, 0x4F, 0xC0, 0xC8, 0x3C, + 0x09, 0xF9, 0x29, 0x4F, 0x5E, 0x55, 0x69, 0xC4, + 0x6B, 0xE8, 0xF8, 0x91, 0xC0, 0x22, 0x65, 0x15, + 0x1E, 0xFB, 0xB9, 0x61, 0xCE, 0x45, 0xBE, 0x2B, + 0xEE, 0xB9, 0x04, 0x2B, 0xFD, 0xAE, 0x61, 0x1C, + 0x3D, 0x3D, 0x7C, 0xBF, 0xC1, 0xF7, 0x3C, 0x4E, + 0x9E, 0x0E, 0x54, 0xC8, 0xAD, 0xA9, 0xDF, 0x43, + 0x49, 0xB9, 0x41, 0x05, 0xE5, 0xF1, 0x49, 0xAA, + 0x77, 0x6C, 0x34, 0x5B, 0x93, 0x24, 0x24, 0x23, + 0x74, 0x68, 0x11, 0xCE, 0x15, 0x80, 0xA1, 0xA4, + 0x1F, 0x8D, 0x81, 0xCD, 0xB2, 0x98, 0xCA, 0x14, + 0x0B, 0x0C, 0x61, 0x50, 0x69, 0x72, 0xAE, 0xFA, + 0x8B, 0xC0, 0x3F, 0x0D, 0xE7, 0xF2, 0x0F, 0xEB, + 0xC1, 0x11, 0xB9, 0x10, 0x03, 0x6A, 0xF5, 0x97, + 0x3C, 0x53, 0x2F, 0x67, 0x86, 0x09, 0x6A, 0xE3, + 0x28, 0xC0, 0x78, 0xC8, 0xB4, 0x39, 0x8E, 0xD1, + 0xCE, 0x25, 0xE8, 0x66, 0xF7, 0x09, 0x40, 0x7D, + 0x81, 0xFB, 0xAF, 0xFA, 0x59, 0xC4, 0x9B, 0x2B, + 0x83, 0x45, 0x5B, 0xA8, 0x66, 0x9E, 0x38, 0xC8, + 0xFD, 0xAC, 0xF2, 0x2D, 0x21, 0xDE, 0x50, 0x4C, + 0x03, 0xCB, 0x88, 0x42, 0xDD, 0x84, 0x09, 0x99, + 0x8E, 0x8B, 0x40, 0x97, 0x1B, 0x14, 0x85, 0x37, + 0x11, 0x01, 0xE0, 0x74, 0x6B, 0x33, 0x52, 0x8C, + 0x68, 0x3A, 0x89, 0xB2, 0xAF, 0x35, 0xE6, 0x65, + 0xC3, 0x58, 0x70, 0xD2, 0xE7, 0x1F, 0x1F, 0xF6, + 0xE5, 0x0A, 0xB1, 0xFE, 0xD0, 0xC9, 0x51, 0x50, + 0xE7, 0xFD, 0x58, 0xF5, 0xC4, 0x58, 0x65, 0x94, + 0xD1, 0x57, 0x55, 0x5E, 0xD2, 0x27, 0x98, 0xAF, + 0xE7, 0x55, 0x0B, 0x87, 0x50, 0x9B, 0xEF, 0xE8, + 0x2B, 0xFC, 0xE7, 0x3B, 0x4E, 0xD7, 0xB7, 0x4D, + 0xF4, 0xBC, 0xF4, 0x88, 0x63, 0xE4, 0x8A, 0x20, + 0x4B, 0x22, 0xB0, 0xA0, 0x53, 0x7F, 0xA8, 0xC9, + 0x0C, 0xF8, 0xD7, 0xBD, 0x46, 0x39, 0xA7, 0x7D, + 0xDD, 0x10, 0x91, 0x50, 0x54, 0x06, 0x47, 0xF0, + 0x3C, 0xAA, 0x43, 0x40, 0xF8, 0x54, 0xDD, 0x8A, + 0xEA, 0x8A, 0x0B, 0xA5, 0x7F, 0xCD, 0x5E, 0xAA, + 0x02, 0x2E, 0x1F, 0xC6, 0x50, 0x15, 0xF8, 0x0A, + 0x0C, 0x1B, 0x3C, 0x55, 0x3A, 0xC3, 0x6F, 0x88, + 0xD7, 0xBF, 0xB1, 0x02, 0xCC, 0xE0, 0x08, 0x29, + 0x97, 0xD2, 0xAA, 0x23, 0xC4, 0x6D, 0xE3, 0xE3, + 0x76, 0x39, 0x92, 0xC3, 0x2E, 0x7A, 0xE2, 0x98, + 0xD1, 0xFC, 0xAE, 0xCC, 0x95, 0xD8, 0xB4, 0xDC, + 0x92, 0xEA, 0x6A, 0x5F, 0xF2, 0x92, 0x17, 0x0B, + 0x8D, 0xC3, 0xFA, 0x9C, 0x62, 0xCE, 0x44, 0x8D, + 0xC3, 0x1E, 0xC3, 0xB2, 0xD5, 0x00, 0xCD, 0xB4, + 0x9E, 0x2D, 0x7B, 0xF2, 0x98, 0xA3, 0x00, 0x8B, + 0x81, 0x30, 0x77, 0x5B, 0x02, 0x99, 0xB1, 0xCD, + 0xC3, 0x1D, 0x74, 0x74, 0xEF, 0x41, 0xCB, 0x69, + 0x63, 0x8E, 0xA6, 0xD3, 0x2D, 0x3E, 0x1F, 0x1D, + 0x12, 0x9E, 0xD9, 0x18, 0x67, 0x06, 0xAF, 0x37, + 0x29, 0xAD, 0x65, 0xD8, 0xEB, 0x71, 0xC4, 0x7D, + 0x94, 0x3D, 0xEA, 0xCC, 0xDF, 0x72, 0x41, 0x51, + 0x3C, 0xA1, 0x66, 0x98, 0x32, 0x32, 0x40, 0x54, + 0xB0, 0x2F, 0xEB, 0xCE, 0xDF, 0x4A, 0x64, 0xFB, + 0x9A, 0x90, 0xDC, 0xF6, 0x6F, 0xA9, 0xD4, 0xCA, + 0xCB, 0x91, 0xC4, 0xFE, 0xEE, 0x9C, 0x01, 0x50, + 0x2E, 0xAC, 0xCC, 0x5F, 0x89, 0xD0, 0x91, 0xA3, + 0xD9, 0xF9, 0x4B, 0x8D, 0xDE, 0x6C, 0x60, 0x21, + 0x19, 0xB1, 0xD3, 0x4D, 0x75, 0x56, 0x6F, 0xB8, + 0x25, 0xA4, 0x92, 0x4F, 0x12, 0xF5, 0x8F, 0xC1, + 0x17, 0x4B, 0xB3, 0x34, 0x21, 0x22, 0xAC, 0x52, + 0xD2, 0x64, 0xC9, 0x9A, 0x7D, 0xFC, 0xC0, 0x0A, + 0x89, 0x34, 0xFF, 0x08, 0xD3, 0x04, 0xDC, 0xFE, + 0x7C, 0xB3, 0xB8, 0xFD, 0x85, 0xDD, 0x79, 0x51, + 0xA7, 0x89, 0xE8, 0xF1, 0x23, 0xB1, 0xDF, 0xD7, + 0x1F, 0x7B, 0xB1, 0x5D, 0x42, 0xF9, 0x61, 0xF8, + 0xDC, 0x81, 0x04, 0xF1, 0xCC, 0xFA, 0xD7, 0xED, + 0xBF, 0x47, 0xAC, 0xBD, 0xE5, 0xFA, 0xAC, 0xB3, + 0x1C, 0xD9, 0xA1, 0xB3, 0x60, 0xEE, 0x9C, 0x8A, + 0x36, 0x57, 0xB4, 0x2F, 0xA1, 0xA2, 0xF3, 0xE2, + 0x09, 0x9A, 0x6E, 0x43, 0x9B, 0xE5, 0x93, 0xB8, + 0x3D, 0x9E, 0x9F, 0xC1, 0xC6, 0x0D, 0x02, 0xEB, + 0x4D, 0x38, 0xE9, 0xB4, 0x9F, 0xEA, 0x33, 0x8C, + 0x07, 0xD8, 0xB4, 0x71, 0xAD, 0xE5, 0x43, 0xB2, + 0xCC, 0x55, 0x93, 0x6A, 0xDB, 0x1E, 0x80, 0xDB, + 0xC2, 0xEA, 0x42, 0x8E, 0xFC, 0x86, 0x44, 0xC9, + 0x8A, 0xC4, 0xF2, 0x46, 0xA7, 0x39, 0x50, 0x0D, + 0x1A, 0xAA, 0x07, 0x04, 0xBE, 0xD4, 0xCE, 0x62, + 0x4D, 0x0F, 0x91, 0x7D, 0x29, 0x88, 0x9C, 0x4C, + 0xAF, 0xF7, 0xD8, 0x40, 0x93, 0x88, 0xC7, 0x20, + 0xD2, 0x17, 0x2A, 0xC4, 0x92, 0x72, 0xD0, 0xC0, + 0x4E, 0x56, 0x47, 0xB1, 0x27, 0x02, 0xE6, 0x61, + 0x82, 0x5E, 0xC8, 0x2E, 0x90, 0xD2, 0x31, 0x22, + 0xE2, 0xA9, 0x4A, 0x91, 0x45, 0x69, 0xB1, 0xA5, + 0x0F, 0x66, 0x2C, 0x30, 0xAD, 0x7F, 0x1B, 0x0E, + 0x22, 0x17, 0x60, 0x2E, 0x3D, 0x7F, 0x7F, 0x8C, + 0x33, 0x51, 0xA0, 0x25, 0xDE, 0xFD, 0x75, 0xBC, + 0xEF, 0xE6, 0xE7, 0x20, 0x04, 0x5A, 0xEC, 0x50, + 0x21, 0x48, 0x56, 0x98, 0xE2, 0x33, 0x6D, 0x22, + 0x5C, 0xC3, 0xFB, 0xFC, 0x6F, 0xB3, 0xA7, 0x8E, + 0x6F, 0x67, 0x70, 0x9D, 0xDA, 0x02, 0x01, 0x59, + 0x7B, 0x3D, 0x2B, 0x38, 0xCC, 0x0F, 0x44, 0x3D, + 0xFB, 0x9A, 0xB3, 0x23, 0x15, 0x50, 0x6E, 0xBF, + 0x8B, 0xA1, 0x94, 0x33, 0xE5, 0x7B, 0x88, 0x4E, + 0xCB, 0x6D, 0x9F, 0xBF, 0xBC, 0x7A, 0xA8, 0x1E, + 0x68, 0x25, 0xED, 0x8E, 0x53, 0x21, 0x72, 0xC5, + 0x70, 0xB3, 0xE4, 0xA6, 0xA1, 0x5A, 0x2D, 0xC8, + 0x43, 0x9D, 0x60, 0x77, 0x78, 0xE0, 0xC4, 0xAF, + 0xC8, 0x29, 0xBA, 0xD0, 0x4D, 0x39, 0x83, 0x51, + 0xA7, 0x10, 0x7F, 0x0C, 0x34, 0x0E, 0x6C, 0x75, + 0x26, 0xD7, 0xD6, 0xC7, 0x32, 0x53, 0xAF, 0x4E, + 0xBE, 0xF2, 0xC2, 0x0F, 0x99, 0x23, 0xB9, 0xE1, + 0xC8, 0xB4, 0xBC, 0x5A, 0xC6, 0xCB, 0xEB, 0x4D, + 0x28, 0x56, 0x72, 0xFE, 0x1B, 0x2C, 0x5D, 0xE3, + 0xBC, 0xC7, 0xA3, 0xC0, 0x7D, 0x27, 0xF0, 0xD0, + 0x4F, 0x3F, 0x1F, 0xF7, 0x87, 0x15, 0xF2, 0xEA, + 0xD4, 0x03, 0x6D, 0x2F, 0xD4, 0x8E, 0x50, 0x4B, + 0x05, 0xBF, 0xF7, 0x8C, 0x67, 0x5A, 0xDC, 0x4D, + 0xCD, 0xCF, 0x9D, 0x02, 0xB6, 0xE7, 0xAE, 0x49, + 0xD1, 0x7C, 0x00, 0xE7, 0x3B, 0xEA, 0xFB, 0x0D, + 0x2A, 0x7B, 0x41, 0x33, 0x66, 0xD0, 0x29, 0x9F, + 0xB3, 0x8A, 0x71, 0xB0, 0xE2, 0x76, 0xA9, 0xDB, + 0xFD, 0x64, 0x04, 0x69, 0xDF, 0x89, 0x1F, 0x56, + 0x86, 0x92, 0xD9, 0xD9, 0xB9, 0xF3, 0x4F, 0xAC, + 0xAE, 0x61, 0x48, 0x20, 0xCE, 0x3C, 0x2B, 0x44, + 0xAB, 0x42, 0xFA, 0xAB, 0x2E, 0x94, 0x82, 0xC8, + 0xD9, 0x97, 0xCF, 0x27, 0xDF, 0xAC, 0xAC, 0xE7, + 0xCA, 0xB2, 0x84, 0xAB, 0xF2, 0x5D, 0xDF, 0x56, + 0x0C, 0x8C, 0x07, 0x3C, 0x3D, 0xA8, 0xDD, 0xBE, + 0xFF, 0x4E, 0x28, 0x0D, 0xB2, 0x2D, 0xE6, 0x9D, + 0x44, 0x21, 0xCB, 0xE7, 0x33, 0x63, 0x22, 0x8F, + 0x4C, 0xFF, 0xB6, 0x1D, 0x9A, 0x71, 0x3F, 0xB1, + 0x29, 0xAE, 0x3A, 0x35, 0xEE, 0x9C, 0x97, 0x68, + 0xA7, 0x52, 0x66, 0x01, 0xD8, 0x9A, 0x5D, 0xF4, + 0xB3, 0x2F, 0x5C, 0xD4, 0x0E, 0xF9, 0xCF, 0x07, + 0xF6, 0x8C, 0xBA, 0xA6, 0x8D, 0x6B, 0xC6, 0x01, + 0xC2, 0x69, 0xAE, 0x60, 0x08, 0x1A, 0x0E, 0x3F, + 0xAE, 0x60, 0x29, 0xF3, 0x48, 0x0D, 0xE0, 0xD0, + 0xAE, 0x52, 0x44, 0xE9, 0x7F, 0x1F, 0x92, 0x5F, + 0x71, 0xAD, 0xEC, 0x6B, 0x47, 0x66, 0x92, 0x22, + 0x27, 0xAE, 0x6E, 0x25, 0xCD, 0xF3, 0x5F, 0x55, + 0x59, 0xBD, 0x73, 0xCE, 0x2B, 0x7E, 0x99, 0x44, + 0x56, 0x70, 0xA3, 0xE7, 0x7A, 0x59, 0x75, 0xD8, + 0x48, 0x0C, 0x39, 0x2B, 0xD7, 0x53, 0xC6, 0xAD, + 0x4A, 0x6F, 0xB4, 0x14, 0x96, 0xDF, 0xF2, 0x4A, + 0x0C, 0xA2, 0xD5, 0x29, 0x98, 0x7C, 0x42, 0x87, + 0xD9, 0x1F, 0x97, 0x61, 0xD9, 0xBF, 0x99, 0x4F, + 0x2C, 0x4C, 0x75, 0xAC, 0xB8, 0x06, 0x75, 0xD6, + 0x87, 0x76, 0x7E, 0xE3, 0x23, 0x4B, 0xEA, 0x1A, + 0x1A, 0xF4, 0xB7, 0x09, 0xAF, 0x53, 0xEB, 0xA6, + 0x39, 0x10, 0xFE, 0xD4, 0xEB, 0x1B, 0xAE, 0x38, + 0x31, 0x33, 0xBA, 0x68, 0xEE, 0xC7, 0x65, 0x76, + 0xFB, 0x49, 0x77, 0xD4, 0x19, 0xC4, 0xE6, 0xA7, + 0x05, 0xFE, 0x2A, 0xDA, 0x39, 0x99, 0x1A, 0x92, + 0xD2, 0xF0, 0x61, 0x97, 0xF6, 0x06, 0x6C, 0x88, + 0x7B, 0x6F, 0x60, 0xE6, 0x70, 0x08, 0xF0, 0xB4, + 0x6B, 0x39, 0x6F, 0x05, 0x41, 0x81, 0xF9, 0xBE, + 0x7A, 0x51, 0xC4, 0x75, 0xB0, 0x6A, 0x89, 0xA0, + 0xA6, 0x9A, 0x5B, 0xEE, 0x7D, 0x78, 0x17, 0x5F, + 0x9F, 0x3B, 0x7D, 0xDD, 0x8A, 0x9E, 0xAA, 0x1A, + 0xDA, 0x49, 0x08, 0xE9, 0xFD, 0x91, 0xA6, 0xFA, + 0xCE, 0xCF, 0x67, 0xDF, 0x0F, 0xC9, 0xD6, 0x38, + 0xD9, 0xD5, 0xD1, 0xC0, 0x76, 0x59, 0x42, 0x53, + 0xBF, 0x48, 0xE9, 0x11, 0x74, 0xC7, 0x11, 0xD8, + 0xE7, 0x8E, 0xD3, 0xC8, 0x25, 0xA1, 0x26, 0x50, + 0xBB, 0xB4, 0x35, 0xAF, 0xAF, 0x06, 0x23, 0x69, + 0x3E, 0x30, 0xFD, 0x7B, 0x34, 0x83, 0x07, 0xD0, + 0xF0, 0x0F, 0x6C, 0x9A, 0x13, 0x5D, 0xC2, 0x7B, + 0xDF, 0x6F, 0xDD, 0x8E, 0xF4, 0x30, 0x82, 0x05, + 0x41, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, + 0x0D, 0x01, 0x07, 0x01, 0xA0, 0x82, 0x05, 0x32, + 0x04, 0x82, 0x05, 0x2E, 0x30, 0x82, 0x05, 0x2A, + 0x30, 0x82, 0x05, 0x26, 0x06, 0x0B, 0x2A, 0x86, + 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, + 0x02, 0xA0, 0x82, 0x04, 0xEE, 0x30, 0x82, 0x04, + 0xEA, 0x30, 0x1C, 0x06, 0x0A, 0x2A, 0x86, 0x48, + 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x03, 0x30, + 0x0E, 0x04, 0x08, 0x74, 0xC0, 0x84, 0x8F, 0xC7, + 0x74, 0x5E, 0x21, 0x02, 0x02, 0x08, 0x00, 0x04, + 0x82, 0x04, 0xC8, 0x1E, 0xF4, 0xE9, 0x07, 0x27, + 0x9E, 0x5A, 0xC9, 0x39, 0x1D, 0x37, 0x2C, 0x06, + 0x4B, 0x57, 0xEA, 0xC5, 0x42, 0x9A, 0x60, 0xD5, + 0x42, 0xB2, 0x34, 0x2D, 0xD3, 0x88, 0x7C, 0x78, + 0x87, 0xB6, 0xE9, 0x42, 0x44, 0x1F, 0x67, 0x32, + 0x92, 0x54, 0x22, 0xDA, 0xB2, 0x43, 0xE7, 0x40, + 0xBE, 0x1F, 0xAF, 0x3A, 0xCD, 0x2A, 0x9F, 0xD7, + 0x44, 0x5B, 0x37, 0x69, 0x85, 0xDF, 0xEB, 0x2A, + 0xB9, 0xE2, 0x92, 0x3B, 0xEA, 0xD5, 0x42, 0x53, + 0x95, 0x4A, 0xB0, 0x1B, 0xA5, 0xEF, 0xA6, 0x0D, + 0x29, 0xF4, 0x33, 0xFE, 0xD7, 0x49, 0x04, 0x1E, + 0x8C, 0xAD, 0x63, 0x1E, 0x79, 0x63, 0x74, 0x0C, + 0xE5, 0x5E, 0xA2, 0x2C, 0xBE, 0xB8, 0x90, 0xCE, + 0x06, 0x25, 0xBF, 0xD1, 0x5A, 0x50, 0xCF, 0x3B, + 0x52, 0xE2, 0xA7, 0xFF, 0x19, 0x02, 0xCF, 0xD0, + 0x9B, 0xD9, 0xF7, 0x28, 0x07, 0x38, 0x1F, 0xF2, + 0xAF, 0x44, 0x91, 0x3F, 0x0F, 0xB6, 0x6E, 0x8C, + 0xC0, 0x32, 0x92, 0xC0, 0xCD, 0x25, 0x98, 0x67, + 0xF1, 0x47, 0x52, 0x50, 0xF0, 0xA3, 0x7B, 0xE6, + 0x74, 0xDC, 0x72, 0x28, 0xC8, 0xAB, 0xB3, 0x31, + 0x7D, 0xA3, 0xF7, 0xC7, 0xD1, 0xE6, 0x99, 0xB4, + 0xB6, 0x5A, 0x3A, 0x4D, 0x83, 0x4F, 0xB8, 0xB5, + 0x86, 0xF8, 0x37, 0x7F, 0xA0, 0x16, 0x2F, 0x3C, + 0x62, 0x7A, 0xD4, 0x3A, 0xEB, 0xC2, 0xE8, 0x03, + 0x49, 0x17, 0x9E, 0xFB, 0xD7, 0xAF, 0x91, 0x32, + 0xFD, 0xEA, 0x4F, 0x64, 0xC6, 0x6E, 0x02, 0xEA, + 0xC4, 0xC8, 0x1F, 0x16, 0xC5, 0x4C, 0xFB, 0xC5, + 0x42, 0xF5, 0x85, 0x05, 0x92, 0x59, 0x4B, 0x31, + 0xE5, 0xE9, 0x69, 0xE7, 0x02, 0x98, 0x33, 0xBA, + 0x4C, 0x17, 0x09, 0xEF, 0x89, 0x20, 0xFA, 0x83, + 0x9F, 0xAE, 0x0E, 0x1B, 0x7D, 0x98, 0xB9, 0xF2, + 0x3C, 0x0F, 0xB7, 0x1C, 0x72, 0xDF, 0x17, 0x84, + 0x7F, 0x0A, 0xFD, 0x12, 0x3C, 0x6F, 0x68, 0x5D, + 0x45, 0xEB, 0xB8, 0xD6, 0x24, 0x65, 0x42, 0x75, + 0x5C, 0xC2, 0xF3, 0x3A, 0x6A, 0x4E, 0x51, 0x34, + 0x1B, 0xB6, 0x81, 0xB2, 0x8A, 0xEF, 0x28, 0xA4, + 0xC5, 0x88, 0x9A, 0x97, 0xE0, 0xEF, 0x31, 0x12, + 0x01, 0x7E, 0x1B, 0x43, 0x0F, 0x27, 0x80, 0x87, + 0x98, 0xC5, 0xD5, 0x83, 0xCB, 0x4B, 0xB7, 0x01, + 0x79, 0x60, 0xA1, 0x1A, 0x03, 0x05, 0xC6, 0x36, + 0x04, 0x31, 0x3C, 0x06, 0xDB, 0x08, 0xA8, 0xDA, + 0x8E, 0x32, 0x19, 0x91, 0xF1, 0x0D, 0x61, 0x6F, + 0xE4, 0xB2, 0x79, 0x8A, 0xDE, 0xF4, 0xF7, 0xFB, + 0x2C, 0x23, 0x5B, 0xD9, 0x64, 0x2F, 0xB7, 0xB3, + 0x8B, 0xCA, 0xB8, 0x8C, 0x1D, 0x3B, 0x49, 0x05, + 0x38, 0xA1, 0xE5, 0x8C, 0x1A, 0xDC, 0xA5, 0x61, + 0xFE, 0xF4, 0x2B, 0xDC, 0x77, 0x28, 0xF6, 0x19, + 0xE7, 0xB7, 0x8F, 0x4D, 0x27, 0x2D, 0xED, 0x8A, + 0x3F, 0x3D, 0xDC, 0x9F, 0xD1, 0x30, 0xFF, 0xD6, + 0xC3, 0xBE, 0x41, 0x25, 0xE3, 0xA5, 0x9B, 0x73, + 0xDF, 0x6A, 0xD9, 0xF9, 0x70, 0x84, 0x02, 0x4C, + 0x35, 0xD4, 0x3E, 0x05, 0x76, 0x3A, 0xDC, 0x6D, + 0x5A, 0x81, 0xB3, 0x94, 0xF7, 0x22, 0xF7, 0xDC, + 0xC1, 0x43, 0x31, 0x57, 0x5B, 0x42, 0x9A, 0x0B, + 0xF4, 0x95, 0x30, 0xA9, 0xBB, 0xD8, 0x06, 0xFB, + 0x1D, 0x6F, 0x9B, 0xC3, 0xBB, 0xF3, 0xBF, 0xFB, + 0xB4, 0x9F, 0x35, 0x64, 0x0A, 0x69, 0xB7, 0xD1, + 0x3E, 0xCA, 0x78, 0x07, 0x04, 0x03, 0x79, 0xD4, + 0xF3, 0xA8, 0xEC, 0x18, 0xDB, 0x03, 0x5E, 0x47, + 0xD7, 0xD0, 0x56, 0x2C, 0x74, 0x94, 0x86, 0x04, + 0x46, 0xB8, 0xD4, 0x35, 0x0A, 0x7B, 0xE6, 0x78, + 0xC4, 0x43, 0x3C, 0x56, 0xCC, 0x37, 0x8B, 0xFD, + 0xE8, 0xF4, 0x57, 0xEA, 0xAE, 0xCF, 0x36, 0x97, + 0x12, 0xAC, 0x39, 0xCF, 0x7C, 0xEF, 0x22, 0x67, + 0x01, 0xEC, 0xD8, 0x09, 0x49, 0x4E, 0xE3, 0x74, + 0xDD, 0x39, 0xE1, 0x39, 0xD7, 0x0C, 0x5F, 0x1B, + 0xCE, 0x69, 0xBC, 0x72, 0x44, 0x87, 0x64, 0x1C, + 0x08, 0x05, 0x93, 0x69, 0x6D, 0x7F, 0x90, 0x0A, + 0x2C, 0xCB, 0x8A, 0xBB, 0x7F, 0xE3, 0xE0, 0x80, + 0x31, 0xD0, 0x0A, 0x3A, 0x95, 0xFF, 0xF7, 0xB4, + 0x36, 0x38, 0x93, 0xE0, 0x0C, 0x11, 0x37, 0x12, + 0x06, 0xF6, 0xAD, 0xE9, 0xB1, 0x7A, 0x00, 0xF5, + 0xD2, 0x32, 0x6B, 0xD0, 0x27, 0xA5, 0x1B, 0x3D, + 0xE8, 0xDB, 0xCC, 0xA9, 0x1F, 0x1F, 0xB1, 0x99, + 0x3D, 0x7C, 0xB7, 0xCA, 0xDA, 0x27, 0x2C, 0x64, + 0x1C, 0x49, 0xB6, 0x87, 0x44, 0x06, 0x94, 0x9D, + 0xBC, 0x6B, 0x20, 0xA2, 0x68, 0x15, 0x1F, 0xE2, + 0xF2, 0xAD, 0x6D, 0x23, 0x2E, 0x2B, 0x74, 0xE2, + 0x5D, 0xE4, 0xB0, 0xC7, 0x84, 0xCB, 0x64, 0xBF, + 0xE0, 0xA8, 0x18, 0x83, 0xB4, 0xC9, 0xD9, 0x73, + 0xA8, 0xE6, 0xA9, 0x36, 0xD5, 0x63, 0x1E, 0x2C, + 0x2A, 0x55, 0x09, 0x77, 0x5E, 0xB3, 0x4B, 0xEA, + 0xB5, 0xD0, 0x14, 0x5F, 0xEB, 0x50, 0x7B, 0xAA, + 0xEF, 0x94, 0xBA, 0x2B, 0xD7, 0x8A, 0x07, 0xF1, + 0xF9, 0x5E, 0x12, 0x12, 0x21, 0x52, 0xE5, 0x0A, + 0x3E, 0xC0, 0xBC, 0x5D, 0x4C, 0xE2, 0x12, 0x7C, + 0x39, 0xF9, 0x16, 0x9D, 0xBD, 0x96, 0x83, 0x3B, + 0x7F, 0x3D, 0x6A, 0xEC, 0xF1, 0x25, 0xD2, 0xB0, + 0xB0, 0xEB, 0x20, 0x06, 0x07, 0xD6, 0xD9, 0x4C, + 0x07, 0x9A, 0x82, 0xC1, 0xFC, 0xF7, 0x66, 0x15, + 0xBD, 0x62, 0x65, 0xD8, 0x6C, 0xF6, 0x33, 0x7B, + 0x5A, 0x28, 0xEC, 0x90, 0xA1, 0x26, 0x9F, 0xC3, + 0x28, 0x4A, 0x64, 0x50, 0x5F, 0xCA, 0xE2, 0x6D, + 0xB8, 0x0F, 0xE2, 0x94, 0xB5, 0x8E, 0x1F, 0x8A, + 0x8F, 0x6B, 0xA6, 0x86, 0x1F, 0xEE, 0xDC, 0x24, + 0xB4, 0xB8, 0x25, 0xEC, 0x28, 0x2D, 0xF9, 0xCB, + 0x7D, 0x38, 0xFF, 0xC7, 0x74, 0x2E, 0xD3, 0x10, + 0xEC, 0x03, 0x31, 0xEE, 0x83, 0xE7, 0xA4, 0xF7, + 0xBA, 0x28, 0x21, 0xE0, 0x7F, 0xB4, 0xB7, 0xE1, + 0x7A, 0xF9, 0x2B, 0xB0, 0x2C, 0x3B, 0x80, 0x5F, + 0xE0, 0x5D, 0xB2, 0x7E, 0x59, 0xFF, 0x59, 0x07, + 0x58, 0x42, 0x57, 0xEE, 0x44, 0xF1, 0xB1, 0xAD, + 0xBA, 0xDE, 0xCB, 0x1D, 0x8A, 0x36, 0x67, 0xE8, + 0x45, 0xFF, 0x07, 0x8D, 0xEE, 0xA4, 0x51, 0x9C, + 0x4C, 0x83, 0x5D, 0x2E, 0x2F, 0xE1, 0x5B, 0x75, + 0xE8, 0x29, 0xCD, 0x0B, 0x07, 0x62, 0xE0, 0xC3, + 0x0D, 0x1D, 0xEA, 0xCF, 0xF0, 0x8A, 0x65, 0x27, + 0x70, 0x42, 0x9F, 0x26, 0x00, 0x15, 0x70, 0xC5, + 0x4A, 0xF6, 0x25, 0xD0, 0x40, 0x72, 0xE9, 0xC1, + 0x73, 0xFD, 0x48, 0x94, 0xA3, 0x8D, 0x66, 0x63, + 0x96, 0x4F, 0xF7, 0xEE, 0xFB, 0x4C, 0xC7, 0xB8, + 0x6B, 0xE9, 0x90, 0xE1, 0x2A, 0x66, 0x80, 0x99, + 0x3B, 0xB0, 0x1A, 0x6C, 0xF9, 0x0E, 0x72, 0xDA, + 0x8E, 0x4F, 0x46, 0xC2, 0x6A, 0x4B, 0x7A, 0x16, + 0xE5, 0x26, 0x0B, 0x5C, 0xD4, 0x47, 0x34, 0xE5, + 0x37, 0xBE, 0x68, 0x6C, 0xDA, 0xD3, 0x9B, 0x6F, + 0xAE, 0x51, 0x9C, 0x99, 0x0A, 0x5B, 0xF8, 0x37, + 0xBC, 0xDE, 0xFC, 0x93, 0xC5, 0xE7, 0x0F, 0xEF, + 0x0B, 0xA6, 0x07, 0xC2, 0xA6, 0xE6, 0xDA, 0x2D, + 0x1B, 0x49, 0xC9, 0xDE, 0x6B, 0x27, 0xDC, 0x00, + 0xEF, 0x23, 0x87, 0x0E, 0xEB, 0xD1, 0x48, 0x7D, + 0xB4, 0xF2, 0x58, 0xC6, 0x3C, 0xE2, 0x89, 0xBA, + 0xB0, 0x05, 0xAC, 0x94, 0x41, 0x9A, 0xA8, 0xFF, + 0x3E, 0xBC, 0x3A, 0x52, 0x9C, 0xF9, 0x7F, 0x07, + 0x8B, 0xB0, 0x2C, 0x71, 0x83, 0x7B, 0xCF, 0x2E, + 0x7F, 0x7C, 0x96, 0x65, 0xD9, 0x08, 0x17, 0xEC, + 0xFA, 0xDE, 0x4E, 0x40, 0x12, 0x26, 0x70, 0x71, + 0x65, 0xA5, 0xDC, 0x98, 0x47, 0xA3, 0xFC, 0xE0, + 0x9A, 0x16, 0xED, 0x45, 0x56, 0x72, 0x50, 0x05, + 0x28, 0x2C, 0x99, 0xEC, 0x20, 0x2E, 0x40, 0xC0, + 0x26, 0x69, 0xCD, 0x49, 0x45, 0x17, 0xA4, 0xA3, + 0x42, 0x0D, 0x14, 0x65, 0x87, 0x33, 0x8C, 0x92, + 0xC5, 0xC4, 0x61, 0xFD, 0xE8, 0x68, 0x56, 0x20, + 0x57, 0xF5, 0x8E, 0x5F, 0xCF, 0x7E, 0x97, 0xF6, + 0x49, 0x97, 0x0A, 0xFE, 0xD3, 0x60, 0x1A, 0x5B, + 0x0C, 0x75, 0xDD, 0x8E, 0x31, 0x78, 0x29, 0xA6, + 0xB1, 0x4D, 0xAA, 0xDF, 0x8A, 0xD1, 0xE6, 0x91, + 0xE3, 0x32, 0x3F, 0xEC, 0x8A, 0x1F, 0x0E, 0x35, + 0x07, 0x6E, 0x4B, 0x83, 0x3B, 0xE5, 0x67, 0x34, + 0x1F, 0x0C, 0x81, 0xD8, 0xD5, 0x25, 0x68, 0xE5, + 0x28, 0x1B, 0x5C, 0x81, 0x3E, 0xE3, 0x5C, 0xB4, + 0xB6, 0xBD, 0x62, 0x6A, 0x70, 0x33, 0xC2, 0xC5, + 0x75, 0x27, 0xF4, 0x30, 0xE1, 0x1D, 0xC1, 0x4C, + 0xC5, 0x02, 0x12, 0x46, 0xAC, 0xEC, 0xF9, 0xE8, + 0xE7, 0x58, 0x24, 0x11, 0xB1, 0xF3, 0xB7, 0x8C, + 0x3C, 0xA4, 0x0A, 0x94, 0xA6, 0x7C, 0x68, 0x54, + 0x5B, 0xB9, 0x4D, 0x57, 0x9C, 0xE7, 0x28, 0x09, + 0x6B, 0x89, 0x26, 0x5D, 0xE7, 0x50, 0xA9, 0x95, + 0x90, 0x91, 0x8E, 0x00, 0x59, 0xF8, 0x3A, 0x70, + 0xAF, 0x48, 0x2E, 0xE8, 0xC4, 0x34, 0x8C, 0xF4, + 0x5F, 0x7F, 0xCB, 0x07, 0xAA, 0xF0, 0xD9, 0xFB, + 0x5C, 0x32, 0x90, 0x22, 0x1A, 0xD2, 0x1A, 0xCF, + 0x92, 0x06, 0x02, 0xCF, 0x10, 0x18, 0x7B, 0x93, + 0xCC, 0x07, 0x4A, 0x31, 0x25, 0x30, 0x23, 0x06, + 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, + 0x09, 0x15, 0x31, 0x16, 0x04, 0x14, 0xD1, 0xDE, + 0x23, 0x16, 0x9F, 0x6E, 0xF4, 0x42, 0x21, 0x23, + 0xE1, 0x11, 0xAA, 0xC8, 0x7C, 0x60, 0x4A, 0x78, + 0x9D, 0x24, 0x30, 0x31, 0x30, 0x21, 0x30, 0x09, + 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x05, + 0x00, 0x04, 0x14, 0xD6, 0x4A, 0xBB, 0x75, 0xB1, + 0xF9, 0x9E, 0xD3, 0x58, 0x6D, 0xD1, 0x74, 0x9F, + 0x00, 0x8A, 0xF2, 0xC8, 0xAA, 0x52, 0x4D, 0x04, + 0x08, 0x77, 0x46, 0xE7, 0xBA, 0x25, 0x4B, 0xDA, + 0x41, 0x02, 0x02, 0x08, 0x00] +}; + +const WPA_EAP_CLIENT_LIST = [ + { + ssid: 'WPA-EAP-TTLS', + keyManagement: 'WPA-EAP', + eap: 'TTLS', + identity: EAP_USERNAME, + password: EAP_PASSWORD, + serverCertificate: CLIENT_PKCS12_CERT.nickname, + phase2: 'MSCHAPV2' + } +]; + +/** + * Convert the given MozWifiNetwork object array to testAssociate chain. + * + * @param aNetworks + * An array of MozWifiNetwork which we want to convert. + * + * @return A promise chain which "then"s testAssociate accordingly. + */ +function convertToTestAssociateChain(aNetworks) { + let chain = Promise.resolve(); + + aNetworks.forEach(function (aNetwork) { + network = new window.MozWifiNetwork(aNetwork); + chain = chain.then(() => gTestSuite.testAssociate(network)); + }); + + return chain; +} + +gTestSuite.doTestWithCertificate( + new Blob([new Uint8Array(CLIENT_PKCS12_CERT.content)]), + CLIENT_PKCS12_CERT.password, + CLIENT_PKCS12_CERT.nickname, + CLIENT_PKCS12_CERT.usage, + function() { + return gTestSuite.ensureWifiEnabled(true) + // Load required server files. + .then(() => gTestSuite.writeFile(SERVER_EAP_USER_CONF.path, SERVER_EAP_USER_CONF.content)) + .then(() => gTestSuite.writeFile(CA_CERT.path, CA_CERT.content)) + .then(() => gTestSuite.writeFile(SERVER_CERT.path, SERVER_CERT.content)) + .then(() => gTestSuite.writeFile(SERVER_KEY.path, SERVER_KEY.content)) + // Start AP. + .then(() => gTestSuite.startHostapds(WPA_EAP_AP_LIST)) + // Scan test. + .then(() => gTestSuite.testWifiScanWithRetry(SCAN_RETRY_CNT, WPA_EAP_AP_LIST)) + // Associate test. + .then(() => convertToTestAssociateChain(WPA_EAP_CLIENT_LIST)) + // Tear down. + .then(gTestSuite.killAllHostapd) +}); diff --git a/dom/wifi/test/marionette/test_wifi_associate_wo_connect.js b/dom/wifi/test/marionette/test_wifi_associate_wo_connect.js new file mode 100644 index 000000000..3fba0b2c6 --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_associate_wo_connect.js @@ -0,0 +1,55 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +/** + * Associate with the given networks but don't connect to it. + * + * Issue a association-only request, which will not have us connect + * to the network. Instead, the network config will be added as the + * known networks. After calling the "associate" API, we will wait + * a while to make sure the "connected" event is not received. + * + * Fulfill params: (none) + * Reject params: (none) + * + * @param aNetwork + * MozWifiNetwork object. + * + * @return A deferred promise. + */ +function associateButDontConnect(aNetwork) { + log('Associating with ' + aNetwork.ssid); + aNetwork.dontConnect = true; + + let promises = []; + promises.push(gTestSuite.waitForTimeout(10 * 1000) + .then(() => { throw 'timeout'; })); + + promises.push(gTestSuite.testAssociate(aNetwork)); + + return Promise.all(promises) + .then(() => { throw 'unexpected state'; }, + function(aReason) { + is(typeof aReason, 'string', 'typeof aReason'); + is(aReason, 'timeout', aReason); + }); +} + +gTestSuite.doTest(function() { + let firstNetwork; + return gTestSuite.ensureWifiEnabled(true) + .then(gTestSuite.requestWifiScan) + .then(function(aNetworks) { + firstNetwork = aNetworks[0]; + return associateButDontConnect(firstNetwork); + }) + .then(gTestSuite.getKnownNetworks) + .then(function(aKnownNetworks) { + is(1, aKnownNetworks.length, 'There should be only one known network!'); + is(aKnownNetworks[0].ssid, firstNetwork.ssid, + 'The only one known network should be ' + firstNetwork.ssid) + }); +}); diff --git a/dom/wifi/test/marionette/test_wifi_auto_connect.js b/dom/wifi/test/marionette/test_wifi_auto_connect.js new file mode 100644 index 000000000..7add9f03d --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_auto_connect.js @@ -0,0 +1,44 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +const TESTING_HOSTAPD = [{ ssid: 'ap0' }]; + +gTestSuite.doTestWithoutStockAp(function() { + let firstNetwork; + return gTestSuite.ensureWifiEnabled(true) + // Start custom hostapd for testing. + .then(() => gTestSuite.startHostapds(TESTING_HOSTAPD)) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', TESTING_HOSTAPD.length)) + + // Request the first scan. + .then(gTestSuite.requestWifiScan) + .then(function(networks) { + firstNetwork = networks[0]; + return gTestSuite.testAssociate(firstNetwork); + }) + + // Note that due to Bug 1168285, we need to re-start testing hostapd + // after wifi has been re-enabled. + + // Disable wifi and kill running hostapd. + .then(() => gTestSuite.requestWifiEnabled(false)) + .then(gTestSuite.killAllHostapd) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', 0)) + + // Re-enable wifi. + .then(() => gTestSuite.requestWifiEnabled(true)) + + // Restart hostapd. + .then(() => gTestSuite.startHostapds(TESTING_HOSTAPD)) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', TESTING_HOSTAPD.length)) + + // Wait for connection automatically. + .then(() => gTestSuite.waitForConnected(firstNetwork)) + + // Kill running hostapd. + .then(gTestSuite.killAllHostapd) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', 0)) +}); diff --git a/dom/wifi/test/marionette/test_wifi_enable.js b/dom/wifi/test/marionette/test_wifi_enable.js new file mode 100644 index 000000000..6a1bec7a2 --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_enable.js @@ -0,0 +1,11 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +gTestSuite.doTest(function() { + return Promise.resolve() + .then(() => gTestSuite.ensureWifiEnabled(false)) + .then(() => gTestSuite.requestWifiEnabled(true)); +});
\ No newline at end of file diff --git a/dom/wifi/test/marionette/test_wifi_enable_api.js b/dom/wifi/test/marionette/test_wifi_enable_api.js new file mode 100644 index 000000000..3728330a2 --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_enable_api.js @@ -0,0 +1,13 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +gTestSuite.doTest(function() { + return Promise.resolve() + .then(() => gTestSuite.ensureWifiEnabled(false, true)) + .then(() => gTestSuite.requestWifiEnabled(true, true)) + .then(() => gTestSuite.requestWifiEnabled(false, true)) + .then(() => gTestSuite.ensureWifiEnabled(true, true)); +}); diff --git a/dom/wifi/test/marionette/test_wifi_manage_pkcs12_certificate.js b/dom/wifi/test/marionette/test_wifi_manage_pkcs12_certificate.js new file mode 100644 index 000000000..f85ef00c9 --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_manage_pkcs12_certificate.js @@ -0,0 +1,338 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +// Binary form of test certificate. +var testCertInfo = { + nickname: 'Test Certificate', + password: '12345678', + usage: ['UserCert', 'ServerCert'], + blob: [0x30, 0x82, 0x09, 0xF1, 0x02, 0x01, 0x03, 0x30, + 0x82, 0x09, 0xB7, 0x06, 0x09, 0x2A, 0x86, 0x48, + 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01, 0xA0, 0x82, + 0x09, 0xA8, 0x04, 0x82, 0x09, 0xA4, 0x30, 0x82, + 0x09, 0xA0, 0x30, 0x82, 0x06, 0x9F, 0x06, 0x09, + 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, + 0x06, 0xA0, 0x82, 0x06, 0x90, 0x30, 0x82, 0x06, + 0x8C, 0x02, 0x01, 0x00, 0x30, 0x82, 0x06, 0x85, + 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, + 0x01, 0x07, 0x01, 0x30, 0x1C, 0x06, 0x0A, 0x2A, + 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, + 0x06, 0x30, 0x0E, 0x04, 0x08, 0x13, 0xB5, 0x2F, + 0x5A, 0xB9, 0x49, 0xE6, 0x0B, 0x02, 0x02, 0x08, + 0x00, 0x80, 0x82, 0x06, 0x58, 0x35, 0x77, 0x6B, + 0xBF, 0x5C, 0x06, 0x09, 0xD8, 0xF0, 0x36, 0x06, + 0x69, 0x8D, 0xA2, 0x86, 0xCF, 0x6B, 0x73, 0x86, + 0x14, 0xFA, 0x51, 0x9A, 0x87, 0x73, 0x29, 0x71, + 0xC5, 0xB1, 0x4F, 0xFB, 0xEC, 0x64, 0x84, 0x20, + 0xFC, 0x06, 0x4A, 0x93, 0x74, 0x01, 0xFB, 0xEB, + 0x1F, 0xDC, 0xF8, 0xF7, 0xBB, 0xDC, 0x42, 0xA1, + 0x4A, 0x71, 0xDE, 0x08, 0x33, 0x7A, 0xCA, 0xD3, + 0xD8, 0x40, 0x24, 0x47, 0xAE, 0x41, 0x42, 0x8E, + 0xC8, 0x4E, 0xBE, 0x8B, 0xB3, 0xE5, 0x77, 0xAC, + 0xBD, 0x98, 0x0C, 0x0E, 0x53, 0xBE, 0x38, 0xB7, + 0xEA, 0xD2, 0x29, 0x35, 0xD2, 0xC4, 0xF4, 0xC7, + 0xD8, 0xB1, 0x73, 0x2A, 0x13, 0x11, 0x65, 0xF7, + 0x0C, 0x8B, 0xC0, 0x43, 0xFB, 0x31, 0x6C, 0xD2, + 0xE4, 0x43, 0x85, 0x51, 0x16, 0xBF, 0x35, 0xB5, + 0x05, 0x6B, 0x86, 0x11, 0xEA, 0x78, 0x64, 0x9F, + 0x42, 0x29, 0xB9, 0x79, 0xAF, 0xB0, 0x7C, 0xBF, + 0xC0, 0x89, 0xAD, 0xC7, 0x37, 0xD2, 0x30, 0x8C, + 0xDC, 0xF6, 0x77, 0x5E, 0x1F, 0x26, 0x28, 0x8F, + 0xAC, 0x19, 0x6C, 0xA0, 0x15, 0xC7, 0x12, 0xA3, + 0x0A, 0xD5, 0xC6, 0x15, 0x60, 0x58, 0x16, 0xB8, + 0x30, 0x12, 0x3C, 0x78, 0x3C, 0x93, 0x23, 0xA1, + 0x56, 0x75, 0x0B, 0x77, 0xAA, 0x0B, 0x0B, 0x2B, + 0x91, 0xB6, 0x41, 0xAB, 0xF5, 0x09, 0x4C, 0x1E, + 0x36, 0xC0, 0x88, 0xC3, 0x08, 0xF2, 0x65, 0xCB, + 0x58, 0x8F, 0x94, 0xB4, 0xB4, 0x05, 0xCC, 0x44, + 0x49, 0x73, 0x1B, 0x25, 0x6F, 0x5D, 0x83, 0xBD, + 0xF0, 0x70, 0xD0, 0xE8, 0x0D, 0x18, 0x2E, 0x44, + 0xD7, 0x89, 0x64, 0x6A, 0xED, 0x23, 0x30, 0xDF, + 0xAD, 0x84, 0x3B, 0x74, 0x2C, 0x0D, 0x2B, 0x51, + 0x84, 0xA2, 0xA4, 0x9E, 0x42, 0xC3, 0x81, 0x69, + 0xFA, 0x56, 0x76, 0x9F, 0xD9, 0x02, 0x64, 0x04, + 0xFE, 0xF0, 0xD9, 0x01, 0xBC, 0xE2, 0xC9, 0xDD, + 0x88, 0xAC, 0xFA, 0x24, 0x7E, 0xB1, 0xF8, 0x39, + 0x27, 0xA2, 0xEB, 0xE4, 0x53, 0xC1, 0xF3, 0xFE, + 0x2D, 0x9A, 0x49, 0x73, 0xFF, 0x7C, 0x8E, 0x39, + 0xF7, 0x15, 0x27, 0xB3, 0x47, 0x48, 0x92, 0x8C, + 0x57, 0x60, 0x9C, 0x97, 0xBA, 0x80, 0xD2, 0x25, + 0x80, 0x94, 0xCE, 0x2C, 0x0C, 0x00, 0x44, 0x8C, + 0x8C, 0x37, 0x82, 0x5D, 0x5F, 0x62, 0x8B, 0x05, + 0x6F, 0xB0, 0x07, 0x34, 0xF9, 0xC3, 0xA1, 0x34, + 0x3D, 0xE4, 0x90, 0xB0, 0x03, 0x59, 0x97, 0x6E, + 0xFB, 0xF2, 0x92, 0xE5, 0xB5, 0x30, 0x7C, 0x0D, + 0x3B, 0x8F, 0x90, 0x8E, 0x04, 0x47, 0x01, 0x0E, + 0x88, 0x50, 0x4A, 0x88, 0xA0, 0xFF, 0xB7, 0x9E, + 0x2B, 0x2C, 0x98, 0xD0, 0x3E, 0x16, 0x35, 0x5B, + 0xD5, 0xEA, 0x54, 0x86, 0xE0, 0xFB, 0x9F, 0x2F, + 0x62, 0x89, 0x36, 0x36, 0x9D, 0x6E, 0x62, 0xCB, + 0xC8, 0x6C, 0x62, 0x34, 0x8F, 0x66, 0x07, 0x62, + 0xA7, 0x00, 0x90, 0x31, 0xFA, 0x5D, 0xDD, 0x12, + 0x33, 0x69, 0xD0, 0x74, 0x0E, 0x0B, 0x42, 0x9A, + 0xF3, 0x40, 0x7E, 0x3E, 0x48, 0x1D, 0xF2, 0x5C, + 0x71, 0x0B, 0x78, 0x7E, 0xD5, 0x15, 0xA4, 0x16, + 0x1E, 0xBD, 0x71, 0x18, 0x87, 0x3A, 0xC9, 0xE3, + 0x45, 0xEE, 0x70, 0xA2, 0x4C, 0x50, 0xF5, 0x16, + 0x5C, 0xF8, 0x76, 0xE6, 0x9F, 0x8D, 0x86, 0x41, + 0x7E, 0xF8, 0x60, 0x3D, 0x75, 0x6D, 0x55, 0x96, + 0x9E, 0x43, 0x48, 0x82, 0xF7, 0xB6, 0xAC, 0x98, + 0x6F, 0x10, 0xAA, 0x20, 0x64, 0xD0, 0x7C, 0x25, + 0x24, 0xF7, 0xD8, 0xA4, 0xCC, 0x2D, 0xBF, 0x85, + 0x62, 0x6C, 0x4F, 0xFF, 0x9D, 0x71, 0x04, 0x98, + 0x61, 0xB0, 0xBC, 0x31, 0xC1, 0xE9, 0xB8, 0x29, + 0xA5, 0xEB, 0xD1, 0x1D, 0x65, 0x8E, 0xAE, 0x38, + 0x55, 0x65, 0x22, 0xC7, 0xFD, 0x7E, 0xF2, 0x6A, + 0xB6, 0xB1, 0x51, 0x37, 0x4B, 0x05, 0x8F, 0xA7, + 0x2D, 0x3F, 0x5C, 0x04, 0x2B, 0xBA, 0x2C, 0x37, + 0xCA, 0xDE, 0xD5, 0x3E, 0xA0, 0xA5, 0x86, 0x59, + 0xA7, 0xD7, 0x38, 0x07, 0xFB, 0x79, 0xF6, 0x2D, + 0xE1, 0xAA, 0x7C, 0xD1, 0x91, 0xBE, 0x39, 0xDF, + 0x53, 0x3C, 0xD1, 0x44, 0x2C, 0xF9, 0x12, 0x7D, + 0xB1, 0xCD, 0xF3, 0x35, 0x1F, 0x85, 0xA6, 0x64, + 0x2F, 0xFD, 0x28, 0xF2, 0x85, 0xA8, 0xA7, 0x1F, + 0x7F, 0xD9, 0x79, 0x30, 0x9B, 0xFC, 0x69, 0x3A, + 0x9B, 0x1F, 0x55, 0x70, 0xC9, 0x60, 0x82, 0x3D, + 0xE9, 0x5A, 0x37, 0x5F, 0x8C, 0xBD, 0x19, 0x5D, + 0xCC, 0x1C, 0xBE, 0x26, 0x4A, 0xEA, 0x8B, 0x39, + 0xCE, 0x0D, 0xBD, 0x63, 0x05, 0x98, 0x75, 0xAB, + 0x08, 0x79, 0x90, 0xC7, 0x20, 0xFF, 0xE4, 0x0D, + 0xB1, 0xA0, 0x92, 0x2B, 0x0C, 0x4B, 0x0C, 0xDC, + 0xB9, 0x72, 0x2A, 0xA4, 0xCC, 0xA6, 0x32, 0xA3, + 0x57, 0x82, 0xB4, 0xB9, 0x0F, 0x81, 0xC5, 0xD9, + 0x7C, 0xB8, 0x0F, 0x7D, 0xEA, 0x5D, 0xD3, 0xC4, + 0x2F, 0x31, 0x79, 0x11, 0xAD, 0x36, 0x56, 0x1F, + 0xFA, 0xE3, 0xCE, 0xD2, 0x29, 0x23, 0xE8, 0x2C, + 0xDF, 0x7D, 0x94, 0x28, 0x28, 0x9A, 0x0E, 0x64, + 0xFC, 0x07, 0x11, 0x96, 0x06, 0x1A, 0x39, 0xCD, + 0x04, 0x37, 0x37, 0xDB, 0xFE, 0x68, 0x37, 0xF5, + 0x59, 0x54, 0xBC, 0xEF, 0xDB, 0x0C, 0x80, 0xCD, + 0xD3, 0x46, 0xA8, 0xA2, 0xBE, 0xE0, 0x63, 0x80, + 0xA1, 0x5F, 0x5D, 0xF1, 0xFB, 0x96, 0x8C, 0x06, + 0x38, 0xB6, 0xCB, 0x70, 0xB0, 0xFB, 0xD3, 0x26, + 0xB3, 0x8B, 0xC6, 0x85, 0x34, 0xB7, 0xAB, 0x5F, + 0x7E, 0xC6, 0xAA, 0x79, 0x5B, 0x48, 0x11, 0x65, + 0x9E, 0x2A, 0xCD, 0x6A, 0xF0, 0xB2, 0x93, 0xF5, + 0x2B, 0x88, 0x45, 0xB7, 0xC9, 0xBE, 0x1A, 0x72, + 0x60, 0x62, 0xA4, 0xA5, 0x3B, 0xC2, 0x1C, 0xC6, + 0x21, 0x09, 0xA9, 0x40, 0xF6, 0x58, 0x2B, 0xE5, + 0x70, 0xDC, 0xFC, 0x47, 0x3B, 0x08, 0xEE, 0xA9, + 0x94, 0x26, 0x43, 0xFE, 0xA7, 0x75, 0xD6, 0x4E, + 0x52, 0xF6, 0x46, 0xD1, 0x80, 0xEB, 0x3B, 0x8E, + 0xBE, 0x54, 0x4F, 0xBD, 0x42, 0x0E, 0x41, 0xF9, + 0x36, 0x7D, 0xB6, 0x7F, 0x99, 0x20, 0xC9, 0x63, + 0xE7, 0x93, 0x02, 0x62, 0x59, 0x94, 0xCB, 0xC6, + 0x62, 0xA9, 0x26, 0xE1, 0x1E, 0x03, 0x5A, 0x41, + 0x2F, 0x43, 0x28, 0x75, 0xB7, 0x0C, 0x02, 0x9C, + 0x1E, 0xE0, 0x40, 0xB3, 0xE2, 0x9A, 0xED, 0xC6, + 0x20, 0x49, 0xEC, 0xDD, 0xC5, 0x64, 0x95, 0x83, + 0x51, 0xAE, 0x46, 0x9D, 0x70, 0x17, 0xC6, 0x47, + 0xD3, 0x82, 0xCC, 0x6A, 0x5D, 0x93, 0xB2, 0x85, + 0x5B, 0x25, 0x05, 0xE7, 0x26, 0x2E, 0xD3, 0xDA, + 0x1C, 0xD9, 0x06, 0xB6, 0x16, 0x69, 0x8C, 0x7F, + 0xC8, 0xCF, 0x95, 0x18, 0xB5, 0x98, 0xC0, 0x42, + 0x61, 0xDE, 0x77, 0x41, 0x3A, 0xF6, 0xE1, 0xB0, + 0xE8, 0x64, 0x4A, 0xC2, 0x58, 0xBE, 0x27, 0xC6, + 0x9B, 0x0D, 0x47, 0x1A, 0x09, 0x56, 0x7D, 0x2B, + 0x19, 0x01, 0x88, 0xC7, 0xFB, 0x1E, 0xCF, 0x5E, + 0xF6, 0xB0, 0x82, 0x87, 0xC0, 0xBE, 0xD6, 0xA5, + 0xC3, 0xAC, 0x3A, 0x97, 0x88, 0x25, 0x81, 0xAA, + 0x3A, 0xCE, 0x66, 0x88, 0x0F, 0xC3, 0x02, 0x50, + 0x1C, 0xC3, 0x2B, 0xBC, 0x53, 0x52, 0xFE, 0xD2, + 0x3F, 0x50, 0xC8, 0xB2, 0x19, 0x0A, 0x14, 0xB1, + 0x73, 0x18, 0xB4, 0xDF, 0xBD, 0xED, 0x43, 0xC5, + 0x91, 0xF4, 0x91, 0xBA, 0x7E, 0xB0, 0x7E, 0xA9, + 0x43, 0x67, 0x06, 0xCF, 0x51, 0xC1, 0xBF, 0x63, + 0x7E, 0x91, 0x76, 0xFF, 0x4F, 0x48, 0x91, 0xCF, + 0xDF, 0x01, 0x4D, 0x7E, 0x81, 0x22, 0xFB, 0x79, + 0xFC, 0x1D, 0xE3, 0xA7, 0x45, 0x16, 0xFB, 0xF2, + 0x83, 0xC7, 0xAE, 0xC6, 0xC5, 0x81, 0xDB, 0xA2, + 0x9F, 0x2F, 0xEA, 0xE6, 0x8E, 0x12, 0x8D, 0x43, + 0x14, 0x26, 0x25, 0x0E, 0xB4, 0x18, 0xE8, 0x41, + 0x84, 0xA3, 0x04, 0xDF, 0x97, 0xFF, 0xAA, 0x45, + 0xEC, 0x18, 0xAA, 0xB1, 0xFC, 0xDC, 0xB9, 0xAB, + 0xEE, 0xD1, 0xC4, 0x9E, 0x42, 0x3F, 0x5B, 0x8F, + 0x9F, 0x22, 0xAF, 0xCC, 0x6F, 0xA0, 0x41, 0x41, + 0xCB, 0xD3, 0xAC, 0x96, 0x20, 0xF1, 0x63, 0x56, + 0x65, 0xCE, 0x83, 0xC6, 0x62, 0x04, 0x85, 0x16, + 0x7F, 0x4E, 0xFB, 0xA0, 0x68, 0x11, 0x85, 0x5B, + 0x51, 0xB6, 0x9F, 0xA2, 0xF5, 0xA1, 0xCF, 0x01, + 0x9A, 0x80, 0x68, 0xC3, 0xE9, 0x7F, 0x9E, 0x2E, + 0x83, 0x84, 0xDC, 0x3C, 0x35, 0xCF, 0x24, 0xBF, + 0xF5, 0x00, 0x91, 0x45, 0x14, 0x65, 0xE0, 0xC5, + 0x75, 0xDA, 0xEF, 0x14, 0xBD, 0xDB, 0x28, 0x8D, + 0x30, 0x96, 0xC9, 0xFE, 0xA8, 0x49, 0x76, 0xC9, + 0xED, 0x90, 0x4C, 0x2E, 0xF1, 0x14, 0x2C, 0xF7, + 0x13, 0x7C, 0xF1, 0xCC, 0x67, 0xA5, 0x11, 0x55, + 0xBD, 0x66, 0x13, 0x8A, 0x76, 0xF9, 0xAC, 0xC9, + 0x51, 0x8A, 0xBB, 0x5D, 0x29, 0xEF, 0xF6, 0x37, + 0xA0, 0x3E, 0x99, 0x77, 0x6B, 0xE5, 0xCD, 0x06, + 0xAC, 0x57, 0x07, 0x37, 0x44, 0x3D, 0x5D, 0xD7, + 0xB6, 0x5C, 0xCB, 0x77, 0xD0, 0x4C, 0x28, 0x9D, + 0x12, 0x69, 0x5A, 0x68, 0xD1, 0x15, 0x30, 0xC4, + 0x30, 0xD2, 0x20, 0xDF, 0xD5, 0x73, 0x9F, 0x83, + 0xE9, 0x4C, 0x55, 0xF5, 0xAF, 0xAA, 0x37, 0xF8, + 0x28, 0xB6, 0x3F, 0x99, 0x4B, 0x15, 0x1E, 0x40, + 0xAB, 0x4F, 0x58, 0x3D, 0x3B, 0x81, 0x7D, 0x62, + 0x28, 0x6E, 0x73, 0x58, 0x50, 0x36, 0x49, 0x01, + 0xF7, 0x04, 0x3A, 0x23, 0x28, 0xDA, 0x15, 0xC5, + 0xE3, 0xF6, 0x6F, 0xE1, 0x79, 0x07, 0xFB, 0xAA, + 0xFF, 0x44, 0x48, 0x53, 0x9E, 0x7F, 0x8D, 0x89, + 0x88, 0x1A, 0x9A, 0xF9, 0x47, 0x58, 0x20, 0xBB, + 0x79, 0x4A, 0x2A, 0x14, 0x03, 0x9B, 0x65, 0x4C, + 0x67, 0x02, 0x02, 0xFE, 0xEB, 0xCD, 0xCB, 0x84, + 0xF5, 0xCE, 0x32, 0x59, 0xBC, 0xEA, 0xEC, 0xB1, + 0x3C, 0x22, 0xCF, 0x9D, 0xB0, 0x34, 0x6D, 0xE6, + 0x5A, 0x37, 0xC0, 0x22, 0xAA, 0xF3, 0xB5, 0x71, + 0x90, 0x21, 0xE0, 0xB6, 0x19, 0xE9, 0xB3, 0x10, + 0xCE, 0x5B, 0xF9, 0xD4, 0x25, 0x30, 0x7D, 0xF6, + 0x7D, 0xB6, 0x16, 0xFC, 0x20, 0x3C, 0x2F, 0x96, + 0xD5, 0x79, 0x90, 0x88, 0x24, 0x5D, 0x46, 0x64, + 0x99, 0xC1, 0xF8, 0x7F, 0x96, 0xA7, 0xB5, 0xA9, + 0x47, 0xA3, 0x14, 0xED, 0x93, 0xED, 0x30, 0x56, + 0x58, 0xA5, 0xD4, 0x54, 0x2A, 0xF3, 0x89, 0x27, + 0x7C, 0x55, 0x41, 0x11, 0x27, 0x9D, 0xF6, 0x4D, + 0xA6, 0xB1, 0x00, 0xE0, 0xB0, 0xF6, 0x1E, 0xAB, + 0x20, 0x1F, 0xAE, 0x8A, 0x82, 0xA7, 0x49, 0xFC, + 0xBB, 0x66, 0xAC, 0x97, 0x95, 0x49, 0x29, 0xCB, + 0x6F, 0xF4, 0xC1, 0xB7, 0x6B, 0xF9, 0x8C, 0x25, + 0xC6, 0xF0, 0xB5, 0x81, 0xB0, 0xA2, 0x4D, 0xCC, + 0x2E, 0xD0, 0x13, 0x5F, 0x96, 0x3F, 0xCD, 0xD0, + 0x52, 0xD1, 0xFE, 0xF9, 0xC2, 0x7E, 0x9D, 0xAB, + 0xCB, 0x95, 0x0F, 0x27, 0x01, 0x9E, 0x23, 0x6B, + 0x19, 0xFF, 0x52, 0x55, 0x71, 0x0A, 0xD4, 0xBB, + 0x43, 0x65, 0x29, 0x66, 0xBE, 0x2D, 0x6C, 0xE3, + 0x2A, 0x7C, 0xB4, 0x02, 0x32, 0x59, 0x94, 0x80, + 0x14, 0xE7, 0x62, 0xE4, 0xCE, 0xB0, 0xCA, 0xCA, + 0x37, 0xD7, 0x0C, 0x68, 0x29, 0xE2, 0x92, 0xE1, + 0xEB, 0x91, 0xE5, 0xA1, 0x0C, 0xFC, 0x55, 0xCB, + 0x56, 0xB3, 0x96, 0xFB, 0x64, 0xD9, 0x53, 0x8E, + 0x82, 0x2B, 0xDF, 0x7F, 0xCB, 0x2A, 0xF6, 0x3C, + 0xA7, 0x89, 0x52, 0x13, 0x2C, 0x6A, 0x93, 0xA2, + 0x74, 0xF5, 0x91, 0x00, 0x17, 0xAA, 0x74, 0x45, + 0x63, 0x5A, 0xE5, 0xC3, 0x16, 0xFC, 0x0E, 0xF7, + 0xF3, 0xA4, 0x55, 0x8A, 0xA2, 0x60, 0x24, 0x57, + 0x25, 0x2C, 0x94, 0xE0, 0xF5, 0x32, 0x54, 0x4A, + 0x2D, 0x63, 0x5F, 0xD8, 0x35, 0x96, 0xBD, 0xFE, + 0x90, 0x33, 0x17, 0xF6, 0xB5, 0x81, 0x02, 0xFA, + 0x5C, 0x94, 0x3A, 0xBE, 0x22, 0xB9, 0xFC, 0x3E, + 0x09, 0xE4, 0x76, 0xD7, 0x03, 0x38, 0x38, 0xC2, + 0xC2, 0x0D, 0x66, 0x3C, 0xD0, 0x91, 0x5C, 0xF4, + 0x0E, 0xC2, 0xDE, 0x46, 0x90, 0x2E, 0xF5, 0x22, + 0xA9, 0x3D, 0x15, 0x20, 0x5F, 0x17, 0x10, 0x5A, + 0x54, 0x63, 0x93, 0x7B, 0xC3, 0x00, 0x3D, 0x42, + 0x73, 0xF1, 0xAD, 0xC1, 0xDE, 0x76, 0x18, 0x9C, + 0x68, 0x17, 0xBF, 0x3B, 0xE0, 0x30, 0x82, 0x02, + 0xF9, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, + 0x0D, 0x01, 0x07, 0x01, 0xA0, 0x82, 0x02, 0xEA, + 0x04, 0x82, 0x02, 0xE6, 0x30, 0x82, 0x02, 0xE2, + 0x30, 0x82, 0x02, 0xDE, 0x06, 0x0B, 0x2A, 0x86, + 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, + 0x02, 0xA0, 0x82, 0x02, 0xA6, 0x30, 0x82, 0x02, + 0xA2, 0x30, 0x1C, 0x06, 0x0A, 0x2A, 0x86, 0x48, + 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x03, 0x30, + 0x0E, 0x04, 0x08, 0x34, 0x37, 0x27, 0x5F, 0xE8, + 0xD6, 0x00, 0x0D, 0x02, 0x02, 0x08, 0x00, 0x04, + 0x82, 0x02, 0x80, 0xC0, 0xE6, 0xB1, 0x63, 0x73, + 0xFC, 0xBF, 0x50, 0xFB, 0x54, 0xCF, 0x67, 0x16, + 0xF8, 0x28, 0x48, 0x13, 0x7F, 0xF2, 0xBD, 0x66, + 0x70, 0xC7, 0xF6, 0x01, 0xD0, 0x58, 0xF4, 0xA4, + 0xD9, 0x45, 0xE2, 0x63, 0x92, 0x7F, 0x78, 0x2B, + 0xB6, 0xDB, 0x16, 0x44, 0x1D, 0x11, 0xCB, 0xC3, + 0x20, 0xA9, 0x8A, 0x96, 0x13, 0xB8, 0x6E, 0xF3, + 0xDA, 0x46, 0x05, 0x2C, 0xF9, 0x67, 0xBB, 0x05, + 0x88, 0xC0, 0xC8, 0x60, 0x09, 0xA3, 0x82, 0x27, + 0x33, 0xEB, 0xEE, 0x43, 0x98, 0xE9, 0xE2, 0x24, + 0xA8, 0x06, 0xD5, 0xFF, 0xF5, 0xC0, 0x79, 0x4B, + 0x06, 0x40, 0xE6, 0x28, 0xC6, 0x6E, 0x4E, 0x03, + 0xCC, 0x9B, 0xB6, 0xBD, 0xB6, 0x81, 0x88, 0x5C, + 0x34, 0x6B, 0x8B, 0x15, 0x23, 0x75, 0x21, 0xAC, + 0x79, 0xFD, 0xDB, 0x80, 0x1D, 0x20, 0x84, 0xF1, + 0x47, 0xAF, 0x7B, 0x40, 0x6C, 0xD2, 0x64, 0x52, + 0x11, 0x1B, 0x01, 0x1E, 0xB5, 0xA9, 0x4B, 0xC4, + 0x51, 0x54, 0x40, 0xE2, 0xC8, 0xEB, 0x20, 0x48, + 0x2D, 0x40, 0xF8, 0xC6, 0x58, 0x5A, 0xE3, 0x34, + 0xD8, 0x79, 0x04, 0xD7, 0xD6, 0x07, 0xF2, 0x12, + 0x66, 0xC8, 0x31, 0x37, 0x71, 0x60, 0xF4, 0x75, + 0xDC, 0x60, 0x54, 0x19, 0x6A, 0x75, 0x56, 0xC5, + 0xA9, 0x67, 0x4A, 0x03, 0x7A, 0xFD, 0x12, 0x59, + 0x2B, 0x74, 0xE6, 0xA5, 0xE2, 0xF8, 0xBB, 0x1E, + 0x76, 0x96, 0xD4, 0xD4, 0x3F, 0x8B, 0xAD, 0x90, + 0xAF, 0x04, 0x41, 0xDB, 0xD8, 0xCC, 0x2D, 0x37, + 0x06, 0x20, 0x9B, 0xE7, 0x98, 0x87, 0x12, 0xAC, + 0x70, 0xC9, 0xF4, 0x1C, 0x28, 0xFB, 0x2C, 0x9E, + 0x18, 0xE1, 0x6D, 0x79, 0x34, 0xBC, 0xAC, 0xCB, + 0x75, 0x92, 0x7E, 0x8E, 0x7C, 0xA9, 0x0B, 0x86, + 0x4A, 0x88, 0xFB, 0xE8, 0xBE, 0x6A, 0x32, 0xEF, + 0x58, 0xCC, 0x4C, 0x89, 0x50, 0xEF, 0xDF, 0xE0, + 0xDD, 0x35, 0x07, 0x8C, 0x01, 0x8B, 0x57, 0x38, + 0xB5, 0x64, 0xBB, 0x0A, 0xC2, 0xD8, 0xAB, 0xC5, + 0x45, 0xA6, 0x83, 0xBF, 0xA6, 0xA2, 0xCC, 0x06, + 0x64, 0xBE, 0x84, 0x04, 0x55, 0x8E, 0xF4, 0x4C, + 0xB5, 0xBC, 0xE5, 0x97, 0x2B, 0x3C, 0x42, 0x44, + 0x91, 0x9B, 0xB2, 0x65, 0x70, 0x02, 0xC5, 0xB7, + 0x71, 0xB3, 0xF0, 0xAA, 0x46, 0x4F, 0x42, 0x40, + 0x53, 0x65, 0x89, 0xA5, 0x6C, 0xBC, 0xB5, 0x6C, + 0x0C, 0x3B, 0x50, 0x46, 0x67, 0xFA, 0x14, 0x68, + 0x01, 0xE7, 0xA6, 0xD4, 0xB5, 0xD0, 0x82, 0x44, + 0x92, 0x2C, 0xE3, 0x43, 0x5D, 0x34, 0x7C, 0x04, + 0xA3, 0x4D, 0x2F, 0x5A, 0x75, 0xE7, 0x0B, 0x64, + 0xD0, 0xAE, 0x7F, 0xCB, 0xDD, 0x7D, 0x05, 0x88, + 0x4C, 0x34, 0xBB, 0xF4, 0x00, 0xCE, 0x1C, 0x13, + 0x4E, 0xA3, 0xE3, 0x60, 0x4B, 0x50, 0x4E, 0xE1, + 0x26, 0x22, 0x51, 0xD4, 0x32, 0x60, 0xC6, 0x3E, + 0x7D, 0x4A, 0x3E, 0x56, 0x78, 0xBD, 0x5F, 0x23, + 0x7F, 0x0A, 0xA0, 0xC1, 0x1A, 0x60, 0xA2, 0x7C, + 0x9E, 0x17, 0x6F, 0xD8, 0x73, 0x0F, 0x1A, 0x1F, + 0x47, 0x58, 0x44, 0x20, 0x80, 0xC6, 0x5D, 0x6E, + 0xEC, 0xFF, 0xCA, 0x65, 0xA1, 0xFB, 0xEE, 0xF2, + 0x56, 0x1A, 0x16, 0x9E, 0x4D, 0xCA, 0x67, 0x81, + 0x23, 0xDE, 0xBE, 0x5E, 0x31, 0x56, 0xF0, 0x34, + 0xBA, 0x12, 0xFC, 0x07, 0x03, 0x96, 0xD2, 0x8E, + 0xCE, 0xA6, 0xF6, 0x74, 0x07, 0x4F, 0x63, 0x40, + 0x14, 0x0A, 0xD6, 0x45, 0xB4, 0xF1, 0x72, 0x87, + 0x34, 0x89, 0x5C, 0x06, 0x1B, 0x8C, 0x0E, 0xA2, + 0x84, 0x50, 0x12, 0xAD, 0x26, 0x5B, 0x4F, 0x6B, + 0x23, 0x9D, 0x3C, 0xBB, 0x8A, 0xDA, 0x08, 0x4B, + 0x93, 0x47, 0x02, 0x96, 0x76, 0xD4, 0x87, 0xE9, + 0x4B, 0x69, 0x82, 0xD6, 0xCC, 0x69, 0x02, 0xC0, + 0xA4, 0x75, 0x7A, 0x90, 0xFD, 0xF6, 0xD6, 0x9D, + 0xE2, 0x4C, 0xB6, 0xFA, 0x61, 0xA5, 0x7C, 0x18, + 0xEA, 0x84, 0xA1, 0x74, 0x85, 0x2E, 0xCA, 0xF9, + 0x17, 0x29, 0xFF, 0x67, 0x70, 0xC9, 0x6F, 0xF1, + 0x41, 0xEF, 0xA1, 0x59, 0x54, 0xA0, 0x99, 0x14, + 0x48, 0x74, 0x5D, 0x14, 0x3E, 0x04, 0xCE, 0xF7, + 0x16, 0x9F, 0x8A, 0x41, 0xF4, 0xAE, 0xB3, 0x10, + 0xCE, 0x19, 0xC2, 0x83, 0x7B, 0xD0, 0x26, 0x1E, + 0x75, 0x8A, 0x0A, 0x40, 0x4A, 0xB8, 0xE0, 0x5C, + 0x13, 0x8B, 0xCC, 0x6F, 0xF3, 0x00, 0xB3, 0x64, + 0x1B, 0x3C, 0x3D, 0x08, 0x3B, 0x9F, 0xD0, 0x9B, + 0xE5, 0x72, 0x45, 0x96, 0x95, 0x4D, 0x66, 0xC7, + 0x79, 0x5D, 0x3A, 0x1A, 0x94, 0x64, 0x94, 0x07, + 0x1A, 0xE8, 0x7C, 0xD1, 0x1C, 0xB1, 0x7E, 0x32, + 0x28, 0x1A, 0x90, 0x22, 0xD9, 0x86, 0x9B, 0x9C, + 0x9B, 0x0C, 0x04, 0x31, 0x85, 0x10, 0x42, 0x50, + 0x40, 0x11, 0x72, 0xAB, 0x94, 0x0C, 0xAF, 0xC3, + 0x22, 0x1A, 0xC1, 0x31, 0x25, 0x30, 0x23, 0x06, + 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, + 0x09, 0x15, 0x31, 0x16, 0x04, 0x14, 0xFD, 0x78, + 0xA7, 0x70, 0x1F, 0x8A, 0xE9, 0x07, 0xB9, 0xCA, + 0x3C, 0xD1, 0xE8, 0xDC, 0x68, 0xFF, 0x02, 0x61, + 0x29, 0x97, 0x30, 0x31, 0x30, 0x21, 0x30, 0x09, + 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x05, + 0x00, 0x04, 0x14, 0x22, 0x7E, 0x99, 0x10, 0xB3, + 0x99, 0x79, 0xE7, 0x14, 0x7F, 0x91, 0x59, 0x24, + 0x4F, 0x2F, 0xCF, 0xE8, 0x53, 0x1D, 0x0F, 0x04, + 0x08, 0x30, 0x1E, 0x5C, 0xE4, 0x3C, 0x66, 0xDF, + 0xB0, 0x02, 0x02, 0x08, 0x00] +}; + +gTestSuite.doTestWithCertificate( + new Blob([new Uint8Array(testCertInfo.blob)]), + testCertInfo.password, + testCertInfo.nickname, + testCertInfo.usage +); diff --git a/dom/wifi/test/marionette/test_wifi_manage_server_certificate.js b/dom/wifi/test/marionette/test_wifi_manage_server_certificate.js new file mode 100644 index 000000000..dfaf524b2 --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_manage_server_certificate.js @@ -0,0 +1,106 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +// Binary form of test certificate. +var testCertInfo = { + nickname: 'Test Certificate', + password: '', + usage: ['ServerCert'], + blob: [0x30, 0x82, 0x02, 0xae, 0x30, 0x82, 0x02, 0x17, + 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00, + 0x92, 0x49, 0xe2, 0x62, 0x71, 0xf6, 0xc7, 0x92, + 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, + 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, + 0x70, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, + 0x04, 0x06, 0x13, 0x02, 0x54, 0x57, 0x31, 0x0f, + 0x30, 0x0d, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, + 0x06, 0x54, 0x61, 0x69, 0x70, 0x65, 0x69, 0x31, + 0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x04, 0x0a, + 0x0c, 0x07, 0x4d, 0x6f, 0x7a, 0x69, 0x6c, 0x6c, + 0x61, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, + 0x04, 0x0b, 0x0c, 0x02, 0x51, 0x41, 0x31, 0x0e, + 0x30, 0x0c, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, + 0x05, 0x47, 0x65, 0x72, 0x72, 0x79, 0x31, 0x21, + 0x30, 0x1f, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, + 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x12, 0x67, + 0x63, 0x68, 0x61, 0x6e, 0x67, 0x40, 0x6d, 0x6f, + 0x7a, 0x69, 0x6c, 0x6c, 0x61, 0x2e, 0x63, 0x6f, + 0x6d, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x34, 0x30, + 0x35, 0x32, 0x33, 0x30, 0x39, 0x34, 0x32, 0x33, + 0x37, 0x5a, 0x17, 0x0d, 0x31, 0x37, 0x30, 0x35, + 0x32, 0x32, 0x30, 0x39, 0x34, 0x32, 0x33, 0x37, + 0x5a, 0x30, 0x70, 0x31, 0x0b, 0x30, 0x09, 0x06, + 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x54, 0x57, + 0x31, 0x0f, 0x30, 0x0d, 0x06, 0x03, 0x55, 0x04, + 0x08, 0x0c, 0x06, 0x54, 0x61, 0x69, 0x70, 0x65, + 0x69, 0x31, 0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, + 0x04, 0x0a, 0x0c, 0x07, 0x4d, 0x6f, 0x7a, 0x69, + 0x6c, 0x6c, 0x61, 0x31, 0x0b, 0x30, 0x09, 0x06, + 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x02, 0x51, 0x41, + 0x31, 0x0e, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x04, + 0x03, 0x0c, 0x05, 0x47, 0x65, 0x72, 0x72, 0x79, + 0x31, 0x21, 0x30, 0x1f, 0x06, 0x09, 0x2a, 0x86, + 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, + 0x12, 0x67, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x40, + 0x6d, 0x6f, 0x7a, 0x69, 0x6c, 0x6c, 0x61, 0x2e, + 0x63, 0x6f, 0x6d, 0x30, 0x81, 0x9f, 0x30, 0x0d, + 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, + 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x81, 0x8d, + 0x00, 0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, + 0xd3, 0xdb, 0x54, 0xcc, 0xca, 0x0b, 0xee, 0xf9, + 0x8a, 0x37, 0x0d, 0x06, 0x8b, 0x20, 0x00, 0x4a, + 0x55, 0x84, 0x90, 0x1a, 0xb7, 0x9c, 0x91, 0xb2, + 0x38, 0x6b, 0x8b, 0x32, 0x7a, 0x89, 0x9e, 0x79, + 0x71, 0x88, 0x43, 0x21, 0x94, 0x18, 0xa8, 0xfc, + 0xe3, 0x7a, 0x8a, 0xb3, 0xa1, 0xf7, 0x23, 0xe7, + 0x1a, 0xe3, 0xe7, 0x0d, 0xf1, 0x66, 0x21, 0x58, + 0x21, 0x85, 0x5b, 0x35, 0xec, 0x68, 0xd2, 0xfd, + 0x44, 0x76, 0x93, 0x05, 0xbb, 0x89, 0x7d, 0x92, + 0xf9, 0xce, 0x75, 0xa3, 0xeb, 0x39, 0xc1, 0x7d, + 0x7e, 0x50, 0xf9, 0xb8, 0x60, 0x61, 0xf7, 0x2f, + 0x54, 0x39, 0xfe, 0x8a, 0x20, 0xb2, 0x0d, 0x48, + 0x7f, 0x18, 0x0d, 0x02, 0xcc, 0x7b, 0x8e, 0x31, + 0xe9, 0xbe, 0xfc, 0x96, 0x2e, 0x63, 0x6f, 0xfa, + 0x4c, 0xc4, 0xcf, 0x8a, 0xe4, 0x13, 0x67, 0xf1, + 0xec, 0x3e, 0xd8, 0x23, 0xa1, 0xbf, 0x67, 0x71, + 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x50, 0x30, + 0x4e, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, + 0x04, 0x16, 0x04, 0x14, 0x13, 0xe1, 0xac, 0xa4, + 0x75, 0x3d, 0x2c, 0x5f, 0xe5, 0x41, 0x42, 0x90, + 0x5a, 0x48, 0x5c, 0x46, 0xbc, 0x24, 0x8e, 0xa1, + 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, + 0x18, 0x30, 0x16, 0x80, 0x14, 0x13, 0xe1, 0xac, + 0xa4, 0x75, 0x3d, 0x2c, 0x5f, 0xe5, 0x41, 0x42, + 0x90, 0x5a, 0x48, 0x5c, 0x46, 0xbc, 0x24, 0x8e, + 0xa1, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, + 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, + 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, + 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x03, 0x81, + 0x81, 0x00, 0xaa, 0x6b, 0x62, 0x53, 0x74, 0x2a, + 0x20, 0x76, 0xab, 0xd2, 0x60, 0x06, 0xfd, 0x88, + 0xf5, 0x1c, 0x85, 0xe6, 0x57, 0xf1, 0xf0, 0x18, + 0x97, 0x7c, 0x70, 0xb8, 0xb4, 0x7c, 0xcc, 0x58, + 0x8d, 0xf4, 0x7c, 0xb6, 0x34, 0xcc, 0x15, 0x79, + 0xaf, 0x75, 0xa9, 0x0b, 0xd1, 0xea, 0xf8, 0x85, + 0x7c, 0xe8, 0x19, 0xe9, 0x13, 0x90, 0x84, 0x5f, + 0x21, 0x94, 0x0a, 0x4d, 0x15, 0xef, 0xd1, 0x16, + 0xd4, 0xba, 0x2c, 0x59, 0x1b, 0x83, 0x23, 0xf5, + 0xa5, 0xcd, 0xbd, 0xda, 0x32, 0x73, 0x46, 0x49, + 0x98, 0xf3, 0xfb, 0x50, 0x6e, 0x30, 0xd7, 0x3e, + 0x31, 0xd6, 0xe8, 0x65, 0x2f, 0x5a, 0xf1, 0x0f, + 0x7b, 0x0a, 0x21, 0x61, 0x8e, 0x45, 0x29, 0x4f, + 0x7a, 0x04, 0xda, 0x29, 0xfc, 0x6f, 0xc5, 0x5e, + 0xee, 0xe1, 0x0f, 0xd5, 0x4b, 0xb7, 0xc9, 0x6a, + 0x8e, 0x7c, 0x19, 0xef, 0x6e, 0x64, 0x98, 0xfe, + 0xe3, 0x35] +}; + +gTestSuite.doTestWithCertificate( + new Blob([new Uint8Array(testCertInfo.blob)]), + testCertInfo.password, + testCertInfo.nickname, + testCertInfo.usage +); diff --git a/dom/wifi/test/marionette/test_wifi_manage_user_certificate.js b/dom/wifi/test/marionette/test_wifi_manage_user_certificate.js new file mode 100644 index 000000000..950ceae4e --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_manage_user_certificate.js @@ -0,0 +1,34 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +// Binary form of test certificate. +var testCertInfo = { + nickname: 'Test Certificate', + password: '', + usage: ['UserCert'], + blob: '-----BEGIN CERTIFICATE-----\n' + + 'MIICTjCCAbegAwIBAgICNV4wDQYJKoZIhvcNAQEEBQAwgYUxCzAJBgNVBAYTAklU\n' + + 'MRYwFAYDVQQKEw1aZXJvc2hlbGwubmV0MRAwDgYDVQQLEwdFeGFtcGxlMR0wGwYD\n' + + 'VQQDExRaZXJvU2hlbGwgRXhhbXBsZSBDQTEtMCsGCSqGSIb3DQEJARYeRnVsdmlv\n' + + 'LlJpY2NpYXJkaUB6ZXJvc2hlbGwubmV0MB4XDTEzMDMxMTAzMzg1MloXDTE0MDMx\n' + + 'MTAzMzg1MlowIzEOMAwGA1UECxMFVXNlcnMxETAPBgNVBAMTCGNodWNrbGVlMIGf\n' + + 'MA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDvVzFhQAVqAIHW5DlAhp4FEGEei7k7\n' + + 'uVUeqkH7JAsww6zmDLg9yZlcZAc95N0lkz022gLXehH2M0R1FOR++nkqofzWfc7w\n' + + 'n79ith+dU2GQMeKq7vPGDYXpgIkEKbYfzKj3fY3129MlTxJQt1UD/ejz38V8HKgw\n' + + 'qKSuwo0NVeY66QIDAQABoy4wLDALBgNVHQ8EBAMCBLAwHQYDVR0lBBYwFAYIKwYB\n' + + 'BQUHAwIGCCsGAQUFBwMEMA0GCSqGSIb3DQEBBAUAA4GBAJWgfX5vYSD7MGZk1rTF\n' + + 'DSziWYGqpR+Moo3qQ+9qLG8m+XVM9hckWpY31A5sWAeCZCe1SSNLFbbgsaOyPZE2\n' + + 'NqMyvs61Vszpc2mmWAYT6j2OU2tw8p5pcUZd6eIp7Gc3fLymiX/WoSmilZKmrGUZ\n' + + 'Q15R+TCpclUsaNrUGjybgaw7\n' + + '-----END CERTIFICATE-----' +}; + +gTestSuite.doTestWithCertificate( + new Blob([testCertInfo.blob]), + testCertInfo.password, + testCertInfo.nickname, + testCertInfo.usage +); diff --git a/dom/wifi/test/marionette/test_wifi_scan.js b/dom/wifi/test/marionette/test_wifi_scan.js new file mode 100644 index 000000000..4bb7d1a3d --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_scan.js @@ -0,0 +1,43 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +const SCAN_RETRY_CNT = 5; + +/** + * Test scan with no AP present. + * + * The precondition is: + * 1) Wifi is enabled. + * 2) All the hostapds are turned off. + * + * @return deferred promise. + */ +function testScanNoAp() { + return gTestSuite.testWifiScanWithRetry(SCAN_RETRY_CNT, []); +} + +/** + * Test scan with APs present. + * + * The precondition is: + * 1) Wifi is enabled. + * 2) All the hostapds are turned off. + * + * @return deferred promise. + */ +function testScanWithAps() { + return gTestSuite.startHostapds(HOSTAPD_CONFIG_LIST) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', HOSTAPD_CONFIG_LIST.length)) + .then(() => gTestSuite.testWifiScanWithRetry(SCAN_RETRY_CNT, HOSTAPD_CONFIG_LIST)) + .then(gTestSuite.killAllHostapd) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', 0)); +} + +gTestSuite.doTestWithoutStockAp(function() { + return gTestSuite.ensureWifiEnabled(true) + .then(testScanNoAp) + .then(testScanWithAps); +}); diff --git a/dom/wifi/test/marionette/test_wifi_static_ip.js b/dom/wifi/test/marionette/test_wifi_static_ip.js new file mode 100644 index 000000000..90436b6fe --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_static_ip.js @@ -0,0 +1,65 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +const STATIC_IP_CONFIG = { + enabled: true, + ipaddr: "192.168.111.222", + proxy: "", + maskLength: 24, + gateway: "192.168.111.1", + dns1: "8.8.8.8", + dns2: "8.8.4.4", +}; + +const TESTING_HOSTAPD = [{ ssid: 'ap0' }]; + +function testAssociateWithStaticIp(aNetwork, aStaticIpConfig) { + return gTestSuite.setStaticIpMode(aNetwork, aStaticIpConfig) + .then(() => gTestSuite.testAssociate(aNetwork)) + // Check ip address and prefix. + .then(() => gTestSuite.exeAndParseNetcfg()) + .then((aResult) => { + is(aResult["wlan0"].ip, aStaticIpConfig.ipaddr, "Check ip address"); + is(aResult["wlan0"].prefix, aStaticIpConfig.maskLength, "Check prefix"); + }) + // Check routing. + .then(() => gTestSuite.exeAndParseIpRoute()) + .then((aResult) => { + is(aResult["wlan0"].src, aStaticIpConfig.ipaddr, "Check ip address"); + is(aResult["wlan0"].default, true, "Check default route"); + is(aResult["wlan0"].gateway, aStaticIpConfig.gateway, "Check gateway"); + }); +} + +function findDesireNetwork(aNetworks) { + let i = gTestSuite.getFirstIndexBySsid(TESTING_HOSTAPD[0].ssid, aNetworks); + + if (-1 !== i) { + return aNetworks[i]; + } + + return aNetworks[0]; +} + +// Start test. +gTestSuite.doTestWithoutStockAp(function() { + return gTestSuite.ensureWifiEnabled(true) + + // Start custom hostapd for testing. + .then(() => gTestSuite.startHostapds(TESTING_HOSTAPD)) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', + TESTING_HOSTAPD.length)) + + // Perform a wifi scan, and then run the static ip test + .then(() => gTestSuite.requestWifiScan()) + .then((aNetworks) => findDesireNetwork(aNetworks)) + .then((aNetwork) => testAssociateWithStaticIp(aNetwork, + STATIC_IP_CONFIG)) + + // Kill running hostapd. + .then(gTestSuite.killAllHostapd) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', 0)); +}); diff --git a/dom/wifi/test/marionette/test_wifi_tethering_wifi_active.js b/dom/wifi/test/marionette/test_wifi_tethering_wifi_active.js new file mode 100644 index 000000000..af0df01a0 --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_tethering_wifi_active.js @@ -0,0 +1,74 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +const TESTING_HOSTAPD = [{ ssid: 'ap0' }]; + +function connectToFirstNetwork() { + let firstNetwork; + return gTestSuite.requestWifiScan() + .then(function (networks) { + firstNetwork = networks[0]; + return gTestSuite.testAssociate(firstNetwork); + }) + .then(() => firstNetwork); +} + +gTestSuite.doTestTethering(function() { + let firstNetwork; + + return gTestSuite.ensureWifiEnabled(true) + // Start custom hostapd for testing. + .then(() => gTestSuite.startHostapds(TESTING_HOSTAPD)) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', TESTING_HOSTAPD.length)) + + // Connect to the testing AP and wait for data becoming disconnected. + .then(function () { + return Promise.all([ + // 1) Set up the event listener first: + // RIL data should become disconnected after connecting to wifi. + gTestSuite.waitForRilDataConnected(false), + + // 2) Connect to the first scanned network. + connectToFirstNetwork() + .then(aFirstNetwork => firstNetwork = aFirstNetwork) + ]); + }) + .then(function() { + return Promise.all([ + // 1) Set up the event listeners first: + // Wifi should be turned off and RIL data should be connected. + gTestSuite.waitForWifiManagerEventOnce('disabled'), + gTestSuite.waitForRilDataConnected(true), + + // 2) Start wifi tethering. + gTestSuite.requestTetheringEnabled(true) + ]); + }) + .then(function() { + return Promise.all([ + // 1) Set up the event listeners first: + // Wifi should be enabled, RIL data should become disconnected and + // we should connect to an wifi AP. + gTestSuite.waitForWifiManagerEventOnce('enabled'), + + // Due to Bug 1168285, after re-enablin wifi, the remembered network + // will not be connected automatically. Leave "auto connect test" + // covered by test_wifi_auto_connect.js. + //gTestSuite.waitForRilDataConnected(false), + //gTestSuite.waitForConnected(firstNetwork), + + // 2) Stop wifi tethering. + gTestSuite.requestTetheringEnabled(false) + ]); + }) + // Remove wlan0 from default route by disabling wifi. Otherwise, + // it will cause the subsequent test cases loading page error. + .then(() => gTestSuite.requestWifiEnabled(false)) + + // Kill running hostapd. + .then(gTestSuite.killAllHostapd) + .then(() => gTestSuite.verifyNumOfProcesses('hostapd', 0)); +});
\ No newline at end of file diff --git a/dom/wifi/test/marionette/test_wifi_tethering_wifi_disabled.js b/dom/wifi/test/marionette/test_wifi_tethering_wifi_disabled.js new file mode 100644 index 000000000..860a91cf6 --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_tethering_wifi_disabled.js @@ -0,0 +1,11 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +gTestSuite.doTestTethering(function() { + return gTestSuite.ensureWifiEnabled(false) + .then(() => gTestSuite.requestTetheringEnabled(true)) + .then(() => gTestSuite.requestTetheringEnabled(false)) +}); diff --git a/dom/wifi/test/marionette/test_wifi_tethering_wifi_inactive.js b/dom/wifi/test/marionette/test_wifi_tethering_wifi_inactive.js new file mode 100644 index 000000000..2de6ab667 --- /dev/null +++ b/dom/wifi/test/marionette/test_wifi_tethering_wifi_inactive.js @@ -0,0 +1,21 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +MARIONETTE_TIMEOUT = 60000; +MARIONETTE_HEAD_JS = 'head.js'; + +gTestSuite.doTestTethering(function() { + return gTestSuite.ensureWifiEnabled(true) + .then(function() { + return Promise.all([ + gTestSuite.waitForWifiManagerEventOnce('disabled'), + gTestSuite.requestTetheringEnabled(true) + ]); + }) + .then(function() { + return Promise.all([ + gTestSuite.waitForWifiManagerEventOnce('enabled'), + gTestSuite.requestTetheringEnabled(false) + ]); + }); +}); |