The Tor Browser / file revision

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