The Tor Browser: toolkit/modules/Sntp.jsm@6474c204b198 (annotated)

toolkit/modules/Sntp.jsm@6474c204b198 (annotated)

toolkit/modules/Sntp.jsm

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/. */
 "use strict";
 this.EXPORTED_SYMBOLS = [
   "Sntp",
 ];
 const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
 // Set to true to see debug messages.
 let DEBUG = false;
 /**
  * Constructor of Sntp.
  *
  * @param dataAvailableCb
  *        Callback function gets called when SNTP offset available. Signature
  *        is function dataAvailableCb(offsetInMS).
  * @param maxRetryCount
  *        Maximum retry count when SNTP failed to connect to server; set to
  *        zero to disable the retry.
  * @param refreshPeriodInSecs
  *        Refresh period; set to zero to disable refresh.
  * @param timeoutInSecs
  *        Timeout value used for connection.
  * @param pools
  *        SNTP server lists separated by ';'.
  * @param port
  *        SNTP port.
  */
 this.Sntp = function Sntp(dataAvailableCb, maxRetryCount, refreshPeriodInSecs,
                           timeoutInSecs, pools, port) {
   if (dataAvailableCb != null) {
     this._dataAvailableCb = dataAvailableCb;
   }
   if (maxRetryCount != null) {
     this._maxRetryCount = maxRetryCount;
   }
   if (refreshPeriodInSecs != null) {
     this._refreshPeriodInMS = refreshPeriodInSecs * 1000;
   }
   if (timeoutInSecs != null) {
     this._timeoutInMS = timeoutInSecs * 1000;
   }
   if (pools != null && Array.isArray(pools) && pools.length > 0) {
     this._pools = pools;
   }
   if (port != null) {
     this._port = port;
   }
 }
 Sntp.prototype = {
   isAvailable: function isAvailable() {
     return this._cachedOffset != null;
   },
   isExpired: function isExpired() {
     let valid = this._cachedOffset != null && this._cachedTimeInMS != null;
     if (this._refreshPeriodInMS > 0) {
       valid = valid && Date.now() < this._cachedTimeInMS +
                                     this._refreshPeriodInMS;
     }
     return !valid;
   },
   request: function request() {
     this._request();
   },
   getOffset: function getOffset() {
     return this._cachedOffset;
   },
   /**
    * Indicates the system clock has been changed by [offset]ms so we need to
    * adjust the stored value.
    */
   updateOffset: function updateOffset(offset) {
     if (this._cachedOffset != null) {
       this._cachedOffset -= offset;
     }
   },
   /**
    * Used to schedule a retry or periodic updates.
    */
   _schedule: function _schedule(timeInMS) {
     if (this._updateTimer == null) {
       this._updateTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
     }
     this._updateTimer.initWithCallback(this._request.bind(this),
                                        timeInMS,
                                        Ci.nsITimer.TYPE_ONE_SHOT);
     debug("Scheduled SNTP request in " + timeInMS + "ms");
   },
   /**
    * Handle the SNTP response.
    */
   _handleSntp: function _handleSntp(originateTimeInMS, receiveTimeInMS,
                                     transmitTimeInMS, respondTimeInMS) {
     let clockOffset = Math.floor(((receiveTimeInMS - originateTimeInMS) +
                                  (transmitTimeInMS - respondTimeInMS)) / 2);
     debug("Clock offset: " + clockOffset);
     // We've succeeded so clear the retry status.
     this._retryCount = 0;
     this._retryPeriodInMS = 0;
     // Cache the latest SNTP offset whenever receiving it.
     this._cachedOffset = clockOffset;
     this._cachedTimeInMS = respondTimeInMS;
     if (this._dataAvailableCb != null) {
       this._dataAvailableCb(clockOffset);
     }
     this._schedule(this._refreshPeriodInMS);
   },
   /**
    * Used for retry SNTP requests.
    */
   _retry: function _retry() {
     this._retryCount++;
     if (this._retryCount > this._maxRetryCount) {
       debug ("stop retrying SNTP");
       // Clear so we can start with clean status next time we have network.
       this._retryCount = 0;
       this._retryPeriodInMS = 0;
       return;
     }
     this._retryPeriodInMS = Math.max(1000, this._retryPeriodInMS * 2);
     this._schedule(this._retryPeriodInMS);
   },
   /**
    * Request SNTP.
    */
   _request: function _request() {
     function GetRequest() {
       let NTP_PACKET_SIZE = 48;
       let NTP_MODE_CLIENT = 3;
       let NTP_VERSION = 3;
       let TRANSMIT_TIME_OFFSET = 40;
       // Send the NTP request.
       let requestTimeInMS = Date.now();
       let s = requestTimeInMS / 1000;
       let ms = requestTimeInMS % 1000;
       // NTP time is relative to 1900.
       s += OFFSET_1900_TO_1970;
       let f = ms * 0x100000000 / 1000;
       s = Math.floor(s);
       f = Math.floor(f);
       let buffer = new ArrayBuffer(NTP_PACKET_SIZE);
       let data = new DataView(buffer);
       data.setUint8(0, NTP_MODE_CLIENT | (NTP_VERSION << 3));
       data.setUint32(TRANSMIT_TIME_OFFSET, s, false);
       data.setUint32(TRANSMIT_TIME_OFFSET + 4, f, false);
       return String.fromCharCode.apply(null, new Uint8Array(buffer));
     }
     function SNTPListener() {};
     SNTPListener.prototype = {
       onStartRequest: function onStartRequest(request, context) {
       },
       onStopRequest: function onStopRequest(request, context, status) {
         if (!Components.isSuccessCode(status)) {
           debug ("Connection failed");
           this._requesting = false;
           this._retry();
         }
       }.bind(this),
       onDataAvailable: function onDataAvailable(request, context, inputStream,
                                                 offset, count) {
         function GetTimeStamp(binaryInputStream) {
           let s = binaryInputStream.read32();
           let f = binaryInputStream.read32();
           return Math.floor(
             ((s - OFFSET_1900_TO_1970) * 1000) + ((f * 1000) / 0x100000000)
           );
         }
         debug ("Data available: " + count + " bytes");
         try {
           let binaryInputStream = Cc["@mozilla.org/binaryinputstream;1"]
                                     .createInstance(Ci.nsIBinaryInputStream);
           binaryInputStream.setInputStream(inputStream);
           // We don't need first 24 bytes.
           for (let i = 0; i < 6; i++) {
             binaryInputStream.read32();
           }
           // Offset 24: originate time.
           let originateTimeInMS = GetTimeStamp(binaryInputStream);
           // Offset 32: receive time.
           let receiveTimeInMS = GetTimeStamp(binaryInputStream);
           // Offset 40: transmit time.
           let transmitTimeInMS = GetTimeStamp(binaryInputStream);
           let respondTimeInMS = Date.now();
           this._handleSntp(originateTimeInMS, receiveTimeInMS,
                            transmitTimeInMS, respondTimeInMS);
           this._requesting = false;
         } catch (e) {
           debug ("SNTPListener Error: " + e.message);
           this._requesting = false;
           this._retry();
         }
         inputStream.close();
       }.bind(this)
     };
     function SNTPRequester() {}
     SNTPRequester.prototype = {
       onOutputStreamReady: function(stream) {
         try {
           let data = GetRequest();
           let bytes_write = stream.write(data, data.length);
           debug ("SNTP: sent " + bytes_write + " bytes");
           stream.close();
         } catch (e) {
           debug ("SNTPRequester Error: " + e.message);
           this._requesting = false;
           this._retry();
         }
       }.bind(this)
     };
     // Number of seconds between Jan 1, 1900 and Jan 1, 1970.
     // 70 years plus 17 leap days.
     let OFFSET_1900_TO_1970 = ((365 * 70) + 17) * 24 * 60 * 60;
     if (this._requesting) {
       return;
     }
     if (this._pools.length < 1) {
       debug("No server defined");
       return;
     }
     if (this._updateTimer) {
       this._updateTimer.cancel();
     }
     debug ("Making request");
     this._requesting = true;
     let currentThread = Cc["@mozilla.org/thread-manager;1"]
                           .getService().currentThread;
     let socketTransportService =
       Cc["@mozilla.org/network/socket-transport-service;1"]
         .getService(Ci.nsISocketTransportService);
     let pump = Cc["@mozilla.org/network/input-stream-pump;1"]
                  .createInstance(Ci.nsIInputStreamPump);
     let transport = socketTransportService
       .createTransport(["udp"],
 ,
                        this._pools[Math.floor(this._pools.length * Math.random())],
                        this._port,
                        null);
     transport.setTimeout(Ci.nsISocketTransport.TIMEOUT_CONNECT, this._timeoutInMS);
     transport.setTimeout(Ci.nsISocketTransport.TIMEOUT_READ_WRITE, this._timeoutInMS);
     let outStream = transport.openOutputStream(0, 0, 0)
                              .QueryInterface(Ci.nsIAsyncOutputStream);
     let inStream = transport.openInputStream(0, 0, 0);
     pump.init(inStream, -1, -1, 0, 0, false);
     pump.asyncRead(new SNTPListener(), null);
     outStream.asyncWait(new SNTPRequester(), 0, 0, currentThread);
   },
   // Callback function.
   _dataAvailableCb: null,
   // Sntp servers.
   _pools: [
     "0.pool.ntp.org",
     "1.pool.ntp.org",
     "2.pool.ntp.org",
     "3.pool.ntp.org"
   ],
   // The SNTP port.
   _port: 123,
   // Maximum retry count allowed when request failed.
   _maxRetryCount: 0,
   // Refresh period.
   _refreshPeriodInMS: 0,
   // Timeout value used for connecting.
   _timeoutInMS: 30 * 1000,
   // Cached SNTP offset.
   _cachedOffset: null,
   // The time point when we cache the offset.
   _cachedTimeInMS: null,
   // Flag to avoid redundant requests.
   _requesting: false,
   // Retry counter.
   _retryCount: 0,
   // Retry time offset (in seconds).
   _retryPeriodInMS: 0,
   // Timer used for retries & daily updates.
   _updateTimer: null
 };
 let debug;
 if (DEBUG) {
   debug = function (s) {
     dump("-*- Sntp: " + s + "\n");
   };
 } else {
   debug = function (s) {};
 }

The Tor Browser / annotate

toolkit/modules/Sntp.jsm@6474c204b198 (annotated)

toolkit/modules/Sntp.jsm