The Tor Browser: dom/system/NetworkGeolocationProvider.js@b8a032363ba2 (annotated)

dom/system/NetworkGeolocationProvider.js@b8a032363ba2 (annotated)

dom/system/NetworkGeolocationProvider.js

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rwxr-xr-x

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

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