The Tor Browser: comparison services/sync/modules/resource.js

comparison: services/sync/modules/resource.js

services/sync/modules/resource.js

branch: TOR_BUG_3246
changeset 5: 4ab42b5ab56c

equal deleted inserted replaced

--1:000000000000
+:fbabe0f9d500
+/* 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.EXPORTED_SYMBOLS = [
+"AsyncResource",
+"Resource"
+];
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+const Cu = Components.utils;
+Cu.import("resource://gre/modules/Preferences.jsm");
+Cu.import("resource://services-common/async.js");
+Cu.import("resource://gre/modules/Log.jsm");
+Cu.import("resource://services-common/observers.js");
+Cu.import("resource://services-common/utils.js");
+Cu.import("resource://services-sync/constants.js");
+Cu.import("resource://services-sync/util.js");
+const DEFAULT_LOAD_FLAGS =
+// Always validate the cache:
+Ci.nsIRequest.LOAD_BYPASS_CACHE |
+Ci.nsIRequest.INHIBIT_CACHING |
+// Don't send user cookies over the wire (Bug 644734).
+Ci.nsIRequest.LOAD_ANONYMOUS;
+/*
+* AsyncResource represents a remote network resource, identified by a URI.
+* Create an instance like so:
+*
+*   let resource = new AsyncResource("http://foobar.com/path/to/resource");
+*
+* The 'resource' object has the following methods to issue HTTP requests
+* of the corresponding HTTP methods:
+*
+*   get(callback)
+*   put(data, callback)
+*   post(data, callback)
+*   delete(callback)
+*
+* 'callback' is a function with the following signature:
+*
+*   function callback(error, result) {...}
+*
+* 'error' will be null on successful requests. Likewise, result will not be
+* passed (=undefined) when an error occurs. Note that this is independent of
+* the status of the HTTP response.
+*/
+this.AsyncResource = function AsyncResource(uri) {
+this._log = Log.repository.getLogger(this._logName);
+this._log.level =
+Log.Level[Svc.Prefs.get("log.logger.network.resources")];
+this.uri = uri;
+this._headers = {};
+this._onComplete = Utils.bind2(this, this._onComplete);
+}
+AsyncResource.prototype = {
+_logName: "Sync.AsyncResource",
+// ** {{{ AsyncResource.serverTime }}} **
+//
+// Caches the latest server timestamp (X-Weave-Timestamp header).
+serverTime: null,
+/**
+* Callback to be invoked at request time to add authentication details.
+*
+* By default, a global authenticator is provided. If this is set, it will
+* be used instead of the global one.
+*/
+authenticator: null,
+// The string to use as the base User-Agent in Sync requests.
+// These strings will look something like
+//
+//   Firefox/4.0 FxSync/1.8.0.20100101.mobile
+//
+// or
+//
+//   Firefox Aurora/5.0a1 FxSync/1.9.0.20110409.desktop
+//
+_userAgent:
+Services.appinfo.name + "/" + Services.appinfo.version +  // Product.
+" FxSync/" + WEAVE_VERSION + "." +                        // Sync.
+Services.appinfo.appBuildID + ".",                        // Build.
+// Wait 5 minutes before killing a request.
+ABORT_TIMEOUT: 300000,
+// ** {{{ AsyncResource.headers }}} **
+//
+// Headers to be included when making a request for the resource.
+// Note: Header names should be all lower case, there's no explicit
+// check for duplicates due to case!
+get headers() {
+return this._headers;
+},
+set headers(value) {
+this._headers = value;
+},
+setHeader: function Res_setHeader(header, value) {
+this._headers[header.toLowerCase()] = value;
+},
+get headerNames() {
+return Object.keys(this.headers);
+},
+// ** {{{ AsyncResource.uri }}} **
+//
+// URI representing this resource.
+get uri() {
+return this._uri;
+},
+set uri(value) {
+if (typeof value == 'string')
+this._uri = CommonUtils.makeURI(value);
+else
+this._uri = value;
+},
+// ** {{{ AsyncResource.spec }}} **
+//
+// Get the string representation of the URI.
+get spec() {
+if (this._uri)
+return this._uri.spec;
+return null;
+},
+// ** {{{ AsyncResource.data }}} **
+//
+// Get and set the data encapulated in the resource.
+_data: null,
+get data() this._data,
+set data(value) {
+this._data = value;
+},
+// ** {{{ AsyncResource._createRequest }}} **
+//
+// This method returns a new IO Channel for requests to be made
+// through. It is never called directly, only {{{_doRequest}}} uses it
+// to obtain a request channel.
+//
+_createRequest: function Res__createRequest(method) {
+let channel = Services.io.newChannel(this.spec, null, null)
+.QueryInterface(Ci.nsIRequest)
+.QueryInterface(Ci.nsIHttpChannel);
+channel.loadFlags |= DEFAULT_LOAD_FLAGS;
+// Setup a callback to handle channel notifications.
+let listener = new ChannelNotificationListener(this.headerNames);
+channel.notificationCallbacks = listener;
+// Compose a UA string fragment from the various available identifiers.
+if (Svc.Prefs.get("sendVersionInfo", true)) {
+let ua = this._userAgent + Svc.Prefs.get("client.type", "desktop");
+channel.setRequestHeader("user-agent", ua, false);
+}
+let headers = this.headers;
+if (this.authenticator) {
+let result = this.authenticator(this, method);
+if (result && result.headers) {
+for (let [k, v] in Iterator(result.headers)) {
+headers[k.toLowerCase()] = v;
+}
+}
+} else {
+this._log.debug("No authenticator found.");
+}
+for (let [key, value] in Iterator(headers)) {
+if (key == 'authorization')
+this._log.trace("HTTP Header " + key + ": ***** (suppressed)");
+else
+this._log.trace("HTTP Header " + key + ": " + headers[key]);
+channel.setRequestHeader(key, headers[key], false);
+}
+return channel;
+},
+_onProgress: function Res__onProgress(channel) {},
+_doRequest: function _doRequest(action, data, callback) {
+this._log.trace("In _doRequest.");
+this._callback = callback;
+let channel = this._createRequest(action);
+if ("undefined" != typeof(data))
+this._data = data;
+// PUT and POST are treated differently because they have payload data.
+if ("PUT" == action || "POST" == action) {
+// Convert non-string bodies into JSON
+if (this._data.constructor.toString() != String)
+this._data = JSON.stringify(this._data);
+this._log.debug(action + " Length: " + this._data.length);
+this._log.trace(action + " Body: " + this._data);
+let type = ('content-type' in this._headers) ?
+this._headers['content-type'] : 'text/plain';
+let stream = Cc["@mozilla.org/io/string-input-stream;1"].
+createInstance(Ci.nsIStringInputStream);
+stream.setData(this._data, this._data.length);
+channel.QueryInterface(Ci.nsIUploadChannel);
+channel.setUploadStream(stream, type, this._data.length);
+}
+// Setup a channel listener so that the actual network operation
+// is performed asynchronously.
+let listener = new ChannelListener(this._onComplete, this._onProgress,
+this._log, this.ABORT_TIMEOUT);
+channel.requestMethod = action;
+try {
+channel.asyncOpen(listener, null);
+} catch (ex) {
+// asyncOpen can throw in a bunch of cases -- e.g., a forbidden port.
+this._log.warn("Caught an error in asyncOpen: " + CommonUtils.exceptionStr(ex));
+CommonUtils.nextTick(callback.bind(this, ex));
+}
+},
+_onComplete: function _onComplete(error, data, channel) {
+this._log.trace("In _onComplete. Error is " + error + ".");
+if (error) {
+this._callback(error);
+return;
+}
+this._data = data;
+let action = channel.requestMethod;
+this._log.trace("Channel: " + channel);
+this._log.trace("Action: "  + action);
+// Process status and success first. This way a problem with headers
+// doesn't fail to include accurate status information.
+let status = 0;
+let success = false;
+try {
+status  = channel.responseStatus;
+success = channel.requestSucceeded;    // HTTP status.
+this._log.trace("Status: " + status);
+this._log.trace("Success: " + success);
+// Log the status of the request.
+let mesg = [action, success ? "success" : "fail", status,
+channel.URI.spec].join(" ");
+this._log.debug("mesg: " + mesg);
+if (mesg.length > 200)
+mesg = mesg.substr(0, 200) + "…";
+this._log.debug(mesg);
+// Additionally give the full response body when Trace logging.
+if (this._log.level <= Log.Level.Trace)
+this._log.trace(action + " body: " + data);
+} catch(ex) {
+// Got a response, but an exception occurred during processing.
+// This shouldn't occur.
+this._log.warn("Caught unexpected exception " + CommonUtils.exceptionStr(ex) +
+" in _onComplete.");
+this._log.debug(CommonUtils.stackTrace(ex));
+}
+// Process headers. They can be empty, or the call can otherwise fail, so
+// put this in its own try block.
+let headers = {};
+try {
+this._log.trace("Processing response headers.");
+// Read out the response headers if available.
+channel.visitResponseHeaders({
+visitHeader: function visitHeader(header, value) {
+headers[header.toLowerCase()] = value;
+}
+});
+// This is a server-side safety valve to allow slowing down
+// clients without hurting performance.
+if (headers["x-weave-backoff"]) {
+let backoff = headers["x-weave-backoff"];
+this._log.debug("Got X-Weave-Backoff: " + backoff);
+Observers.notify("weave:service:backoff:interval",
+parseInt(backoff, 10));
+}
+if (success && headers["x-weave-quota-remaining"]) {
+Observers.notify("weave:service:quota:remaining",
+parseInt(headers["x-weave-quota-remaining"], 10));
+}
+} catch (ex) {
+this._log.debug("Caught exception " + CommonUtils.exceptionStr(ex) +
+" visiting headers in _onComplete.");
+this._log.debug(CommonUtils.stackTrace(ex));
+}
+let ret     = new String(data);
+ret.status  = status;
+ret.success = success;
+ret.headers = headers;
+// Make a lazy getter to convert the json response into an object.
+// Note that this can cause a parse error to be thrown far away from the
+// actual fetch, so be warned!
+XPCOMUtils.defineLazyGetter(ret, "obj", function() {
+try {
+return JSON.parse(ret);
+} catch (ex) {
+this._log.warn("Got exception parsing response body: \"" + CommonUtils.exceptionStr(ex));
+// Stringify to avoid possibly printing non-printable characters.
+this._log.debug("Parse fail: Response body starts: \"" +
+JSON.stringify((ret + "").slice(0, 100)) +
+"\".");
+throw ex;
+}
+}.bind(this));
+this._callback(null, ret);
+},
+get: function get(callback) {
+this._doRequest("GET", undefined, callback);
+},
+put: function put(data, callback) {
+if (typeof data == "function")
+[data, callback] = [undefined, data];
+this._doRequest("PUT", data, callback);
+},
+post: function post(data, callback) {
+if (typeof data == "function")
+[data, callback] = [undefined, data];
+this._doRequest("POST", data, callback);
+},
+delete: function delete_(callback) {
+this._doRequest("DELETE", undefined, callback);
+}
+};
+/*
+* Represent a remote network resource, identified by a URI, with a
+* synchronous API.
+*
+* 'Resource' is not recommended for new code. Use the asynchronous API of
+* 'AsyncResource' instead.
+*/
+this.Resource = function Resource(uri) {
+AsyncResource.call(this, uri);
+}
+Resource.prototype = {
+__proto__: AsyncResource.prototype,
+_logName: "Sync.Resource",
+// ** {{{ Resource._request }}} **
+//
+// Perform a particular HTTP request on the resource. This method
+// is never called directly, but is used by the high-level
+// {{{get}}}, {{{put}}}, {{{post}}} and {{delete}} methods.
+_request: function Res__request(action, data) {
+let cb = Async.makeSyncCallback();
+function callback(error, ret) {
+if (error)
+cb.throw(error);
+cb(ret);
+}
+// The channel listener might get a failure code
+try {
+this._doRequest(action, data, callback);
+return Async.waitForSyncCallback(cb);
+} catch(ex) {
+// Combine the channel stack with this request stack.  Need to create
+// a new error object for that.
+let error = Error(ex.message);
+error.result = ex.result;
+let chanStack = [];
+if (ex.stack)
+chanStack = ex.stack.trim().split(/\n/).slice(1);
+let requestStack = error.stack.split(/\n/).slice(1);
+// Strip out the args for the last 2 frames because they're usually HUGE!
+for (let i = 0; i <= 1; i++)
+requestStack[i] = requestStack[i].replace(/\(".*"\)@/, "(...)@");
+error.stack = chanStack.concat(requestStack).join("\n");
+throw error;
+}
+},
+// ** {{{ Resource.get }}} **
+//
+// Perform an asynchronous HTTP GET for this resource.
+get: function Res_get() {
+return this._request("GET");
+},
+// ** {{{ Resource.put }}} **
+//
+// Perform a HTTP PUT for this resource.
+put: function Res_put(data) {
+return this._request("PUT", data);
+},
+// ** {{{ Resource.post }}} **
+//
+// Perform a HTTP POST for this resource.
+post: function Res_post(data) {
+return this._request("POST", data);
+},
+// ** {{{ Resource.delete }}} **
+//
+// Perform a HTTP DELETE for this resource.
+delete: function Res_delete() {
+return this._request("DELETE");
+}
+};
+// = ChannelListener =
+//
+// This object implements the {{{nsIStreamListener}}} interface
+// and is called as the network operation proceeds.
+function ChannelListener(onComplete, onProgress, logger, timeout) {
+this._onComplete = onComplete;
+this._onProgress = onProgress;
+this._log = logger;
+this._timeout = timeout;
+this.delayAbort();
+}
+ChannelListener.prototype = {
+onStartRequest: function Channel_onStartRequest(channel) {
+this._log.trace("onStartRequest called for channel " + channel + ".");
+try {
+channel.QueryInterface(Ci.nsIHttpChannel);
+} catch (ex) {
+this._log.error("Unexpected error: channel is not a nsIHttpChannel!");
+channel.cancel(Cr.NS_BINDING_ABORTED);
+return;
+}
+// Save the latest server timestamp when possible.
+try {
+AsyncResource.serverTime = channel.getResponseHeader("X-Weave-Timestamp") - 0;
+}
+catch(ex) {}
+this._log.trace("onStartRequest: " + channel.requestMethod + " " +
+channel.URI.spec);
+this._data = '';
+this.delayAbort();
+},
+onStopRequest: function Channel_onStopRequest(channel, context, status) {
+// Clear the abort timer now that the channel is done.
+this.abortTimer.clear();
+if (!this._onComplete) {
+this._log.error("Unexpected error: _onComplete not defined in onStopRequest.");
+this._onProgress = null;
+return;
+}
+try {
+channel.QueryInterface(Ci.nsIHttpChannel);
+} catch (ex) {
+this._log.error("Unexpected error: channel is not a nsIHttpChannel!");
+this._onComplete(ex, this._data, channel);
+this._onComplete = this._onProgress = null;
+return;
+}
+let statusSuccess = Components.isSuccessCode(status);
+let uri = channel && channel.URI && channel.URI.spec || "<unknown>";
+this._log.trace("Channel for " + channel.requestMethod + " " + uri + ": " +
+"isSuccessCode(" + status + ")? " + statusSuccess);
+if (this._data == '') {
+this._data = null;
+}
+// Pass back the failure code and stop execution. Use Components.Exception()
+// instead of Error() so the exception is QI-able and can be passed across
+// XPCOM borders while preserving the status code.
+if (!statusSuccess) {
+let message = Components.Exception("", status).name;
+let error   = Components.Exception(message, status);
+this._onComplete(error, undefined, channel);
+this._onComplete = this._onProgress = null;
+return;
+}
+this._log.trace("Channel: flags = " + channel.loadFlags +
+", URI = " + uri +
+", HTTP success? " + channel.requestSucceeded);
+this._onComplete(null, this._data, channel);
+this._onComplete = this._onProgress = null;
+},
+onDataAvailable: function Channel_onDataAvail(req, cb, stream, off, count) {
+let siStream;
+try {
+siStream = Cc["@mozilla.org/scriptableinputstream;1"].createInstance(Ci.nsIScriptableInputStream);
+siStream.init(stream);
+} catch (ex) {
+this._log.warn("Exception creating nsIScriptableInputStream." + CommonUtils.exceptionStr(ex));
+this._log.debug("Parameters: " + req.URI.spec + ", " + stream + ", " + off + ", " + count);
+// Cannot proceed, so rethrow and allow the channel to cancel itself.
+throw ex;
+}
+try {
+this._data += siStream.read(count);
+} catch (ex) {
+this._log.warn("Exception thrown reading " + count + " bytes from " + siStream + ".");
+throw ex;
+}
+try {
+this._onProgress();
+} catch (ex) {
+this._log.warn("Got exception calling onProgress handler during fetch of "
++ req.URI.spec);
+this._log.debug(CommonUtils.exceptionStr(ex));
+this._log.trace("Rethrowing; expect a failure code from the HTTP channel.");
+throw ex;
+}
+this.delayAbort();
+},
+/**
+* Create or push back the abort timer that kills this request.
+*/
+delayAbort: function delayAbort() {
+try {
+CommonUtils.namedTimer(this.abortRequest, this._timeout, this, "abortTimer");
+} catch (ex) {
+this._log.warn("Got exception extending abort timer: " + CommonUtils.exceptionStr(ex));
+}
+},
+abortRequest: function abortRequest() {
+// Ignore any callbacks if we happen to get any now
+this.onStopRequest = function() {};
+let error = Components.Exception("Aborting due to channel inactivity.",
+Cr.NS_ERROR_NET_TIMEOUT);
+if (!this._onComplete) {
+this._log.error("Unexpected error: _onComplete not defined in " +
+"abortRequest.");
+return;
+}
+this._onComplete(error);
+}
+};
+/**
+* This class handles channel notification events.
+*
+* An instance of this class is bound to each created channel.
+*
+* Optionally pass an array of header names. Each header named
+* in this array will be copied between the channels in the
+* event of a redirect.
+*/
+function ChannelNotificationListener(headersToCopy) {
+this._headersToCopy = headersToCopy;
+this._log = Log.repository.getLogger(this._logName);
+this._log.level = Log.Level[Svc.Prefs.get("log.logger.network.resources")];
+}
+ChannelNotificationListener.prototype = {
+_logName: "Sync.Resource",
+getInterface: function(aIID) {
+return this.QueryInterface(aIID);
+},
+QueryInterface: function(aIID) {
+if (aIID.equals(Ci.nsIBadCertListener2) ||
+aIID.equals(Ci.nsIInterfaceRequestor) ||
+aIID.equals(Ci.nsISupports) ||
+aIID.equals(Ci.nsIChannelEventSink))
+return this;
+throw Cr.NS_ERROR_NO_INTERFACE;
+},
+notifyCertProblem: function certProblem(socketInfo, sslStatus, targetHost) {
+let log = Log.repository.getLogger("Sync.CertListener");
+log.warn("Invalid HTTPS certificate encountered!");
+// This suppresses the UI warning only. The request is still cancelled.
+return true;
+},
+asyncOnChannelRedirect:
+function asyncOnChannelRedirect(oldChannel, newChannel, flags, callback) {
+let oldSpec = (oldChannel && oldChannel.URI) ? oldChannel.URI.spec : "<undefined>";
+let newSpec = (newChannel && newChannel.URI) ? newChannel.URI.spec : "<undefined>";
+this._log.debug("Channel redirect: " + oldSpec + ", " + newSpec + ", " + flags);
+this._log.debug("Ensuring load flags are set.");
+newChannel.loadFlags |= DEFAULT_LOAD_FLAGS;
+// For internal redirects, copy the headers that our caller set.
+try {
+if ((flags & Ci.nsIChannelEventSink.REDIRECT_INTERNAL) &&
+newChannel.URI.equals(oldChannel.URI)) {
+this._log.debug("Copying headers for safe internal redirect.");
+// QI the channel so we can set headers on it.
+try {
+newChannel.QueryInterface(Ci.nsIHttpChannel);
+} catch (ex) {
+this._log.error("Unexpected error: channel is not a nsIHttpChannel!");
+throw ex;
+}
+for (let header of this._headersToCopy) {
+let value = oldChannel.getRequestHeader(header);
+if (value) {
+let printed = (header == "authorization") ? "****" : value;
+this._log.debug("Header: " + header + " = " + printed);
+newChannel.setRequestHeader(header, value, false);
+} else {
+this._log.warn("No value for header " + header);
+}
+}
+}
+} catch (ex) {
+this._log.error("Error copying headers: " + CommonUtils.exceptionStr(ex));
+}
+// We let all redirects proceed.
+try {
+callback.onRedirectVerifyCallback(Cr.NS_OK);
+} catch (ex) {
+this._log.error("onRedirectVerifyCallback threw!" + CommonUtils.exceptionStr(ex));
+}
+}
+};