The Tor Browser: toolkit/components/url-classifier/content/listmanager.js@6474c204b198 (annotated)

toolkit/components/url-classifier/content/listmanager.js@6474c204b198 (annotated)

toolkit/components/url-classifier/content/listmanager.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 # 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/.
 // This is the only implementation of nsIUrlListManager.
 // A class that manages lists, namely white and black lists for
 // phishing or malware protection. The ListManager knows how to fetch,
 // update, and store lists.
 //
 // There is a single listmanager for the whole application.
 //
 // TODO more comprehensive update tests, for example add unittest check
 //      that the listmanagers tables are properly written on updates
 function QueryAdapter(callback) {
   this.callback_ = callback;
 };
 QueryAdapter.prototype.handleResponse = function(value) {
   this.callback_.handleEvent(value);
 }
 /**
  * A ListManager keeps track of black and white lists and knows
  * how to update them.
  *
  * @constructor
  */
 function PROT_ListManager() {
   this.debugZone = "listmanager";
   G_debugService.enableZone(this.debugZone);
   this.currentUpdateChecker_ = null;   // set when we toggle updates
   this.prefs_ = new G_Preferences();
   this.updateInterval = this.prefs_.getPref("urlclassifier.updateinterval", 30 * 60) * 1000;
   this.updateserverURL_ = null;
   this.gethashURL_ = null;
   this.isTesting_ = false;
   this.tablesData = {};
   this.observerServiceObserver_ = new G_ObserverServiceObserver(
                                           'quit-application',
                                           BindToObject(this.shutdown_, this),
                                           true /*only once*/);
   this.cookieObserver_ = new G_ObserverServiceObserver(
                                           'cookie-changed',
                                           BindToObject(this.cookieChanged_, this),
                                           false);
   /* Backoff interval should be between 30 and 60 minutes. */
   var backoffInterval = 30 * 60 * 1000;
   backoffInterval += Math.floor(Math.random() * (30 * 60 * 1000));
   this.requestBackoff_ = new RequestBackoff(2 /* max errors */,
 *1000 /* retry interval, 1 min */,
 /* num requests */,
 *60*1000 /* request time, 60 min */,
                               backoffInterval /* backoff interval, 60 min */,
 *60*60*1000 /* max backoff, 8hr */);
   this.dbService_ = Cc["@mozilla.org/url-classifier/dbservice;1"]
                    .getService(Ci.nsIUrlClassifierDBService);
   this.hashCompleter_ = Cc["@mozilla.org/url-classifier/hashcompleter;1"]
                         .getService(Ci.nsIUrlClassifierHashCompleter);
 }
 /**
  * xpcom-shutdown callback
  * Delete all of our data tables which seem to leak otherwise.
  */
 PROT_ListManager.prototype.shutdown_ = function() {
   for (var name in this.tablesData) {
     delete this.tablesData[name];
   }
 }
 /**
  * Set the url we check for updates.  If the new url is valid and different,
  * update our table list.
  *
  * After setting the update url, the caller is responsible for registering
  * tables and then toggling update checking.  All the code for this logic is
  * currently in browser/components/safebrowsing.  Maybe it should be part of
  * the listmanger?
  */
 PROT_ListManager.prototype.setUpdateUrl = function(url) {
   G_Debug(this, "Set update url: " + url);
   if (url != this.updateserverURL_) {
     this.updateserverURL_ = url;
     this.requestBackoff_.reset();
     // Remove old tables which probably aren't valid for the new provider.
     for (var name in this.tablesData) {
       delete this.tablesData[name];
     }
   }
 }
 /**
  * Set the gethash url.
  */
 PROT_ListManager.prototype.setGethashUrl = function(url) {
   G_Debug(this, "Set gethash url: " + url);
   if (url != this.gethashURL_) {
     this.gethashURL_ = url;
     this.hashCompleter_.gethashUrl = url;
   }
 }
 /**
  * Register a new table table
  * @param tableName - the name of the table
  * @param opt_requireMac true if a mac is required on update, false otherwise
  * @returns true if the table could be created; false otherwise
  */
 PROT_ListManager.prototype.registerTable = function(tableName,
                                                     opt_requireMac) {
   this.tablesData[tableName] = {};
   this.tablesData[tableName].needsUpdate = false;
   return true;
 }
 /**
  * Enable updates for some tables
  * @param tables - an array of table names that need updating
  */
 PROT_ListManager.prototype.enableUpdate = function(tableName) {
   var changed = false;
   var table = this.tablesData[tableName];
   if (table) {
     G_Debug(this, "Enabling table updates for " + tableName);
     table.needsUpdate = true;
     changed = true;
   }
   if (changed === true)
     this.maybeToggleUpdateChecking();
 }
 /**
  * Disables updates for some tables
  * @param tables - an array of table names that no longer need updating
  */
 PROT_ListManager.prototype.disableUpdate = function(tableName) {
   var changed = false;
   var table = this.tablesData[tableName];
   if (table) {
     G_Debug(this, "Disabling table updates for " + tableName);
     table.needsUpdate = false;
     changed = true;
   }
   if (changed === true)
     this.maybeToggleUpdateChecking();
 }
 /**
  * Determine if we have some tables that need updating.
  */
 PROT_ListManager.prototype.requireTableUpdates = function() {
   for (var type in this.tablesData) {
     // Tables that need updating even if other tables dont require it
     if (this.tablesData[type].needsUpdate)
       return true;
   }
   return false;
 }
 /**
  * Start managing the lists we know about. We don't do this automatically
  * when the listmanager is instantiated because their profile directory
  * (where we store the lists) might not be available.
  */
 PROT_ListManager.prototype.maybeStartManagingUpdates = function() {
   if (this.isTesting_)
     return;
   // We might have been told about tables already, so see if we should be
   // actually updating.
   this.maybeToggleUpdateChecking();
 }
 /**
  * Acts as a nsIUrlClassifierCallback for getTables.
  */
 PROT_ListManager.prototype.kickoffUpdate_ = function (onDiskTableData)
 {
   this.startingUpdate_ = false;
   var initialUpdateDelay = 3000;
   // Check if any table registered for updates has ever been downloaded.
   var diskTablesAreUpdating = false;
   for (var tableName in this.tablesData) {
     if (this.tablesData[tableName].needsUpdate) {
       if (onDiskTableData.indexOf(tableName) != -1) {
         diskTablesAreUpdating = true;
       }
     }
   }
   // If the user has never downloaded tables, do the check now.
   // If the user has tables, add a fuzz of a few minutes.
   if (diskTablesAreUpdating) {
     // Add a fuzz of 0-5 minutes.
     initialUpdateDelay += Math.floor(Math.random() * (5 * 60 * 1000));
   }
   this.currentUpdateChecker_ =
     new G_Alarm(BindToObject(this.checkForUpdates, this),
                 initialUpdateDelay);
 }
 /**
  * Determine if we have any tables that require updating.  Different
  * Wardens may call us with new tables that need to be updated.
  */
 PROT_ListManager.prototype.maybeToggleUpdateChecking = function() {
   // If we are testing or dont have an application directory yet, we should
   // not start reading tables from disk or schedule remote updates
   if (this.isTesting_)
     return;
   // We update tables if we have some tables that want updates.  If there
   // are no tables that want to be updated - we dont need to check anything.
   if (this.requireTableUpdates() === true) {
     G_Debug(this, "Starting managing lists");
     this.startUpdateChecker();
     // Multiple warden can ask us to reenable updates at the same time, but we
     // really just need to schedule a single update.
     if (!this.currentUpdateChecker && !this.startingUpdate_) {
       this.startingUpdate_ = true;
       // check the current state of tables in the database
       this.dbService_.getTables(BindToObject(this.kickoffUpdate_, this));
     }
   } else {
     G_Debug(this, "Stopping managing lists (if currently active)");
     this.stopUpdateChecker();                    // Cancel pending updates
   }
 }
 /**
  * Start periodic checks for updates. Idempotent.
  * We want to distribute update checks evenly across the update period (an
  * hour).  The first update is scheduled for a random time between 0.5 and 1.5
  * times the update interval.
  */
 PROT_ListManager.prototype.startUpdateChecker = function() {
   this.stopUpdateChecker();
   // Schedule the first check for between 15 and 45 minutes.
   var repeatingUpdateDelay = this.updateInterval / 2;
   repeatingUpdateDelay += Math.floor(Math.random() * this.updateInterval);
   this.updateChecker_ = new G_Alarm(BindToObject(this.initialUpdateCheck_,
                                                  this),
                                     repeatingUpdateDelay);
 }
 /**
  * Callback for the first update check.
  * We go ahead and check for table updates, then start a regular timer (once
  * every update interval).
  */
 PROT_ListManager.prototype.initialUpdateCheck_ = function() {
   this.checkForUpdates();
   this.updateChecker_ = new G_Alarm(BindToObject(this.checkForUpdates, this),
                                     this.updateInterval, true /* repeat */);
 }
 /**
  * Stop checking for updates. Idempotent.
  */
 PROT_ListManager.prototype.stopUpdateChecker = function() {
   if (this.updateChecker_) {
     this.updateChecker_.cancel();
     this.updateChecker_ = null;
   }
   // Cancel the oneoff check from maybeToggleUpdateChecking.
   if (this.currentUpdateChecker_) {
     this.currentUpdateChecker_.cancel();
     this.currentUpdateChecker_ = null;
   }
 }
 /**
  * Provides an exception free way to look up the data in a table. We
  * use this because at certain points our tables might not be loaded,
  * and querying them could throw.
  *
  * @param table String Name of the table that we want to consult
  * @param key Principal being used to lookup the database
  * @param callback nsIUrlListManagerCallback (ie., Function) given false or the
  *        value in the table corresponding to key.  If the table name does not
  *        exist, we return false, too.
  */
 PROT_ListManager.prototype.safeLookup = function(key, callback) {
   try {
     G_Debug(this, "safeLookup: " + key);
     var cb = new QueryAdapter(callback);
     this.dbService_.lookup(key,
                            BindToObject(cb.handleResponse, cb),
                            true);
   } catch(e) {
     G_Debug(this, "safeLookup masked failure for key " + key + ": " + e);
     callback.handleEvent("");
   }
 }
 /**
  * Updates our internal tables from the update server
  *
  * @returns true when a new request was scheduled, false if an old request
  *          was still pending.
  */
 PROT_ListManager.prototype.checkForUpdates = function() {
   // Allow new updates to be scheduled from maybeToggleUpdateChecking()
   this.currentUpdateChecker_ = null;
   if (!this.updateserverURL_) {
     G_Debug(this, 'checkForUpdates: no update server url');
     return false;
   }
   // See if we've triggered the request backoff logic.
   if (!this.requestBackoff_.canMakeRequest())
     return false;
   // Grab the current state of the tables from the database
   this.dbService_.getTables(BindToObject(this.makeUpdateRequest_, this));
   return true;
 }
 /**
  * Method that fires the actual HTTP update request.
  * First we reset any tables that have disappeared.
  * @param tableData List of table data already in the database, in the form
  *        tablename;<chunk ranges>\n
  */
 PROT_ListManager.prototype.makeUpdateRequest_ = function(tableData) {
   var tableList;
   var tableNames = {};
   for (var tableName in this.tablesData) {
     if (this.tablesData[tableName].needsUpdate)
       tableNames[tableName] = true;
     if (!tableList) {
       tableList = tableName;
     } else {
       tableList += "," + tableName;
     }
   }
   var request = "";
   // For each table already in the database, include the chunk data from
   // the database
   var lines = tableData.split("\n");
   for (var i = 0; i < lines.length; i++) {
     var fields = lines[i].split(";");
     if (tableNames[fields[0]]) {
       request += lines[i] + "\n";
       delete tableNames[fields[0]];
     }
   }
   // For each requested table that didn't have chunk data in the database,
   // request it fresh
   for (var tableName in tableNames) {
     request += tableName + ";\n";
   }
   G_Debug(this, 'checkForUpdates: scheduling request..');
   var streamer = Cc["@mozilla.org/url-classifier/streamupdater;1"]
                  .getService(Ci.nsIUrlClassifierStreamUpdater);
   try {
     streamer.updateUrl = this.updateserverURL_;
   } catch (e) {
     G_Debug(this, 'invalid url');
     return;
   }
   this.requestBackoff_.noteRequest();
   if (!streamer.downloadUpdates(tableList,
                                 request,
                                 BindToObject(this.updateSuccess_, this),
                                 BindToObject(this.updateError_, this),
                                 BindToObject(this.downloadError_, this))) {
     G_Debug(this, "pending update, wait until later");
   }
 }
 /**
  * Callback function if the update request succeeded.
  * @param waitForUpdate String The number of seconds that the client should
  *        wait before requesting again.
  */
 PROT_ListManager.prototype.updateSuccess_ = function(waitForUpdate) {
   G_Debug(this, "update success: " + waitForUpdate);
   if (waitForUpdate) {
     var delay = parseInt(waitForUpdate, 10);
     // As long as the delay is something sane (5 minutes or more), update
     // our delay time for requesting updates
     if (delay >= (5 * 60) && this.updateChecker_)
       this.updateChecker_.setDelay(delay * 1000);
   }
   // Let the backoff object know that we completed successfully.
   this.requestBackoff_.noteServerResponse(200);
 }
 /**
  * Callback function if the update request succeeded.
  * @param result String The error code of the failure
  */
 PROT_ListManager.prototype.updateError_ = function(result) {
   G_Debug(this, "update error: " + result);
   // XXX: there was some trouble applying the updates.
 }
 /**
  * Callback function when the download failed
  * @param status String http status or an empty string if connection refused.
  */
 PROT_ListManager.prototype.downloadError_ = function(status) {
   G_Debug(this, "download error: " + status);
   // If status is empty, then we assume that we got an NS_CONNECTION_REFUSED
   // error.  In this case, we treat this is a http 500 error.
   if (!status) {
     status = 500;
   }
   status = parseInt(status, 10);
   this.requestBackoff_.noteServerResponse(status);
   if (this.requestBackoff_.isErrorStatus(status)) {
     // Schedule an update for when our backoff is complete
     this.currentUpdateChecker_ =
       new G_Alarm(BindToObject(this.checkForUpdates, this),
                   this.requestBackoff_.nextRequestDelay());
   }
 }
 /**
  * Called when cookies are cleared
  */
 PROT_ListManager.prototype.cookieChanged_ = function(subject, topic, data) {
   if (data != "cleared")
     return;
   G_Debug(this, "cookies cleared");
 }
 PROT_ListManager.prototype.QueryInterface = function(iid) {
   if (iid.equals(Ci.nsISupports) ||
       iid.equals(Ci.nsIUrlListManager) ||
       iid.equals(Ci.nsITimerCallback))
     return this;
   throw Components.results.NS_ERROR_NO_INTERFACE;
 }