Adding upstream version 4.7.upstream/4.7

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 114 insertions, 0 deletions

diff --git a/content/modules/network.js b/content/modules/network.js
new file mode 100644
index 0000000..f5e81d3
--- /dev/null
+++ b/content/modules/network.js
@@ -0,0 +1,114 @@
+/*
+ * This file is part of TbSync.
+ *
+ * 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";
+ 
+var network = {
+
+  load: async function () {
+  },
+
+  unload: async function () {
+  },
+  
+  getContainerIdForUser: function(username) {
+    //define the allowed range of container ids to be used
+    let min = 10000;
+    let max = 19999;
+    
+    //we need to store the container map in the main window, so it is persistent and survives a restart of this bootstrapped addon
+    //TODO: is there a better way to store this container map globally? Can there be TWO main windows?
+    let mainWindow = Services.wm.getMostRecentWindow("mail:3pane");
+
+    //init
+    if (!(mainWindow._containers)) {
+      mainWindow._containers = [];
+    }
+    
+    //reset if adding an entry will exceed allowed range
+    if (mainWindow._containers.length > (max-min) && mainWindow._containers.indexOf(username) == -1) {
+      for (let i=0; i < mainWindow._containers.length; i++) {
+        //Services.clearData.deleteDataFromOriginAttributesPattern({ userContextId: i + min });
+        Services.obs.notifyObservers(null, "clear-origin-attributes-data", JSON.stringify({ userContextId: i + min }));
+      }
+      mainWindow._containers = [];
+    }
+    
+    let idx = mainWindow._containers.indexOf(username);
+    return (idx == -1) ? mainWindow._containers.push(username) - 1 + min : (idx + min);
+  },
+  
+  resetContainerForUser: function(username) {
+    let id = this.getContainerIdForUser(username);
+    Services.obs.notifyObservers(null, "clear-origin-attributes-data", JSON.stringify({ userContextId: id }));
+  },
+
+  createTCPErrorFromFailedXHR: function (xhr) {
+    return this.createTCPErrorFromFailedRequest(xhr.channel.QueryInterface(Components.interfaces.nsIRequest));
+  },
+  
+  createTCPErrorFromFailedRequest: function (request) {
+    //adapted from :
+    //https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/How_to_check_the_secruity_state_of_an_XMLHTTPRequest_over_SSL		
+    //codes: https://developer.mozilla.org/en-US/docs/Mozilla/Errors
+    let status = request.status;
+
+    if ((status & 0xff0000) === 0x5a0000) { // Security module
+      const nsINSSErrorsService = Components.interfaces.nsINSSErrorsService;
+      let nssErrorsService = Components.classes['@mozilla.org/nss_errors_service;1'].getService(nsINSSErrorsService);
+      
+      // NSS_SEC errors (happen below the base value because of negative vals)
+      if ((status & 0xffff) < Math.abs(nsINSSErrorsService.NSS_SEC_ERROR_BASE)) {
+
+        // The bases are actually negative, so in our positive numeric space, we
+        // need to subtract the base off our value.
+        let nssErr = Math.abs(nsINSSErrorsService.NSS_SEC_ERROR_BASE) - (status & 0xffff);
+        switch (nssErr) {
+          case 11: return 'security::SEC_ERROR_EXPIRED_CERTIFICATE';
+          case 12: return 'security::SEC_ERROR_REVOKED_CERTIFICATE';
+          case 13: return 'security::SEC_ERROR_UNKNOWN_ISSUER';
+          case 20: return 'security::SEC_ERROR_UNTRUSTED_ISSUER';
+          case 21: return 'security::SEC_ERROR_UNTRUSTED_CERT';
+          case 36: return 'security::SEC_ERROR_CA_CERT_INVALID';
+          case 90: return 'security::SEC_ERROR_INADEQUATE_KEY_USAGE';
+          case 176: return 'security::SEC_ERROR_CERT_SIGNATURE_ALGORITHM_DISABLED';
+        }
+        return 'security::UNKNOWN_SECURITY_ERROR';
+        
+      } else {
+
+        // Calculating the difference 		  
+        let sslErr = Math.abs(nsINSSErrorsService.NSS_SSL_ERROR_BASE) - (status & 0xffff);		
+        switch (sslErr) {
+          case 3: return 'security::SSL_ERROR_NO_CERTIFICATE';
+          case 4: return 'security::SSL_ERROR_BAD_CERTIFICATE';
+          case 8: return 'security::SSL_ERROR_UNSUPPORTED_CERTIFICATE_TYPE';
+          case 9: return 'security::SSL_ERROR_UNSUPPORTED_VERSION';
+          case 12: return 'security::SSL_ERROR_BAD_CERT_DOMAIN';
+        }
+        return 'security::UNKOWN_SSL_ERROR';
+        
+      }
+
+    } else { //not the security module
+      
+      switch (status) {
+        case 0x804B000C: return 'network::NS_ERROR_CONNECTION_REFUSED';
+        case 0x804B000E: return 'network::NS_ERROR_NET_TIMEOUT';
+        case 0x804B001E: return 'network::NS_ERROR_UNKNOWN_HOST';
+        case 0x804B0047: return 'network::NS_ERROR_NET_INTERRUPT';
+        case 0x805303F4: return 'network::NS_ERROR_DOM_BAD_URI';
+        // Custom error
+        case 0x804B002F: return 'network::REJECTED_REDIRECT_FROM_HTTPS_TO_HTTP';
+      }
+      return 'network::UNKNOWN_NETWORK_ERROR';
+
+    }
+    return null;	 
+  },
+}