The Tor Browser: comparison dom/system/NetworkGeolocationProvider.js

comparison: dom/system/NetworkGeolocationProvider.js

dom/system/NetworkGeolocationProvider.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:1a4de5979062
+/* 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/. */
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+const Ci = Components.interfaces;
+const Cc = Components.classes;
+const POSITION_UNAVAILABLE = Ci.nsIDOMGeoPositionError.POSITION_UNAVAILABLE;
+const SETTING_DEBUG_ENABLED = "geolocation.debugging.enabled";
+const SETTING_CHANGED_TOPIC = "mozsettings-changed";
+let gLoggingEnabled = false;
+// if we don't see any wifi responses in 5 seconds, send the request.
+let gTimeToWaitBeforeSending = 5000; //ms
+let gWifiScanningEnabled = true;
+let gWifiResults;
+let gCellScanningEnabled = false;
+let gCellResults;
+function LOG(aMsg) {
+if (gLoggingEnabled) {
+aMsg = "*** WIFI GEO: " + aMsg + "\n";
+Cc["@mozilla.org/consoleservice;1"].getService(Ci.nsIConsoleService).logStringMessage(aMsg);
+dump(aMsg);
+}
+}
+function CachedRequest(loc, cellInfo, wifiList) {
+this.location = loc;
+let wifis = new Set();
+if (wifiList) {
+for (let i = 0; i < wifiList.length; i++) {
+wifis.add(wifiList[i].macAddress);
+}
+}
+// Use only these values for equality
+// (the JSON will contain additional values in future)
+function makeCellKey(cell) {
+return "" + cell.radio + ":" + cell.mobileCountryCode + ":" +
+cell.mobileNetworkCode + ":" + cell.locationAreaCode + ":" +
+cell.cellId;
+}
+let cells = new Set();
+if (cellInfo) {
+for (let i = 0; i < cellInfo.length; i++) {
+cells.add(makeCellKey(cellInfo[i]));
+}
+}
+this.hasCells = () => cells.size > 0;
+this.hasWifis = () => wifis.size > 0;
+// if fields match
+this.isCellEqual = function(cellInfo) {
+if (!this.hasCells()) {
+return false;
+}
+let len1 = cells.size;
+let len2 = cellInfo.length;
+if (len1 != len2) {
+LOG("cells not equal len");
+return false;
+}
+for (let i = 0; i < len2; i++) {
+if (!cells.has(makeCellKey(cellInfo[i]))) {
+return false;
+}
+}
+return true;
+};
+// if 50% of the SSIDS match
+this.isWifiApproxEqual = function(wifiList) {
+if (!this.hasWifis()) {
+return false;
+}
+// if either list is a 50% subset of the other, they are equal
+let common = 0;
+for (let i = 0; i < wifiList.length; i++) {
+if (wifis.has(wifiList[i].macAddress)) {
+common++;
+}
+}
+let kPercentMatch = 0.5;
+return common >= (Math.max(wifis.size, wifiList.length) * kPercentMatch);
+};
+this.isGeoip = function() {
+return !this.hasCells() && !this.hasWifis();
+};
+this.isCellAndWifi = function() {
+return this.hasCells() && this.hasWifis();
+};
+this.isCellOnly = function() {
+return this.hasCells() && !this.hasWifis();
+};
+this.isWifiOnly = function() {
+return this.hasWifis() && !this.hasCells();
+};
+}
+let gCachedRequest = null;
+let gDebugCacheReasoning = ""; // for logging the caching logic
+// This function serves two purposes:
+// 1) do we have a cached request
+// 2) is the cached request better than what newCell and newWifiList will obtain
+// If the cached request exists, and we know it to have greater accuracy
+// by the nature of its origin (wifi/cell/geoip), use its cached location.
+//
+// If there is more source info than the cached request had, return false
+// In other cases, MLS is known to produce better/worse accuracy based on the
+// inputs, so base the decision on that.
+function isCachedRequestMoreAccurateThanServerRequest(newCell, newWifiList)
+{
+gDebugCacheReasoning = "";
+let isNetworkRequestCacheEnabled = true;
+try {
+// Mochitest needs this pref to simulate request failure
+isNetworkRequestCacheEnabled = Services.prefs.getBoolPref("geo.wifi.debug.requestCache.enabled");
+if (!isNetworkRequestCacheEnabled) {
+gCachedRequest = null;
+}
+} catch (e) {}
+if (!gCachedRequest || !isNetworkRequestCacheEnabled) {
+gDebugCacheReasoning = "No cached data";
+return false;
+}
+if (!newCell && !newWifiList) {
+gDebugCacheReasoning = "New req. is GeoIP.";
+return true;
+}
+if (newCell && newWifiList && (gCachedRequest.isCellOnly() || gCachedRequest.isWifiOnly())) {
+gDebugCacheReasoning = "New req. is cell+wifi, cache only cell or wifi.";
+return false;
+}
+if (newCell && gCachedRequest.isWifiOnly()) {
+// In order to know if a cell-only request should trump a wifi-only request
+// need to know if wifi is low accuracy. >5km would be VERY low accuracy,
+// it is worth trying the cell
+var isHighAccuracyWifi = gCachedRequest.location.coords.accuracy < 5000;
+gDebugCacheReasoning = "Req. is cell, cache is wifi, isHigh:" + isHighAccuracyWifi;
+return isHighAccuracyWifi;
+}
+let hasEqualCells = false;
+if (newCell) {
+hasEqualCells = gCachedRequest.isCellEqual(newCell);
+}
+let hasEqualWifis = false;
+if (newWifiList) {
+hasEqualWifis = gCachedRequest.isWifiApproxEqual(newWifiList);
+}
+gDebugCacheReasoning = "EqualCells:" + hasEqualCells + " EqualWifis:" + hasEqualWifis;
+if (gCachedRequest.isCellOnly()) {
+gDebugCacheReasoning += ", Cell only.";
+if (hasEqualCells) {
+return true;
+}
+} else if (gCachedRequest.isWifiOnly() && hasEqualWifis) {
+gDebugCacheReasoning +=", Wifi only."
+return true;
+} else if (gCachedRequest.isCellAndWifi()) {
+gDebugCacheReasoning += ", Cache has Cell+Wifi.";
+if ((hasEqualCells && hasEqualWifis) ||
+(!newWifiList && hasEqualCells) ||
+(!newCell && hasEqualWifis))
+{
+return true;
+}
+}
+return false;
+}
+function WifiGeoCoordsObject(lat, lon, acc, alt, altacc) {
+this.latitude = lat;
+this.longitude = lon;
+this.accuracy = acc;
+this.altitude = alt;
+this.altitudeAccuracy = altacc;
+}
+WifiGeoCoordsObject.prototype = {
+QueryInterface:  XPCOMUtils.generateQI([Ci.nsIDOMGeoPositionCoords])
+};
+function WifiGeoPositionObject(lat, lng, acc) {
+this.coords = new WifiGeoCoordsObject(lat, lng, acc, 0, 0);
+this.address = null;
+this.timestamp = Date.now();
+}
+WifiGeoPositionObject.prototype = {
+QueryInterface:   XPCOMUtils.generateQI([Ci.nsIDOMGeoPosition])
+};
+function WifiGeoPositionProvider() {
+try {
+gLoggingEnabled = Services.prefs.getBoolPref("geo.wifi.logging.enabled");
+} catch (e) {}
+try {
+gTimeToWaitBeforeSending = Services.prefs.getIntPref("geo.wifi.timeToWaitBeforeSending");
+} catch (e) {}
+try {
+gWifiScanningEnabled = Services.prefs.getBoolPref("geo.wifi.scan");
+} catch (e) {}
+try {
+gCellScanningEnabled = Services.prefs.getBoolPref("geo.cell.scan");
+} catch (e) {}
+this.wifiService = null;
+this.timeoutTimer = null;
+this.started = false;
+}
+WifiGeoPositionProvider.prototype = {
+classID:          Components.ID("{77DA64D3-7458-4920-9491-86CC9914F904}"),
+QueryInterface:   XPCOMUtils.generateQI([Ci.nsIGeolocationProvider,
+Ci.nsIWifiListener,
+Ci.nsITimerCallback,
+Ci.nsIObserver]),
+listener: null,
+observe: function(aSubject, aTopic, aData) {
+if (aTopic != SETTING_CHANGED_TOPIC) {
+return;
+}
+try {
+let setting = JSON.parse(aData);
+if (setting.key != SETTING_DEBUG_ENABLED) {
+return;
+}
+gLoggingEnabled = setting.value;
+} catch (e) {
+}
+},
+startup:  function() {
+if (this.started)
+return;
+this.started = true;
+let settingsCallback = {
+handle: function(name, result) {
+gLoggingEnabled = result && result.value === true ? true : false;
+},
+handleError: function(message) {
+gLoggingEnabled = false;
+LOG("settings callback threw an exception, dropping");
+}
+};
+try {
+Services.obs.addObserver(this, SETTING_CHANGED_TOPIC, false);
+let settings = Cc["@mozilla.org/settingsService;1"].getService(Ci.nsISettingsService);
+settings.createLock().get(SETTING_DEBUG_ENABLED, settingsCallback);
+} catch(ex) {
+// This platform doesn't have the settings interface, and that is just peachy
+}
+if (gWifiScanningEnabled) {
+this.wifiService = Cc["@mozilla.org/wifi/monitor;1"].getService(Components.interfaces.nsIWifiMonitor);
+this.wifiService.startWatching(this);
+}
+this.timeoutTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+this.timeoutTimer.initWithCallback(this,
+gTimeToWaitBeforeSending,
+this.timeoutTimer.TYPE_REPEATING_SLACK);
+LOG("startup called.");
+},
+watch: function(c) {
+this.listener = c;
+},
+shutdown: function() {
+LOG("shutdown called");
+if (this.started == false) {
+return;
+}
+// Without clearing this, we could end up using the cache almost indefinitely
+// TODO: add logic for cache lifespan, for now just be safe and clear it
+gCachedRequest = null;
+if (this.timeoutTimer) {
+this.timeoutTimer.cancel();
+this.timeoutTimer = null;
+}
+if(this.wifiService) {
+this.wifiService.stopWatching(this);
+this.wifiService = null;
+}
+Services.obs.removeObserver(this, SETTING_CHANGED_TOPIC);
+this.listener = null;
+this.started = false;
+},
+setHighAccuracy: function(enable) {
+},
+onChange: function(accessPoints) {
+function isPublic(ap) {
+let mask = "_nomap"
+let result = ap.ssid.indexOf(mask, ap.ssid.length - mask.length);
+if (result != -1) {
+LOG("Filtering out " + ap.ssid + " " + result);
+}
+return result;
+};
+function sort(a, b) {
+return b.signal - a.signal;
+};
+function encode(ap) {
+return { 'macAddress': ap.mac, 'signalStrength': ap.signal };
+};
+if (accessPoints) {
+gWifiResults = accessPoints.filter(isPublic).sort(sort).map(encode);
+} else {
+gWifiResults = null;
+}
+},
+onError: function (code) {
+LOG("wifi error: " + code);
+},
+updateMobileInfo: function() {
+LOG("updateMobileInfo called");
+try {
+let radio = Cc["@mozilla.org/ril;1"]
+.getService(Ci.nsIRadioInterfaceLayer)
+.getRadioInterface(0);
+let iccInfo = radio.rilContext.iccInfo;
+let cell = radio.rilContext.voice.cell;
+LOG("mcc: " + iccInfo.mcc);
+LOG("mnc: " + iccInfo.mnc);
+LOG("cid: " + cell.gsmCellId);
+LOG("lac: " + cell.gsmLocationAreaCode);
+gCellResults = [{
+"radio": "gsm",
+"mobileCountryCode": iccInfo.mcc,
+"mobileNetworkCode": iccInfo.mnc,
+"locationAreaCode": cell.gsmLocationAreaCode,
+"cellId": cell.gsmCellId,
+}];
+} catch (e) {
+gCellResults = null;
+}
+},
+notify: function (timeoutTimer) {
+let data = {};
+if (gWifiResults) {
+data.wifiAccessPoints = gWifiResults;
+}
+if (gCellScanningEnabled) {
+this.updateMobileInfo();
+}
+if (gCellResults && gCellResults.length > 0) {
+data.cellTowers = gCellResults;
+}
+let useCached = isCachedRequestMoreAccurateThanServerRequest(data.cellTowers,
+data.wifiAccessPoints);
+LOG("Use request cache:" + useCached + " reason:" + gDebugCacheReasoning);
+if (useCached) {
+gCachedRequest.location.timestamp = Date.now();
+this.listener.update(gCachedRequest.location);
+return;
+}
+// From here on, do a network geolocation request //
+let url = Services.urlFormatter.formatURLPref("geo.wifi.uri");
+let listener = this.listener;
+LOG("Sending request: " + url + "\n");
+let xhr = Components.classes["@mozilla.org/xmlextras/xmlhttprequest;1"]
+.createInstance(Ci.nsIXMLHttpRequest);
+listener.locationUpdatePending();
+try {
+xhr.open("POST", url, true);
+} catch (e) {
+listener.notifyError(POSITION_UNAVAILABLE);
+return;
+}
+xhr.setRequestHeader("Content-Type", "application/json; charset=UTF-8");
+xhr.responseType = "json";
+xhr.mozBackgroundRequest = true;
+xhr.channel.loadFlags = Ci.nsIChannel.LOAD_ANONYMOUS;
+xhr.onerror = function() {
+listener.notifyError(POSITION_UNAVAILABLE);
+};
+xhr.onload = function() {
+LOG("gls returned status: " + xhr.status + " --> " +  JSON.stringify(xhr.response));
+if ((xhr.channel instanceof Ci.nsIHttpChannel && xhr.status != 200) ||
+!xhr.response || !xhr.response.location) {
+listener.notifyError(POSITION_UNAVAILABLE);
+return;
+}
+let newLocation = new WifiGeoPositionObject(xhr.response.location.lat,
+xhr.response.location.lng,
+xhr.response.accuracy);
+listener.update(newLocation);
+gCachedRequest = new CachedRequest(newLocation, data.cellTowers, data.wifiAccessPoints);
+};
+var requestData = JSON.stringify(data);
+gWifiResults = gCellResults = null;
+LOG("sending " + requestData);
+xhr.send(requestData);
+},
+};
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([WifiGeoPositionProvider]);