remote/components/RemoteAgent.sys.mjs

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
   6
   7 const lazy = {};
   8
   9 ChromeUtils.defineESModuleGetters(lazy, {
  10   CDP: "chrome://remote/content/cdp/CDP.sys.mjs",
  11   Deferred: "chrome://remote/content/shared/Sync.sys.mjs",
  12   Log: "chrome://remote/content/shared/Log.sys.mjs",
  13   WebDriverBiDi: "chrome://remote/content/webdriver-bidi/WebDriverBiDi.sys.mjs",
  14 });
  15
  16 XPCOMUtils.defineLazyModuleGetters(lazy, {
  17   HttpServer: "chrome://remote/content/server/HTTPD.jsm",
  18 });
  19
  20 XPCOMUtils.defineLazyServiceGetter(
  21   lazy,
  22   "DNSService",
  23   "@mozilla.org/network/dns-service;1",
  24   "nsIDNSService"
  25 );
  26
  27 XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
  28
  29 XPCOMUtils.defineLazyGetter(lazy, "activeProtocols", () => {
  30   const protocols = Services.prefs.getIntPref("remote.active-protocols");
  31   if (protocols < 1 || protocols > 3) {
  32     throw Error(`Invalid remote protocol identifier: ${protocols}`);
  33   }
  34
  35   return protocols;
  36 });
  37
  38 const WEBDRIVER_BIDI_ACTIVE = 0x1;
  39 const CDP_ACTIVE = 0x2;
  40
  41 const DEFAULT_HOST = "localhost";
  42 const DEFAULT_PORT = 9222;
  43
  44 const isRemote =
  45   Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT;
  46
  47 class RemoteAgentParentProcess {
  48   #allowHosts;
  49   #allowOrigins;
  50   #browserStartupFinished;
  51   #classID;
  52   #enabled;
  53   #host;
  54   #port;
  55   #server;
  56
  57   #cdp;
  58   #webDriverBiDi;
  59
  60   constructor() {
  61     this.#allowHosts = null;
  62     this.#allowOrigins = null;
  63     this.#browserStartupFinished = lazy.Deferred();
  64     this.#classID = Components.ID("{8f685a9d-8181-46d6-a71d-869289099c6d}");
  65     this.#enabled = false;
  66
  67     // Configuration for httpd.js
  68     this.#host = DEFAULT_HOST;
  69     this.#port = DEFAULT_PORT;
  70     this.#server = null;
  71
  72     // Supported protocols
  73     this.#cdp = null;
  74     this.#webDriverBiDi = null;
  75
  76     Services.ppmm.addMessageListener("RemoteAgent:IsRunning", this);
  77   }
  78
  79   get allowHosts() {
  80     if (this.#allowHosts !== null) {
  81       return this.#allowHosts;
  82     }
  83
  84     if (this.#server) {
  85       // If the server is bound to a hostname, not an IP address, return it as
  86       // allowed host.
  87       const hostUri = Services.io.newURI(`https://${this.#host}`);
  88       if (!this.#isIPAddress(hostUri)) {
  89         return [RemoteAgent.host];
  90       }
  91
  92       // Following Bug 1220810 localhost is guaranteed to resolve to a loopback
  93       // address (127.0.0.1 or ::1) unless network.proxy.allow_hijacking_localhost
  94       // is set to true, which should not be the case.
  95       const loopbackAddresses = ["127.0.0.1", "[::1]"];
  96
  97       // If the server is bound to an IP address and this IP address is a localhost
  98       // loopback address, return localhost as allowed host.
  99       if (loopbackAddresses.includes(this.#host)) {
 100         return ["localhost"];
 101       }
 102     }
 103
 104     // Otherwise return an empty array.
 105     return [];
 106   }
 107
 108   get allowOrigins() {
 109     return this.#allowOrigins;
 110   }
 111
 112   /**
 113    * A promise that resolves when the initial application window has been opened.
 114    *
 115    * @returns {Promise}
 116    *     Promise that resolves when the initial application window is open.
 117    */
 118   get browserStartupFinished() {
 119     return this.#browserStartupFinished.promise;
 120   }
 121
 122   get cdp() {
 123     return this.#cdp;
 124   }
 125
 126   get debuggerAddress() {
 127     if (!this.#server) {
 128       return "";
 129     }
 130
 131     return `${this.#host}:${this.#port}`;
 132   }
 133
 134   get enabled() {
 135     return this.#enabled;
 136   }
 137
 138   get host() {
 139     return this.#host;
 140   }
 141
 142   get port() {
 143     return this.#port;
 144   }
 145
 146   get running() {
 147     return !!this.#server && !this.#server.isStopped();
 148   }
 149
 150   get scheme() {
 151     return this.#server?.identity.primaryScheme;
 152   }
 153
 154   get server() {
 155     return this.#server;
 156   }
 157
 158   get webDriverBiDi() {
 159     return this.#webDriverBiDi;
 160   }
 161
 162   /**
 163    * Check if the provided URI's host is an IP address.
 164    *
 165    * @param {nsIURI} uri
 166    *     The URI to check.
 167    * @return {boolean}
 168    */
 169   #isIPAddress(uri) {
 170     try {
 171       // getBaseDomain throws an explicit error if the uri host is an IP address.
 172       Services.eTLD.getBaseDomain(uri);
 173     } catch (e) {
 174       return e.result == Cr.NS_ERROR_HOST_IS_IP_ADDRESS;
 175     }
 176     return false;
 177   }
 178
 179   handle(cmdLine) {
 180     // remote-debugging-port has to be consumed in nsICommandLineHandler:handle
 181     // to avoid issues on macos. See Marionette.jsm::handle() for more details.
 182     // TODO: remove after Bug 1724251 is fixed.
 183     try {
 184       cmdLine.handleFlagWithParam("remote-debugging-port", false);
 185     } catch (e) {
 186       cmdLine.handleFlag("remote-debugging-port", false);
 187     }
 188   }
 189
 190   async #listen(port) {
 191     if (Services.appinfo.processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT) {
 192       throw Components.Exception(
 193         "May only be instantiated in parent process",
 194         Cr.NS_ERROR_LAUNCHED_CHILD_PROCESS
 195       );
 196     }
 197
 198     if (this.running) {
 199       return;
 200     }
 201
 202     // Try to resolve localhost to an IPv4  and / or IPv6 address so that the
 203     // server can be started on a given IP. Only fallback to use localhost if
 204     // the hostname cannot be resolved.
 205     //
 206     // Note: This doesn't force httpd.js to use the dual stack support.
 207     let isIPv4Host = false;
 208     try {
 209       const addresses = await this.#resolveHostname(DEFAULT_HOST);
 210       lazy.logger.trace(
 211         `Available local IP addresses: ${addresses.join(", ")}`
 212       );
 213
 214       // Prefer IPv4 over IPv6 addresses.
 215       const addressesIPv4 = addresses.filter(value => !value.includes(":"));
 216       isIPv4Host = !!addressesIPv4.length;
 217       if (isIPv4Host) {
 218         this.#host = addressesIPv4[0];
 219       } else {
 220         this.#host = addresses.length ? addresses[0] : DEFAULT_HOST;
 221       }
 222     } catch (e) {
 223       this.#host = DEFAULT_HOST;
 224
 225       lazy.logger.debug(
 226         `Failed to resolve hostname "localhost" to IP address: ${e.message}`
 227       );
 228     }
 229
 230     // nsIServerSocket uses -1 for atomic port allocation
 231     if (port === 0) {
 232       port = -1;
 233     }
 234
 235     try {
 236       // Bug 1783938: httpd.js refuses connections when started on a IPv4
 237       // address. As workaround start on localhost and add another identity
 238       // for that IP address.
 239       this.#server = new lazy.HttpServer();
 240       const host = isIPv4Host ? DEFAULT_HOST : this.#host;
 241       this.server._start(port, host);
 242       this.#port = this.server._port;
 243
 244       if (isIPv4Host) {
 245         this.server.identity.add("http", this.#host, this.#port);
 246       }
 247
 248       Services.obs.notifyObservers(null, "remote-listening", true);
 249
 250       await Promise.all([this.#webDriverBiDi?.start(), this.#cdp?.start()]);
 251     } catch (e) {
 252       await this.#stop();
 253       lazy.logger.error(`Unable to start remote agent: ${e.message}`, e);
 254     }
 255   }
 256
 257   /**
 258    * Resolves a hostname to one or more IP addresses.
 259    *
 260    * @param {string} hostname
 261    *
 262    * @returns {Array<string>}
 263    */
 264   #resolveHostname(hostname) {
 265     return new Promise((resolve, reject) => {
 266       let originalRequest;
 267
 268       const onLookupCompleteListener = {
 269         onLookupComplete(request, record, status) {
 270           if (request === originalRequest) {
 271             if (!Components.isSuccessCode(status)) {
 272               reject({ message: ChromeUtils.getXPCOMErrorName(status) });
 273               return;
 274             }
 275
 276             record.QueryInterface(Ci.nsIDNSAddrRecord);
 277
 278             const addresses = [];
 279             while (record.hasMore()) {
 280               let addr = record.getNextAddrAsString();
 281               if (addr.includes(":") && !addr.startsWith("[")) {
 282                 // Make sure that the IPv6 address is wrapped with brackets.
 283                 addr = `[${addr}]`;
 284               }
 285               if (!addresses.includes(addr)) {
 286                 // Sometimes there are duplicate records with the same IP.
 287                 addresses.push(addr);
 288               }
 289             }
 290
 291             resolve(addresses);
 292           }
 293         },
 294       };
 295
 296       try {
 297         originalRequest = lazy.DNSService.asyncResolve(
 298           hostname,
 299           Ci.nsIDNSService.RESOLVE_TYPE_DEFAULT,
 300           Ci.nsIDNSService.RESOLVE_BYPASS_CACHE,
 301           null,
 302           onLookupCompleteListener,
 303           null, //Services.tm.mainThread,
 304           {} /* defaultOriginAttributes */
 305         );
 306       } catch (e) {
 307         reject({ message: e.message });
 308       }
 309     });
 310   }
 311
 312   async #stop() {
 313     if (!this.running) {
 314       return;
 315     }
 316
 317     try {
 318       // Stop the CDP support before stopping the server.
 319       // Otherwise the HTTP server will fail to stop.
 320       await this.#cdp?.stop();
 321       await this.#webDriverBiDi?.stop();
 322
 323       await this.#server.stop();
 324       this.#server = null;
 325       Services.obs.notifyObservers(null, "remote-listening");
 326     } catch (e) {
 327       // this function must never fail
 328       lazy.logger.error("unable to stop listener", e);
 329     }
 330   }
 331
 332   /**
 333    * Handle the --remote-debugging-port command line argument.
 334    *
 335    * @param {nsICommandLine} cmdLine
 336    *     Instance of the command line interface.
 337    *
 338    * @return {boolean}
 339    *     Return `true` if the command line argument has been found.
 340    */
 341   handleRemoteDebuggingPortFlag(cmdLine) {
 342     let enabled = false;
 343
 344     try {
 345       // Catch cases when the argument, and a port have been specified.
 346       const port = cmdLine.handleFlagWithParam("remote-debugging-port", false);
 347       if (port !== null) {
 348         enabled = true;
 349
 350         // In case of an invalid port keep the default port
 351         const parsed = Number(port);
 352         if (!isNaN(parsed)) {
 353           this.#port = parsed;
 354         }
 355       }
 356     } catch (e) {
 357       // If no port has been given check for the existence of the argument.
 358       enabled = cmdLine.handleFlag("remote-debugging-port", false);
 359     }
 360
 361     return enabled;
 362   }
 363
 364   handleAllowHostsFlag(cmdLine) {
 365     try {
 366       const hosts = cmdLine.handleFlagWithParam("remote-allow-hosts", false);
 367       return hosts.split(",");
 368     } catch (e) {
 369       return null;
 370     }
 371   }
 372
 373   handleAllowOriginsFlag(cmdLine) {
 374     try {
 375       const origins = cmdLine.handleFlagWithParam(
 376         "remote-allow-origins",
 377         false
 378       );
 379       return origins.split(",");
 380     } catch (e) {
 381       return null;
 382     }
 383   }
 384
 385   async observe(subject, topic) {
 386     if (this.#enabled) {
 387       lazy.logger.trace(`Received observer notification ${topic}`);
 388     }
 389
 390     switch (topic) {
 391       case "profile-after-change":
 392         Services.obs.addObserver(this, "command-line-startup");
 393         break;
 394
 395       case "command-line-startup":
 396         Services.obs.removeObserver(this, topic);
 397
 398         this.#enabled = this.handleRemoteDebuggingPortFlag(subject);
 399
 400         if (this.#enabled) {
 401           Services.obs.addObserver(this, "final-ui-startup");
 402
 403           this.#allowHosts = this.handleAllowHostsFlag(subject);
 404           this.#allowOrigins = this.handleAllowOriginsFlag(subject);
 405
 406           Services.obs.addObserver(this, "browser-idle-startup-tasks-finished");
 407           Services.obs.addObserver(this, "mail-idle-startup-tasks-finished");
 408           Services.obs.addObserver(this, "quit-application");
 409
 410           // With Bug 1717899 we will extend the lifetime of the Remote Agent to
 411           // the whole Firefox session, which will be identical to Marionette. For
 412           // now prevent logging if the component is not enabled during startup.
 413           if (
 414             (lazy.activeProtocols & WEBDRIVER_BIDI_ACTIVE) ===
 415             WEBDRIVER_BIDI_ACTIVE
 416           ) {
 417             this.#webDriverBiDi = new lazy.WebDriverBiDi(this);
 418             if (this.#enabled) {
 419               lazy.logger.debug("WebDriver BiDi enabled");
 420             }
 421           }
 422
 423           if ((lazy.activeProtocols & CDP_ACTIVE) === CDP_ACTIVE) {
 424             this.#cdp = new lazy.CDP(this);
 425             if (this.#enabled) {
 426               lazy.logger.debug("CDP enabled");
 427             }
 428           }
 429         }
 430         break;
 431
 432       case "final-ui-startup":
 433         Services.obs.removeObserver(this, topic);
 434
 435         try {
 436           await this.#listen(this.#port);
 437         } catch (e) {
 438           throw Error(`Unable to start remote agent: ${e}`);
 439         }
 440
 441         break;
 442
 443       // Used to wait until the initial application window has been opened.
 444       case "browser-idle-startup-tasks-finished":
 445       case "mail-idle-startup-tasks-finished":
 446         Services.obs.removeObserver(
 447           this,
 448           "browser-idle-startup-tasks-finished"
 449         );
 450         Services.obs.removeObserver(this, "mail-idle-startup-tasks-finished");
 451         this.#browserStartupFinished.resolve();
 452         break;
 453
 454       // Listen for application shutdown to also shutdown the Remote Agent
 455       // and a possible running instance of httpd.js.
 456       case "quit-application":
 457         Services.obs.removeObserver(this, topic);
 458         this.#stop();
 459         break;
 460     }
 461   }
 462
 463   receiveMessage({ name }) {
 464     switch (name) {
 465       case "RemoteAgent:IsRunning":
 466         return this.running;
 467
 468       default:
 469         lazy.logger.warn("Unknown IPC message to parent process: " + name);
 470         return null;
 471     }
 472   }
 473
 474   // XPCOM
 475
 476   get classID() {
 477     return this.#classID;
 478   }
 479
 480   get helpInfo() {
 481     return `  --remote-debugging-port [<port>] Start the Firefox Remote Agent,
 482                      which is a low-level remote debugging interface used for WebDriver
 483                      BiDi and CDP. Defaults to port 9222.
 484   --remote-allow-hosts <hosts> Values of the Host header to allow for incoming requests.
 485                      Please read security guidelines at https://firefox-source-docs.mozilla.org/remote/Security.html
 486   --remote-allow-origins <origins> Values of the Origin header to allow for incoming requests.
 487                      Please read security guidelines at https://firefox-source-docs.mozilla.org/remote/Security.html\n`;
 488   }
 489
 490   get QueryInterface() {
 491     return ChromeUtils.generateQI([
 492       "nsICommandLineHandler",
 493       "nsIObserver",
 494       "nsIRemoteAgent",
 495     ]);
 496   }
 497 }
 498
 499 class RemoteAgentContentProcess {
 500   #classID;
 501
 502   constructor() {
 503     this.#classID = Components.ID("{8f685a9d-8181-46d6-a71d-869289099c6d}");
 504   }
 505
 506   get running() {
 507     let reply = Services.cpmm.sendSyncMessage("RemoteAgent:IsRunning");
 508     if (!reply.length) {
 509       lazy.logger.warn("No reply from parent process");
 510       return false;
 511     }
 512     return reply[0];
 513   }
 514
 515   get QueryInterface() {
 516     return ChromeUtils.generateQI(["nsIRemoteAgent"]);
 517   }
 518 }
 519
 520 export var RemoteAgent;
 521 if (isRemote) {
 522   RemoteAgent = new RemoteAgentContentProcess();
 523 } else {
 524   RemoteAgent = new RemoteAgentParentProcess();
 525 }
 526
 527 // This is used by the XPCOM codepath which expects a constructor
 528 export var RemoteAgentFactory = function() {
 529   return RemoteAgent;
 530 };