summaryrefslogtreecommitdiffstats
path: root/toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm')
-rw-r--r--toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm435
1 files changed, 435 insertions, 0 deletions
diff --git a/toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm b/toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm
new file mode 100644
index 000000000..cf9617ea1
--- /dev/null
+++ b/toolkit/modules/secondscreen/SimpleServiceDiscovery.jsm
@@ -0,0 +1,435 @@
+// -*- Mode: js; tab-width: 2; indent-tabs-mode: nil; js2-basic-offset: 2; js2-skip-preprocessor-directives: t; -*-
+/* 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 = ["SimpleServiceDiscovery"];
+
+const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Timer.jsm");
+
+var log = Cu.reportError;
+
+XPCOMUtils.defineLazyGetter(this, "converter", function () {
+ let conv = Cc["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Ci.nsIScriptableUnicodeConverter);
+ conv.charset = "utf8";
+ return conv;
+});
+
+// Spec information:
+// https://tools.ietf.org/html/draft-cai-ssdp-v1-03
+// http://www.dial-multiscreen.org/dial-protocol-specification
+const SSDP_PORT = 1900;
+const SSDP_ADDRESS = "239.255.255.250";
+
+const SSDP_DISCOVER_PACKET =
+ "M-SEARCH * HTTP/1.1\r\n" +
+ "HOST: " + SSDP_ADDRESS + ":" + SSDP_PORT + "\r\n" +
+ "MAN: \"ssdp:discover\"\r\n" +
+ "MX: 2\r\n" +
+ "ST: %SEARCH_TARGET%\r\n\r\n";
+
+const SSDP_DISCOVER_ATTEMPTS = 3;
+const SSDP_DISCOVER_DELAY = 500;
+const SSDP_DISCOVER_TIMEOUT_MULTIPLIER = 2;
+const SSDP_TRANSMISSION_INTERVAL = 1000;
+
+const EVENT_SERVICE_FOUND = "ssdp-service-found";
+const EVENT_SERVICE_LOST = "ssdp-service-lost";
+
+/*
+ * SimpleServiceDiscovery manages any discovered SSDP services. It uses a UDP
+ * broadcast to locate available services on the local network.
+ */
+var SimpleServiceDiscovery = {
+ get EVENT_SERVICE_FOUND() { return EVENT_SERVICE_FOUND; },
+ get EVENT_SERVICE_LOST() { return EVENT_SERVICE_LOST; },
+
+ _devices: new Map(),
+ _services: new Map(),
+ _searchSocket: null,
+ _searchInterval: 0,
+ _searchTimestamp: 0,
+ _searchTimeout: Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer),
+ _searchRepeat: Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer),
+ _discoveryMethods: [],
+
+ _forceTrailingSlash: function(aURL) {
+ // Cleanup the URL to make it consistent across devices
+ try {
+ aURL = Services.io.newURI(aURL, null, null).spec;
+ } catch (e) {}
+ return aURL;
+ },
+
+ // nsIUDPSocketListener implementation
+ onPacketReceived: function(aSocket, aMessage) {
+ // Listen for responses from specific devices. There could be more than one
+ // available.
+ let response = aMessage.data.split("\n");
+ let service = {};
+ response.forEach(function(row) {
+ let name = row.toUpperCase();
+ if (name.startsWith("LOCATION")) {
+ service.location = row.substr(10).trim();
+ } else if (name.startsWith("ST")) {
+ service.target = row.substr(4).trim();
+ }
+ }.bind(this));
+
+ if (service.location && service.target) {
+ service.location = this._forceTrailingSlash(service.location);
+
+ // When we find a valid response, package up the service information
+ // and pass it on.
+ try {
+ this._processService(service);
+ } catch (e) {}
+ }
+ },
+
+ onStopListening: function(aSocket, aStatus) {
+ // This is fired when the socket is closed expectedly or unexpectedly.
+ // nsITimer.cancel() is a no-op if the timer is not active.
+ this._searchTimeout.cancel();
+ this._searchSocket = null;
+ },
+
+ // Start a search. Make it continuous by passing an interval (in milliseconds).
+ // This will stop a current search loop because the timer resets itself.
+ // Returns the existing search interval.
+ search: function search(aInterval) {
+ let existingSearchInterval = this._searchInterval;
+ if (aInterval > 0) {
+ this._searchInterval = aInterval || 0;
+ this._searchRepeat.initWithCallback(this._search.bind(this), this._searchInterval, Ci.nsITimer.TYPE_REPEATING_SLACK);
+ }
+ this._search();
+ return existingSearchInterval;
+ },
+
+ // Stop the current continuous search
+ stopSearch: function stopSearch() {
+ this._searchRepeat.cancel();
+ },
+
+ _usingLAN: function() {
+ let network = Cc["@mozilla.org/network/network-link-service;1"].getService(Ci.nsINetworkLinkService);
+ return (network.linkType == Ci.nsINetworkLinkService.LINK_TYPE_WIFI ||
+ network.linkType == Ci.nsINetworkLinkService.LINK_TYPE_ETHERNET ||
+ network.linkType == Ci.nsINetworkLinkService.LINK_TYPE_UNKNOWN);
+ },
+
+ _search: function _search() {
+ // If a search is already active, shut it down.
+ this._searchShutdown();
+
+ // We only search if on local network
+ if (!this._usingLAN()) {
+ return;
+ }
+
+ // Update the timestamp so we can use it to clean out stale services the
+ // next time we search.
+ this._searchTimestamp = Date.now();
+
+ // Look for any fixed IP devices. Some routers might be configured to block
+ // UDP broadcasts, so this is a way to skip discovery.
+ this._searchFixedDevices();
+
+ // Look for any devices via registered external discovery mechanism.
+ this._startExternalDiscovery();
+
+ // Perform a UDP broadcast to search for SSDP devices
+ let socket = Cc["@mozilla.org/network/udp-socket;1"].createInstance(Ci.nsIUDPSocket);
+ try {
+ socket.init(SSDP_PORT, false, Services.scriptSecurityManager.getSystemPrincipal());
+ socket.joinMulticast(SSDP_ADDRESS);
+ socket.asyncListen(this);
+ } catch (e) {
+ // We were unable to create the broadcast socket. Just return, but don't
+ // kill the interval timer. This might work next time.
+ log("failed to start socket: " + e);
+ return;
+ }
+
+ // Make the timeout SSDP_DISCOVER_TIMEOUT_MULTIPLIER times as long as the time needed to send out the discovery packets.
+ const SSDP_DISCOVER_TIMEOUT = this._devices.size * SSDP_DISCOVER_ATTEMPTS * SSDP_TRANSMISSION_INTERVAL * SSDP_DISCOVER_TIMEOUT_MULTIPLIER;
+ this._searchSocket = socket;
+ this._searchTimeout.initWithCallback(this._searchShutdown.bind(this), SSDP_DISCOVER_TIMEOUT, Ci.nsITimer.TYPE_ONE_SHOT);
+
+ let data = SSDP_DISCOVER_PACKET;
+
+ // Send discovery packets out at 1 per SSDP_TRANSMISSION_INTERVAL and send each SSDP_DISCOVER_ATTEMPTS times
+ // to allow for packet loss on noisy networks.
+ let timeout = SSDP_DISCOVER_DELAY;
+ for (let attempts = 0; attempts < SSDP_DISCOVER_ATTEMPTS; attempts++) {
+ for (let [key, device] of this._devices) {
+ let target = device.target;
+ setTimeout(function() {
+ let msgData = data.replace("%SEARCH_TARGET%", target);
+ try {
+ let msgRaw = converter.convertToByteArray(msgData);
+ socket.send(SSDP_ADDRESS, SSDP_PORT, msgRaw, msgRaw.length);
+ } catch (e) {
+ log("failed to convert to byte array: " + e);
+ }
+ }, timeout);
+ timeout += SSDP_TRANSMISSION_INTERVAL;
+ }
+ }
+ },
+
+ _searchFixedDevices: function _searchFixedDevices() {
+ let fixedDevices = null;
+ try {
+ fixedDevices = Services.prefs.getCharPref("browser.casting.fixedDevices");
+ } catch (e) {}
+
+ if (!fixedDevices) {
+ return;
+ }
+
+ fixedDevices = JSON.parse(fixedDevices);
+ for (let fixedDevice of fixedDevices) {
+ // Verify we have the right data
+ if (!("location" in fixedDevice) || !("target" in fixedDevice)) {
+ continue;
+ }
+
+ fixedDevice.location = this._forceTrailingSlash(fixedDevice.location);
+
+ let service = {
+ location: fixedDevice.location,
+ target: fixedDevice.target
+ };
+
+ // We don't assume the fixed target is ready. We still need to ping it.
+ try {
+ this._processService(service);
+ } catch (e) {}
+ }
+ },
+
+ // Called when the search timeout is hit. We use it to cleanup the socket and
+ // perform some post-processing on the services list.
+ _searchShutdown: function _searchShutdown() {
+ if (this._searchSocket) {
+ // This will call onStopListening.
+ this._searchSocket.close();
+
+ // Clean out any stale services
+ for (let [key, service] of this._services) {
+ if (service.lastPing != this._searchTimestamp) {
+ this.removeService(service.uuid);
+ }
+ }
+ }
+
+ this._stopExternalDiscovery();
+ },
+
+ getSupportedExtensions: function() {
+ let extensions = [];
+ this.services.forEach(function(service) {
+ extensions = extensions.concat(service.extensions);
+ }, this);
+ return extensions.filter(function(extension, pos) {
+ return extensions.indexOf(extension) == pos;
+ });
+ },
+
+ getSupportedMimeTypes: function() {
+ let types = [];
+ this.services.forEach(function(service) {
+ types = types.concat(service.types);
+ }, this);
+ return types.filter(function(type, pos) {
+ return types.indexOf(type) == pos;
+ });
+ },
+
+ registerDevice: function registerDevice(aDevice) {
+ // We must have "id", "target" and "factory" defined
+ if (!("id" in aDevice) || !("target" in aDevice) || !("factory" in aDevice)) {
+ // Fatal for registration
+ throw "Registration requires an id, a target and a location";
+ }
+
+ // Only add if we don't already know about this device
+ if (!this._devices.has(aDevice.id)) {
+ this._devices.set(aDevice.id, aDevice);
+ } else {
+ log("device was already registered: " + aDevice.id);
+ }
+ },
+
+ unregisterDevice: function unregisterDevice(aDevice) {
+ // We must have "id", "target" and "factory" defined
+ if (!("id" in aDevice) || !("target" in aDevice) || !("factory" in aDevice)) {
+ return;
+ }
+
+ // Only remove if we know about this device
+ if (this._devices.has(aDevice.id)) {
+ this._devices.delete(aDevice.id);
+ } else {
+ log("device was not registered: " + aDevice.id);
+ }
+ },
+
+ findAppForService: function findAppForService(aService) {
+ if (!aService || !aService.deviceID) {
+ return null;
+ }
+
+ // Find the registration for the device
+ if (this._devices.has(aService.deviceID)) {
+ return this._devices.get(aService.deviceID).factory(aService);
+ }
+ return null;
+ },
+
+ findServiceForID: function findServiceForID(aUUID) {
+ if (this._services.has(aUUID)) {
+ return this._services.get(aUUID);
+ }
+ return null;
+ },
+
+ // Returns an array copy of the active services
+ get services() {
+ let array = [];
+ for (let [key, service] of this._services) {
+ let target = this._devices.get(service.deviceID);
+ service.extensions = target.extensions;
+ service.types = target.types;
+ array.push(service);
+ }
+ return array;
+ },
+
+ // Returns false if the service does not match the device's filters
+ _filterService: function _filterService(aService) {
+ // Loop over all the devices, looking for one that matches the service
+ for (let [key, device] of this._devices) {
+ // First level of match is on the target itself
+ if (device.target != aService.target) {
+ continue;
+ }
+
+ // If we have no filter, everything passes
+ if (!("filters" in device)) {
+ aService.deviceID = device.id;
+ return true;
+ }
+
+ // If all the filters pass, we have a match
+ let failed = false;
+ let filters = device.filters;
+ for (let filter in filters) {
+ if (filter in aService && aService[filter] != filters[filter]) {
+ failed = true;
+ }
+ }
+
+ // We found a match, so link the service to the device
+ if (!failed) {
+ aService.deviceID = device.id;
+ return true;
+ }
+ }
+
+ // We didn't find any matches
+ return false;
+ },
+
+ _processService: function _processService(aService) {
+ // Use the REST api to request more information about this service
+ let xhr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(Ci.nsIXMLHttpRequest);
+ xhr.open("GET", aService.location, true);
+ xhr.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING;
+ xhr.overrideMimeType("text/xml");
+
+ xhr.addEventListener("load", (function() {
+ if (xhr.status == 200) {
+ let doc = xhr.responseXML;
+ aService.appsURL = xhr.getResponseHeader("Application-URL");
+ if (aService.appsURL && !aService.appsURL.endsWith("/"))
+ aService.appsURL += "/";
+ aService.friendlyName = doc.querySelector("friendlyName").textContent;
+ aService.uuid = doc.querySelector("UDN").textContent;
+ aService.manufacturer = doc.querySelector("manufacturer").textContent;
+ aService.modelName = doc.querySelector("modelName").textContent;
+
+ this.addService(aService);
+ }
+ }).bind(this), false);
+
+ xhr.send(null);
+ },
+
+ // Add a service to the WeakMap, even if one already exists with this id.
+ // Returns true if this succeeded or false if it failed
+ _addService: function(service) {
+ // Filter out services that do not match the device filter
+ if (!this._filterService(service)) {
+ return false;
+ }
+
+ let device = this._devices.get(service.target);
+ if (device && device.mirror) {
+ service.mirror = true;
+ }
+ this._services.set(service.uuid, service);
+ return true;
+ },
+
+ addService: function(service) {
+ // Only add and notify if we don't already know about this service
+ if (!this._services.has(service.uuid)) {
+ if (!this._addService(service)) {
+ return;
+ }
+ Services.obs.notifyObservers(null, EVENT_SERVICE_FOUND, service.uuid);
+ }
+
+ // Make sure we remember this service is not stale
+ this._services.get(service.uuid).lastPing = this._searchTimestamp;
+ },
+
+ removeService: function(uuid) {
+ Services.obs.notifyObservers(null, EVENT_SERVICE_LOST, uuid);
+ this._services.delete(uuid);
+ },
+
+ updateService: function(service) {
+ if (!this._addService(service)) {
+ return;
+ }
+
+ // Make sure we remember this service is not stale
+ this._services.get(service.uuid).lastPing = this._searchTimestamp;
+ },
+
+ addExternalDiscovery: function(discovery) {
+ this._discoveryMethods.push(discovery);
+ },
+
+ _startExternalDiscovery: function() {
+ for (let discovery of this._discoveryMethods) {
+ discovery.startDiscovery();
+ }
+ },
+
+ _stopExternalDiscovery: function() {
+ for (let discovery of this._discoveryMethods) {
+ discovery.stopDiscovery();
+ }
+ },
+}