[tor-commits] [Git][tpo/applications/tor-browser][tor-browser-115.1.0esr-13.0-1] 2 commits: squash! Bug 40933: Add tor-launcher functionality

Pier Angelo Vendrame pushed to branch tor-browser-115.1.0esr-13.0-1 at The Tor Project / Applications / Tor Browser

Commits:

57b25177

by Pier Angelo Vendrame at 2023-08-04T20:02:03+02:00

squash! Bug 40933: Add tor-launcher functionality

Bug 41926: Reimplement the control port

9722ca26

by Pier Angelo Vendrame at 2023-08-04T20:02:04+02:00

fixup! Bug 10760: Integrate TorButton to TorBrowser core

Removed torbutton.js, tor-control-port.js and utils.js.

13 changed files:

browser/base/content/browser.xhtml
+ toolkit/components/tor-launcher/TorControlPort.sys.mjs
toolkit/components/tor-launcher/TorMonitorService.sys.mjs
toolkit/components/tor-launcher/TorProtocolService.sys.mjs
toolkit/components/tor-launcher/moz.build
− toolkit/torbutton/chrome/content/torbutton.js
− toolkit/torbutton/components.conf
toolkit/torbutton/jar.mn
− toolkit/torbutton/modules/TorbuttonLogger.jsm
− toolkit/torbutton/modules/tor-control-port.js
− toolkit/torbutton/modules/utils.js
toolkit/torbutton/moz.build
tools/lint/eslint/eslint-plugin-mozilla/lib/environments/browser-window.js

Changes:

browser/base/content/browser.xhtml

@@ -130,17 +130,11 @@
    Services.scriptloader.loadSubScript("chrome://browser/content/search/autocomplete-popup.js", this);
    Services.scriptloader.loadSubScript("chrome://browser/content/search/searchbar.js", this);
    Services.scriptloader.loadSubScript("chrome://browser/content/languageNotification.js", this);
 -  Services.scriptloader.loadSubScript("chrome://torbutton/content/torbutton.js", this);
    window.onload = gBrowserInit.onLoad.bind(gBrowserInit);
    window.onunload = gBrowserInit.onUnload.bind(gBrowserInit);
    window.onclose = WindowIsClosing;
 -  //onLoad Handler
 -  try {
 -    window.addEventListener("load", torbutton_init);
 -  } catch (e) {}
+-
    window.addEventListener("MozBeforeInitialXULLayout",
      gBrowserInit.onBeforeInitialXULLayout.bind(gBrowserInit), { once: true });

toolkit/components/tor-launcher/TorControlPort.sys.mjs

 +import { TorParsers } from "resource://gre/modules/TorParsers.sys.mjs";
++
 +/**
 + * @callback MessageCallback A callback to receive messages from the control
 + * port.
 + * @param {string} message The message to handle
 + */
 +/**
 + * @callback RemoveCallback A function used to remove a previously registered
 + * callback.
 + */
++
 +class CallbackDispatcher {
 +  #callbackPairs = [];
++
 +  /**
 +   * Register a callback to handle a certain type of responses.
 +   *
 +   * @param {RegExp} regex The regex that tells which messages the callback
 +   * wants to handle.
 +   * @param {MessageCallback} callback The function to call
 +   * @returns {RemoveCallback} A function to remove the just added callback
 +   */
 +  addCallback(regex, callback) {
 +    this.#callbackPairs.push([regex, callback]);
 +  }
++
 +  /**
 +   * Push a certain message to all the callbacks whose regex matches it.
 +   *
 +   * @param {string} message The message to push to the callbacks
 +   */
 +  pushMessage(message) {
 +    for (const [regex, callback] of this.#callbackPairs) {
 +      if (message.match(regex)) {
 +        callback(message);
 +      }
 +    }
 +  }
 +}
++
 +/**
 + * A wrapper around XPCOM sockets and buffers to handle streams in a standard
 + * async JS fashion.
 + * This class can handle both Unix sockets and TCP sockets.
 + */
 +class AsyncSocket {
 +  /**
 +   * The output stream used for write operations.
 +   *
 +   * @type {nsIAsyncOutputStream}
 +   */
 +  #outputStream;
 +  /**
 +   * The output stream can only have one registered callback at a time, so
 +   * multiple writes need to be queued up (see nsIAsyncOutputStream.idl).
 +   * Every item is associated with a promise we returned in write, and it will
 +   * resolve it or reject it when called by the output stream.
 +   *
 +   * @type {nsIOutputStreamCallback[]}
 +   */
 +  #outputQueue = [];
 +  /**
 +   * The input stream.
 +   *
 +   * @type {nsIAsyncInputStream}
 +   */
 +  #inputStream;
 +  /**
 +   * An input stream adapter that makes reading from scripts easier.
 +   *
 +   * @type {nsIScriptableInputStream}
 +   */
 +  #scriptableInputStream;
 +  /**
 +   * The queue of callbacks to be used when we receive data.
 +   * Every item is associated with a promise we returned in read, and it will
 +   * resolve it or reject it when called by the input stream.
 +   *
 +   * @type {nsIInputStreamCallback[]}
 +   */
 +  #inputQueue = [];
++
 +  /**
 +   * Connect to a Unix socket. Not available on Windows.
 +   *
 +   * @param {nsIFile} ipcFile The path to the Unix socket to connect to.
 +   */
 +  static fromIpcFile(ipcFile) {
 +    const sts = Cc[
 +      "@mozilla.org/network/socket-transport-service;1"
 +    ].getService(Ci.nsISocketTransportService);
 +    const socket = new AsyncSocket();
 +    const transport = sts.createUnixDomainTransport(ipcFile);
 +    socket.#createStreams(transport);
 +    return socket;
 +  }
++
 +  /**
 +   * Connect to a TCP socket.
 +   *
 +   * @param {string} host The hostname to connect the TCP socket to.
 +   * @param {number} port The port to connect the TCP socket to.
 +   */
 +  static fromSocketAddress(host, port) {
 +    const sts = Cc[
 +      "@mozilla.org/network/socket-transport-service;1"
 +    ].getService(Ci.nsISocketTransportService);
 +    const socket = new AsyncSocket();
 +    const transport = sts.createTransport([], host, port, null, null);
 +    socket.#createStreams(transport);
 +    return socket;
 +  }
++
 +  #createStreams(socketTransport) {
 +    const OPEN_UNBUFFERED = Ci.nsITransport.OPEN_UNBUFFERED;
 +    this.#outputStream = socketTransport
 +      .openOutputStream(OPEN_UNBUFFERED, 1, 1)
 +      .QueryInterface(Ci.nsIAsyncOutputStream);
++
 +    this.#inputStream = socketTransport
 +      .openInputStream(OPEN_UNBUFFERED, 1, 1)
 +      .QueryInterface(Ci.nsIAsyncInputStream);
 +    this.#scriptableInputStream = Cc[
 +      "@mozilla.org/scriptableinputstream;1"
 +    ].createInstance(Ci.nsIScriptableInputStream);
 +    this.#scriptableInputStream.init(this.#inputStream);
 +  }
++
 +  /**
 +   * Asynchronously write string to underlying socket.
 +   *
 +   * When write is called, we create a new promise and queue it on the output
 +   * queue. If it is the only element in the queue, we ask the output stream to
 +   * run it immediately.
 +   * Otherwise, the previous item of the queue will run it after it finishes.
 +   *
 +   * @param {string} str The string to write to the socket. The underlying
 +   * implementation shoulw convert JS strings (UTF-16) into UTF-8 strings.
 +   * See also write nsIOutputStream (the first argument is a string, not a
 +   * wstring).
 +   * @returns {Promise<number>} The number of written bytes
 +   */
 +  async write(str) {
 +    return new Promise((resolve, reject) => {
 +      // asyncWait next write request
 +      const tryAsyncWait = () => {
 +        if (this.#outputQueue.length) {
 +          this.#outputStream.asyncWait(
 +            this.#outputQueue.at(0), // next request
 +            0,
 +            0,
 +            Services.tm.currentThread
 +          );
 +        }
 +      };
++
 +      // Implement an nsIOutputStreamCallback: write the string once possible,
 +      // and then start running the following queue item, if any.
 +      this.#outputQueue.push({
 +        onOutputStreamReady: () => {
 +          try {
 +            const bytesWritten = this.#outputStream.write(str, str.length);
++
 +            // remove this callback object from queue as it is now completed
 +            this.#outputQueue.shift();
++
 +            // request next wait if there is one
 +            tryAsyncWait();
++
 +            // finally resolve promise
 +            resolve(bytesWritten);
 +          } catch (err) {
 +            // reject promise on error
 +            reject(err);
 +          }
 +        },
 +      });
++
 +      // Length 1 imples that there is no in-flight asyncWait, so we may
 +      // immediately follow through on this write.
 +      if (this.#outputQueue.length === 1) {
 +        tryAsyncWait();
 +      }
 +    });
 +  }
++
 +  /**
 +   * Asynchronously read string from underlying socket and return it.
 +   *
 +   * When read is called, we create a new promise and queue it on the input
 +   * queue. If it is the only element in the queue, we ask the input stream to
 +   * run it immediately.
 +   * Otherwise, the previous item of the queue will run it after it finishes.
 +   *
 +   * This function is expected to throw when the underlying socket has been
 +   * closed.
 +   *
 +   * @returns {Promise<string>} The read string
 +   */
 +  async read() {
 +    return new Promise((resolve, reject) => {
 +      const tryAsyncWait = () => {
 +        if (this.#inputQueue.length) {
 +          this.#inputStream.asyncWait(
 +            this.#inputQueue.at(0), // next input request
 +            0,
 +            0,
 +            Services.tm.currentThread
 +          );
 +        }
 +      };
++
 +      this.#inputQueue.push({
 +        onInputStreamReady: stream => {
 +          try {
 +            if (!this.#scriptableInputStream.available()) {
 +              // This means EOF, but not closed yet. However, arriving at EOF
 +              // should be an error condition for us, since we are in a socket,
 +              // and EOF should mean peer disconnected.
 +              // If the stream has been closed, this function itself should
 +              // throw.
 +              reject(
 +                new Error("onInputStreamReady called without available bytes.")
 +              );
 +              return;
 +            }
++
 +            // Read our string from input stream.
 +            const str = this.#scriptableInputStream.read(
 +              this.#scriptableInputStream.available()
 +            );
++
 +            // Remove this callback object from queue now that we have read.
 +            this.#inputQueue.shift();
++
 +            // Start waiting for incoming data again if the reading queue is not
 +            // empty.
 +            tryAsyncWait();
++
 +            // Finally resolve the promise.
 +            resolve(str);
 +          } catch (err) {
 +            // E.g., we received a NS_BASE_STREAM_CLOSED because the socket was
 +            // closed.
 +            reject(err);
 +          }
 +        },
 +      });
++
 +      // Length 1 imples that there is no in-flight asyncWait, so we may
 +      // immediately follow through on this read.
 +      if (this.#inputQueue.length === 1) {
 +        tryAsyncWait();
 +      }
 +    });
 +  }
++
 +  /**
 +   * Close the streams.
 +   */
 +  close() {
 +    this.#outputStream.close();
 +    this.#inputStream.close();
 +  }
 +}
++
 +/**
 + * @typedef Command
 + * @property {string} commandString The string to send over the control port
 + * @property {Function} resolve The function to resolve the promise with the
 + * response we got on the control port
 + * @property {Function} reject The function to reject the promise associated to
 + * the command
 + */
++
 +class TorError extends Error {
 +  constructor(command, reply) {
 +    super(`${command} -> ${reply}`);
 +    this.name = "TorError";
 +    const info = reply.match(/(?<code>\d{3})(?:\s(?<message>.+))?/);
 +    this.torStatusCode = info.groups.code;
 +    if (info.groups.message) {
 +      this.torMessage = info.groups.message;
 +    }
 +  }
 +}
++
 +class ControlSocket {
 +  /**
 +   * The socket to write to the control port.
 +   *
 +   * @type {AsyncSocket}
 +   */
 +  #socket;
++
 +  /**
 +   * The dispatcher used for the data we receive over the control port.
 +   *
 +   * @type {CallbackDispatcher}
 +   */
 +  #mainDispatcher = new CallbackDispatcher();
 +  /**
 +   * A secondary dispatcher used only to dispatch aynchronous events.
 +   *
 +   * @type {CallbackDispatcher}
 +   */
 +  #notificationDispatcher = new CallbackDispatcher();
++
 +  /**
 +   * Data we received on a read but that was not a complete line (missing a
 +   * final CRLF). We will prepend it to the next read.
 +   *
 +   * @type {string}
 +   */
 +  #pendingData = "";
 +  /**
 +   * The lines we received and are still queued for being evaluated.
 +   *
 +   * @type {string[]}
 +   */
 +  #pendingLines = [];
 +  /**
 +   * The commands that need to be run or receive a response.
 +   *
 +   * @type {Command[]}
 +   */
 +  #commandQueue = [];
++
 +  constructor(asyncSocket) {
 +    this.#socket = asyncSocket;
++
 +    // #mainDispatcher pushes only async notifications (650) to
 +    // #notificationDispatcher
 +    this.#mainDispatcher.addCallback(
 +      /^650/,
 +      this.#handleNotification.bind(this)
 +    );
 +    // callback for handling responses and errors
 +    this.#mainDispatcher.addCallback(
 +      /^[245]\d\d/,
 +      this.#handleCommandReply.bind(this)
 +    );
++
 +    this.#startMessagePump();
 +  }
++
 +  /**
 +   * Return the next line in the queue. If there is not any, block until one is
 +   * read (or until a communication error happens, including the underlying
 +   * socket being closed while it was still waiting for data).
 +   * Any letfovers will be prepended to the next read.
 +   *
 +   * @returns {Promise<string>} A line read over the socket
 +   */
 +  async #readLine() {
 +    // Keep reading from socket until we have at least a full line to return.
 +    while (!this.#pendingLines.length) {
 +      if (!this.#socket) {
 +        throw new Error(
 +          "Read interrupted because the control socket is not available anymore"
 +        );
 +      }
 +      // Read data from our socket and split on newline tokens.
 +      // This might still throw when the socket has been closed.
 +      this.#pendingData += await this.#socket.read();
 +      const lines = this.#pendingData.split("\r\n");
 +      // The last line will either be empty string, or a partial read of a
 +      // response/event so save it off for the next socket read.
 +      this.#pendingData = lines.pop();
 +      // Copy remaining full lines to our pendingLines list.
 +      this.#pendingLines = this.#pendingLines.concat(lines);
 +    }
 +    return this.#pendingLines.shift();
 +  }
++
 +  /**
 +   * Blocks until an entire message is ready and returns it.
 +   * This function does a rudimentary parsing of the data only to handle
 +   * multi-line responses.
 +   *
 +   * @returns {Promise<string>} The read message (without the final CRLF)
 +   */
 +  async #readMessage() {
 +    // whether we are searching for the end of a multi-line values
 +    // See control-spec section 3.9
 +    let handlingMultlineValue = false;
 +    let endOfMessageFound = false;
 +    const message = [];
++
 +    do {
 +      const line = await this.#readLine();
 +      message.push(line);
++
 +      if (handlingMultlineValue) {
 +        // look for end of multiline
 +        if (line === ".") {
 +          handlingMultlineValue = false;
 +        }
 +      } else {
 +        // 'Multiline values' are possible. We avoid interrupting one by
 +        // detecting it and waiting for a terminating "." on its own line.
 +        // (See control-spec section 3.9 and
 +        // https://gitlab.torproject.org/tpo/applications/tor-browser/-/issues/16990#note_2625464).
 +        // Ensure this is the first line of a new message
 +        // eslint-disable-next-line no-lonely-if
 +        if (message.length === 1 && line.match(/^\d\d\d\+.+?=$/)) {
 +          handlingMultlineValue = true;
 +        }
 +        // look for end of message (notice the space character at end of the
 +        // regex!)
 +        else if (line.match(/^\d\d\d /)) {
 +          if (message.length === 1) {
 +            endOfMessageFound = true;
 +          } else {
 +            const firstReplyCode = message[0].substring(0, 3);
 +            const lastReplyCode = line.substring(0, 3);
 +            endOfMessageFound = firstReplyCode === lastReplyCode;
 +          }
 +        }
 +      }
 +    } while (!endOfMessageFound);
++
 +    // join our lines back together to form one message
 +    return message.join("\r\n");
 +  }
++
 +  /**
 +   * Read messages on the socket and routed them to a dispatcher until the
 +   * socket is open or some error happens (including the underlying socket being
 +   * closed).
 +   */
 +  async #startMessagePump() {
 +    try {
 +      // This while is inside the try block because it is very likely that it
 +      // will be broken by a NS_BASE_STREAM_CLOSED exception, rather than by its
 +      // condition becoming false.
 +      while (this.#socket) {
 +        const message = await this.#readMessage();
 +        // log("controlPort >> " + message);
 +        this.#mainDispatcher.pushMessage(message);
 +      }
 +    } catch (err) {
 +      try {
 +        this.#close(err);
 +      } catch (ec) {
 +        console.error(
 +          "Caught another error while closing the control socket.",
 +          ec
 +        );
 +      }
 +    }
 +  }
++
 +  /**
 +   * Start running the first available command in the queue.
 +   * To be called when the previous one has finished running.
 +   * This makes sure to avoid conflicts when using the control port.
 +   */
 +  #writeNextCommand() {
 +    const cmd = this.#commandQueue[0];
 +    // log("controlPort << " + cmd.commandString);
 +    this.#socket.write(`${cmd.commandString}\r\n`).catch(cmd.reject);
 +  }
++
 +  /**
 +   * Send a command over the control port.
 +   * This function returns only when it receives a complete message over the
 +   * control port. This class does some rudimentary parsing to check wheter it
 +   * needs to handle multi-line messages.
 +   *
 +   * @param {string} commandString
 +   * @returns {Promise<string>} The message sent by the control port. It will
 +   * always start with 2xx. In case of other codes the function will throw,
 +   * instead. This means that the return value will never be an empty string
 +   * (even though it will not include the final CRLF).
 +   */
 +  async sendCommand(commandString) {
 +    if (!this.#socket) {
 +      throw new Error("ControlSocket not open");
 +    }
++
 +    // this promise is resolved either in #handleCommandReply, or in
 +    // #startMessagePump (on stream error)
 +    return new Promise((resolve, reject) => {
 +      const command = {
 +        commandString,
 +        resolve,
 +        reject,
 +      };
 +      this.#commandQueue.push(command);
 +      if (this.#commandQueue.length === 1) {
 +        this.#writeNextCommand();
 +      }
 +    });
 +  }
++
 +  /**
 +   * Handles a message starting with 2xx, 4xx, or 5xx.
 +   * This function should be used only as a callback for the main dispatcher.
 +   *
 +   * @param {string} message The message to handle
 +   */
 +  #handleCommandReply(message) {
 +    const cmd = this.#commandQueue.shift();
 +    if (message[0] === "2") {
 +      cmd.resolve(message);
 +    } else if (message.match(/^[45]/)) {
 +      cmd.reject(new TorError(cmd.commandString, message));
 +    } else {
 +      // This should never happen, as the dispatcher should filter the messages
 +      // already.
 +      cmd.reject(
 +        new Error(`Received unexpected message:\n----\n${message}\n----`)
 +      );
 +    }
++
 +    // send next command if one is available
 +    if (this.#commandQueue.length) {
 +      this.#writeNextCommand();
 +    }
 +  }
++
 +  /**
 +   * Re-route an event message to the notification dispatcher.
 +   * This function should be used only as a callback for the main dispatcher.
 +   *
 +   * @param {string} message The message received on the control port
 +   */
 +  #handleNotification(message) {
 +    try {
 +      this.#notificationDispatcher.pushMessage(message);
 +    } catch (e) {
 +      console.error("An event watcher threw", e);
 +    }
 +  }
++
 +  /**
 +   * Reject all the commands that are still in queue and close the control
 +   * socket.
 +   *
 +   * @param {object?} reason An error object used to pass a more specific
 +   * rejection reason to the commands that are still queued.
 +   */
 +  #close(reason) {
 +    const error = new Error(
 +      "The control socket has been closed" +
 +        (reason ? `: ${reason.message}` : "")
 +    );
 +    const commands = this.#commandQueue;
 +    this.#commandQueue = [];
 +    for (const cmd of commands) {
 +      cmd.reject(error);
 +    }
 +    try {
 +      this.#socket?.close();
 +    } finally {
 +      this.#socket = null;
 +    }
 +  }
++
 +  /**
 +   * Closes the socket connected to the control port.
 +   */
 +  close() {
 +    this.#close(null);
 +  }
++
 +  /**
 +   * Register an event watcher.
 +   *
 +   * @param {RegExp} regex The regex to filter on messages to receive
 +   * @param {MessageCallback} callback The callback for the messages
 +   */
 +  addNotificationCallback(regex, callback) {
 +    this.#notificationDispatcher.addCallback(regex, callback);
 +  }
++
 +  /**
 +   * Tells whether the underlying socket is still open.
 +   */
 +  get isOpen() {
 +    return !!this.#socket;
 +  }
 +}
++
 +// ## utils
 +// A namespace for utility functions
 +let utils = {};
++
 +// __utils.identity(x)__.
 +// Returns its argument unchanged.
 +utils.identity = function (x) {
 +  return x;
 +};
++
 +// __utils.capture(string, regex)__.
 +// Takes a string and returns an array of capture items, where regex must have a single
 +// capturing group and use the suffix /.../g to specify a global search.
 +utils.capture = function (string, regex) {
 +  let matches = [];
 +  // Special trick to use string.replace for capturing multiple matches.
 +  string.replace(regex, function (a, captured) {
 +    matches.push(captured);
 +  });
 +  return matches;
 +};
++
 +// __utils.extractor(regex)__.
 +// Returns a function that takes a string and returns an array of regex matches. The
 +// regex must use the suffix /.../g to specify a global search.
 +utils.extractor = function (regex) {
 +  return function (text) {
 +    return utils.capture(text, regex);
 +  };
 +};
++
 +// __utils.splitLines(string)__.
 +// Splits a string into an array of strings, each corresponding to a line.
 +utils.splitLines = function (string) {
 +  return string.split(/\r?\n/);
 +};
++
 +// __utils.splitAtSpaces(string)__.
 +// Splits a string into chunks between spaces. Does not split at spaces
 +// inside pairs of quotation marks.
 +utils.splitAtSpaces = utils.extractor(/((\S*?"(.*?)")+\S*|\S+)/g);
++
 +// __utils.splitAtFirst(string, regex)__.
 +// Splits a string at the first instance of regex match. If no match is
 +// found, returns the whole string.
 +utils.splitAtFirst = function (string, regex) {
 +  let match = string.match(regex);
 +  return match
 +    ? [
 +        string.substring(0, match.index),
 +        string.substring(match.index + match[0].length),
 +      ]
 +    : string;
 +};
++
 +// __utils.splitAtEquals(string)__.
 +// Splits a string into chunks between equals. Does not split at equals
 +// inside pairs of quotation marks.
 +utils.splitAtEquals = utils.extractor(/(([^=]*?"(.*?)")+[^=]*|[^=]+)/g);
++
 +// __utils.mergeObjects(arrayOfObjects)__.
 +// Takes an array of objects like [{"a":"b"},{"c":"d"}] and merges to a single object.
 +// Pure function.
 +utils.mergeObjects = function (arrayOfObjects) {
 +  let result = {};
 +  for (let obj of arrayOfObjects) {
 +    for (let key in obj) {
 +      result[key] = obj[key];
 +    }
 +  }
 +  return result;
 +};
++
 +// __utils.listMapData(parameterString, listNames)__.
 +// Takes a list of parameters separated by spaces, of which the first several are
 +// unnamed, and the remainder are named, in the form `NAME=VALUE`. Apply listNames
 +// to the unnamed parameters, and combine them in a map with the named parameters.
 +// Example: `40 FAILED 0 95.78.59.36:80 REASON=CANT_ATTACH`
 +//
 +//     utils.listMapData("40 FAILED 0 95.78.59.36:80 REASON=CANT_ATTACH",
 +//                       ["streamID", "event", "circuitID", "IP"])
 +//     // --> {"streamID" : "40", "event" : "FAILED", "circuitID" : "0",
 +//     //      "address" : "95.78.59.36:80", "REASON" : "CANT_ATTACH"}"
 +utils.listMapData = function (parameterString, listNames) {
 +  // Split out the space-delimited parameters.
 +  let parameters = utils.splitAtSpaces(parameterString),
 +    dataMap = {};
 +  // Assign listNames to the first n = listNames.length parameters.
 +  for (let i = 0; i < listNames.length; ++i) {
 +    dataMap[listNames[i]] = parameters[i];
 +  }
 +  // Read key-value pairs and copy these to the dataMap.
 +  for (let i = listNames.length; i < parameters.length; ++i) {
 +    let [key, value] = utils.splitAtEquals(parameters[i]);
 +    if (key && value) {
 +      dataMap[key] = value;
 +    }
 +  }
 +  return dataMap;
 +};
++
 +// ## info
 +// A namespace for functions related to tor's GETINFO and GETCONF command.
 +let info = {};
++
 +// __info.keyValueStringsFromMessage(messageText)__.
 +// Takes a message (text) response to GETINFO or GETCONF and provides
 +// a series of key-value strings, which are either multiline (with a `250+` prefix):
 +//
 +//     250+config/defaults=
 +//     AccountingMax "0 bytes"
 +//     AllowDotExit "0"
 +//     .
 +//
 +// or single-line (with a `250-` or `250 ` prefix):
 +//
 +//     250-version=0.2.6.0-alpha-dev (git-b408125288ad6943)
 +info.keyValueStringsFromMessage = utils.extractor(
 +  /^(250\+[\s\S]+?^\.|250[- ].+?)$/gim
 +);
++
 +// __info.applyPerLine(transformFunction)__.
 +// Returns a function that splits text into lines,
 +// and applies transformFunction to each line.
 +info.applyPerLine = function (transformFunction) {
 +  return function (text) {
 +    return utils.splitLines(text.trim()).map(transformFunction);
 +  };
 +};
++
 +// __info.routerStatusParser(valueString)__.
 +// Parses a router status entry as, described in
 +// https://gitweb.torproject.org/torspec.git/tree/dir-spec.txt
 +// (search for "router status entry")
 +info.routerStatusParser = function (valueString) {
 +  let lines = utils.splitLines(valueString),
 +    objects = [];
 +  for (let line of lines) {
 +    // Drop first character and grab data following it.
 +    let myData = line.substring(2),
 +      // Accumulate more maps with data, depending on the first character in the line.
 +      dataFun = {
 +        r: data =>
 +          utils.listMapData(data, [
 +            "nickname",
 +            "identity",
 +            "digest",
 +            "publicationDate",
 +            "publicationTime",
 +            "IP",
 +            "ORPort",
 +            "DirPort",
 +          ]),
 +        a: data => ({ IPv6: data }),
 +        s: data => ({ statusFlags: utils.splitAtSpaces(data) }),
 +        v: data => ({ version: data }),
 +        w: data => utils.listMapData(data, []),
 +        p: data => ({ portList: data.split(",") }),
 +      }[line.charAt(0)];
 +    if (dataFun !== undefined) {
 +      objects.push(dataFun(myData));
 +    }
 +  }
 +  return utils.mergeObjects(objects);
 +};
++
 +// __info.circuitStatusParser(line)__.
 +// Parse the output of a circuit status line.
 +info.circuitStatusParser = function (line) {
 +  let data = utils.listMapData(line, ["id", "status", "circuit"]),
 +    circuit = data.circuit;
 +  // Parse out the individual circuit IDs and names.
 +  if (circuit) {
 +    data.circuit = circuit.split(",").map(function (x) {
 +      return x.split(/~|=/);
 +    });
 +  }
 +  return data;
 +};
++
 +// __info.streamStatusParser(line)__.
 +// Parse the output of a stream status line.
 +info.streamStatusParser = function (text) {
 +  return utils.listMapData(text, [
 +    "StreamID",
 +    "StreamStatus",
 +    "CircuitID",
 +    "Target",
 +  ]);
 +};
++
 +// TODO: fix this parsing logic to handle bridgeLine correctly
 +// fingerprint/id is an optional parameter
 +// __info.bridgeParser(bridgeLine)__.
 +// Takes a single line from a `getconf bridge` result and returns
 +// a map containing the bridge's type, address, and ID.
 +info.bridgeParser = function (bridgeLine) {
 +  let result = {},
 +    tokens = bridgeLine.split(/\s+/);
 +  // First check if we have a "vanilla" bridge:
 +  if (tokens[0].match(/^\d+\.\d+\.\d+\.\d+/)) {
 +    result.type = "vanilla";
 +    [result.address, result.ID] = tokens;
 +    // Several bridge types have a similar format:
 +  } else {
 +    result.type = tokens[0];
 +    if (
 +      [
 +        "flashproxy",
 +        "fte",
 +        "meek",
 +        "meek_lite",
 +        "obfs3",
 +        "obfs4",
 +        "scramblesuit",
 +        "snowflake",
 +      ].includes(result.type)
 +    ) {
 +      [result.address, result.ID] = tokens.slice(1);
 +    }
 +  }
 +  return result.type ? result : null;
 +};
++
 +// __info.parsers__.
 +// A map of GETINFO and GETCONF keys to parsing function, which convert
 +// result strings to _javascript_ data.
 +info.parsers = {
 +  "ns/id/": info.routerStatusParser,
 +  "ip-to-country/": utils.identity,
 +  "circuit-status": info.applyPerLine(info.circuitStatusParser),
 +  bridge: info.bridgeParser,
 +  // Currently unused parsers:
 +  //  "ns/name/" : info.routerStatusParser,
 +  //  "stream-status" : info.applyPerLine(info.streamStatusParser),
 +  //  "version" : utils.identity,
 +  //  "config-file" : utils.identity,
 +};
++
 +// __info.getParser(key)__.
 +// Takes a key and determines the parser function that should be used to
 +// convert its corresponding valueString to _javascript_ data.
 +info.getParser = function (key) {
 +  return (
 +    info.parsers[key] ||
 +    info.parsers[key.substring(0, key.lastIndexOf("/") + 1)]
 +  );
 +};
++
 +// __info.stringToValue(string)__.
 +// Converts a key-value string as from GETINFO or GETCONF to a value.
 +info.stringToValue = function (string) {
 +  // key should look something like `250+circuit-status=` or `250-circuit-status=...`
 +  // or `250 circuit-status=...`
 +  let matchForKey = string.match(/^250[ +-](.+?)=/),
 +    key = matchForKey ? matchForKey[1] : null;
 +  if (key === null) {
 +    return null;
 +  }
 +  // matchResult finds a single-line result for `250-` or `250 `,
 +  // or a multi-line one for `250+`.
 +  let matchResult =
 +      string.match(/^250[ -].+?=(.*)$/) ||
 +      string.match(/^250\+.+?=([\s\S]*?)^\.$/m),
 +    // Retrieve the captured group (the text of the value in the key-value pair)
 +    valueString = matchResult ? matchResult[1] : null,
 +    // Get the parser function for the key found.
 +    parse = info.getParser(key.toLowerCase());
 +  if (parse === undefined) {
 +    throw new Error("No parser found for '" + key + "'");
 +  }
 +  // Return value produced by the parser.
 +  return parse(valueString);
 +};
++
 +/**
 + * @typedef {object} Bridge
 + * @property {string} transport The transport of the bridge, or vanilla if not
 + * specified.
 + * @property {string} addr The IP address and port of the bridge
 + * @property {string} id The fingerprint of the bridge
 + * @property {string} args Optional arguments passed to the bridge
 + */
 +/**
 + * @typedef {object} PTInfo The information about a pluggable transport
 + * @property {string[]} transports An array with all the transports supported by
 + * this configuration.
 + * @property {string} type Either socks4, socks5 or exec
 + * @property {string} [ip] The IP address of the proxy (only for socks4 and
 + * socks5)
 + * @property {integer} [port] The port of the proxy (only for socks4 and socks5)
 + * @property {string} [pathToBinary] Path to the binary that is run (only for
 + * exec)
 + * @property {string} [options] Optional options passed to the binary (only for
 + * exec)
 + */
 +/**
 + * @typedef {object} OnionAuthKeyInfo
 + * @property {string} address The address of the onion service
 + * @property {string} typeAndKey Onion service key and type of key, as
 + * `type:base64-private-key`
 + * @property {string} Flags Additional flags, such as Permanent
 + */
 +/**
 + * @callback EventFilterCallback
 + * @param {any} data Either a raw string, or already parsed data
 + * @returns {boolean}
 + */
 +/**
 + * @callback EventCallback
 + * @param {any} data Either a raw string, or already parsed data
 + */
++
 +class TorController {
 +  /**
 +   * The control socket
 +   *
 +   * @type {ControlSocket}
 +   */
 +  #socket;
++
 +  /**
 +   * A map of EVENT keys to parsing functions, which convert result strings to
 +   * _javascript_ data.
 +   */
 +  #eventParsers = {
 +    stream: info.streamStatusParser,
 +    // Currently unused:
 +    // "circ" : info.circuitStatusParser,
 +  };
++
 +  /**
 +   * Builds a new TorController.
 +   *
 +   * @param {AsyncSocket} socket The socket to communicate to the control port
 +   */
 +  constructor(socket) {
 +    this.#socket = new ControlSocket(socket);
 +  }
++
 +  /**
 +   * Tells whether the underlying socket is open.
 +   *
 +   * @returns {boolean}
 +   */
 +  get isOpen() {
 +    return this.#socket.isOpen;
 +  }
++
 +  /**
 +   * Close the underlying socket.
 +   */
 +  close() {
 +    this.#socket.close();
 +  }
++
 +  /**
 +   * Send a command over the control port.
 +   * TODO: Make this function private, and force the operations to go through
 +   * specialized methods.
 +   *
 +   * @param {string} cmd The command to send
 +   * @returns {Promise<string>} A 2xx response obtained from the control port.
 +   * For other codes, this function will throw. The returned string will never
 +   * be empty.
 +   */
 +  async sendCommand(cmd) {
 +    return this.#socket.sendCommand(cmd);
 +  }
++
 +  /**
 +   * Send a simple command whose response is expected to be simply a "250 OK".
 +   * The function will not return a reply, but will throw if an unexpected one
 +   * is received.
 +   *
 +   * @param {string} command The command to send
 +   */
 +  async #sendCommandSimple(command) {
 +    const reply = await this.sendCommand(command);
 +    if (!/^250 OK\s*$/i.test(reply)) {
 +      throw new TorError(command, reply);
 +    }
 +  }
++
 +  /**
 +   * Authenticate to the tor daemon.
 +   * Notice that a failure in the authentication makes the connection close.
 +   *
 +   * @param {string} password The password for the control port.
 +   */
 +  async authenticate(password) {
 +    if (password) {
 +      this.#expectString(password, "password");
 +    }
 +    await this.#sendCommandSimple(`authenticate ${password || ""}`);
 +  }
++
 +  /**
 +   * Sends a GETINFO for a single key.
 +   *
 +   * @param {string} key The key to get value for
 +   * @returns {any} The return value depends on the requested key
 +   */
 +  async getInfo(key) {
 +    this.#expectString(key, "key");
 +    const response = await this.sendCommand(`getinfo ${key}`);
 +    return this.#getMultipleResponseValues(response)[0];
 +  }
++
 +  /**
 +   * Sends a GETINFO for a single key.
 +   * control-spec.txt says "one ReplyLine is sent for each requested value", so,
 +   * we expect to receive only one line starting with `250-keyword=`, or one
 +   * line starting with `250+keyword=` (in which case we will match until a
 +   * period).
 +   * This function could be possibly extended to handle several keys at once,
 +   * but we currently do not need this functionality, so we preferred keeping
 +   * the function simpler.
 +   *
 +   * @param {string} key The key to get value for
 +   * @returns {Promise<string>} The string we received (only the value, without
 +   * the key). We do not do any additional parsing on it.
 +   */
 +  async #getInfo(key) {
 +    this.#expectString(key);
 +    const cmd = `GETINFO ${key}`;
 +    const reply = await this.sendCommand(cmd);
 +    const match =
 +      reply.match(/^250-([^=]+)=(.*)$/m) ||
 +      reply.match(/^250\+([^=]+)=([\s\S]*?)^\.\r?\n^250 OK\s*$/m);
 +    if (!match || match[1] !== key) {
 +      throw new TorError(cmd, reply);
 +    }
 +    return match[2];
 +  }
++
 +  /**
 +   * Ask Tor its bootstrap phase.
 +   *
 +   * @returns {object} An object with the bootstrap information received from
 +   * Tor. Its keys might vary, depending on the input
 +   */
 +  async getBootstrapPhase() {
 +    return this.#parseBootstrapStatus(
 +      await this.#getInfo("status/bootstrap-phase")
 +    );
 +  }
++
 +  /**
 +   * Get the IPv4 and optionally IPv6 addresses of an onion router.
 +   *
 +   * @param {NodeFingerprint} id The fingerprint of the node the caller is
 +   * interested in
 +   * @returns {string[]} The IP addresses (one IPv4 and optionally an IPv6)
 +   */
 +  async getNodeAddresses(id) {
 +    this.#expectString(id, "id");
 +    const reply = await this.#getInfo(`ns/id/${id}`);
 +    // See dir-spec.txt.
 +    // r nickname identity digest publication IP OrPort DirPort
 +    const rLine = reply.match(/^r\s+(.*)$/m);
 +    const v4 = rLine ? rLine[1].split(/\s+/) : [];
 +    // Tor should already reply with a 552 when a relay cannot be found.
 +    // Also, publication is a date with a space inside, so it is counted twice.
 +    if (!rLine || v4.length !== 8) {
 +      throw new Error(`Received an invalid node information: ${reply}`);
 +    }
 +    const addresses = [v4[5]];
 +    // a address:port
 +    // dir-spec.txt also states only the first one should be taken
 +    // TODO: The consumers do not care about the port or the square brackets
 +    // either. Remove them when integrating this function with the rest
 +    const v6 = reply.match(/^a\s+(\[[0-9a-fA-F:]+\]:[0-9]{1,5})$/m);
 +    if (v6) {
 +      addresses.push(v6[1]);
 +    }
 +    return addresses;
 +  }
++
 +  /**
 +   * Maps IP addresses to 2-letter country codes, or ?? if unknown.
 +   *
 +   * @param {string} ip The IP address to look for
 +   * @returns {Promise<string>} A promise with the country code. If unknown, the
 +   * promise is resolved with "??". It is rejected only when the underlying
 +   * GETINFO command fails or if an exception is thrown
 +   */
 +  async getIPCountry(ip) {
 +    this.#expectString(ip, "ip");
 +    return this.#getInfo(`ip-to-country/${ip}`);
 +  }
++
 +  /**
 +   * Ask tor which ports it is listening to for SOCKS connections.
 +   *
 +   * @returns {Promise<string[]>} An array of addresses. It might be empty
 +   * (e.g., when DisableNetwork is set)
 +   */
 +  async getSocksListeners() {
 +    const listeners = await this.#getInfo("net/listeners/socks");
 +    return Array.from(listeners.matchAll(/\s*("(?:[^"\\]|\\.)*"|\S+)\s*/g), m =>
 +      TorParsers.unescapeString(m[1])
 +    );
 +  }
++
 +  // Configuration
++
 +  /**
 +   * Sends a GETCONF for a single key.
 +   * GETCONF with a single argument returns results with one or more lines that
 +   * look like `250[- ]key=value`.
 +   * Any GETCONF lines that contain a single keyword only are currently dropped.
 +   * So we can use similar parsing to that for getInfo.
 +   *
 +   * @param {string} key The key to get value for
 +   * @returns {any} A parsed config value (it depends if a parser is known)
 +   */
 +  async getConf(key) {
 +    this.#expectString(key, "key");
 +    return this.#getMultipleResponseValues(
 +      await this.sendCommand(`getconf ${key}`)
 +    );
 +  }
++
 +  /**
 +   * Sends a GETCONF for a single key.
 +   * The function could be easily generalized to get multiple keys at once, but
 +   * we do not need this functionality, at the moment.
 +   *
 +   * @param {string} key The keys to get info for
 +   * @returns {Promise<string[]>} The values obtained from the control port.
 +   * The key is removed, and the values unescaped, but they are not parsed.
 +   * The array might contain an empty string, which means that the default value
 +   * is used.
 +   */
 +  async #getConf(key) {
 +    this.#expectString(key, "key");
 +    // GETCONF expects a `keyword`, which should be only alpha characters,
 +    // according to the definition in control-port.txt. But as a matter of fact,
 +    // several configuration keys include numbers (e.g., Socks4Proxy). So, we
 +    // accept also numbers in this regular _expression_. One of the reason to
 +    // sanitize the input is that we then use it to create a regular _expression_.
 +    // Sadly, _javascript_ does not provide a function to escape/quote a string
 +    // for inclusion in a regex. Should we remove this limitation, we should
 +    // also implement a regex sanitizer, or switch to another pattern, like
 +    // `([^=])` and then filter on the keyword.
 +    if (!/^[A-Za-z0-9]+$/.test(key)) {
 +      throw new Error("The key can be composed only of letters and numbers.");
 +    }
 +    const cmd = `GETCONF ${key}`;
 +    const reply = await this.sendCommand(cmd);
 +    // From control-spec.txt: a 'default' value semantically different from an
 +    // empty string will not have an equal sign, just `250 $key`.
 +    const defaultRe = new RegExp(`^250[-\\s]${key}$`, "gim");
 +    if (reply.match(defaultRe)) {
 +      return [];
 +    }
 +    const re = new RegExp(`^250[-\\s]${key}=(.*)$`, "gim");
 +    const values = Array.from(reply.matchAll(re), m =>
 +      TorParsers.unescapeString(m[1])
 +    );
 +    if (!values.length) {
 +      throw new TorError(cmd, reply);
 +    }
 +    return values;
 +  }
++
 +  /**
 +   * Get the bridges Tor has been configured with.
 +   *
 +   * @returns {Bridge[]} The configured bridges
 +   */
 +  async getBridges() {
 +    return (await this.#getConf("BRIDGE")).map(TorParsers.parseBridgeLine);
 +  }
++
 +  /**
 +   * Get the configured pluggable transports.
 +   *
 +   * @returns {PTInfo[]} An array with the info of all the configured pluggable
 +   * transports.
 +   */
 +  async getPluggableTransports() {
 +    return (await this.#getConf("ClientTransportPlugin")).map(ptLine => {
 +      // man 1 tor: ClientTransportPlugin transport socks4|socks5 IP:PORT
 +      const socksLine = ptLine.match(
 +        /(\S+)\s+(socks[45])\s+([\d.]{7,15}|\[[\da-fA-F:]+\]):(\d{1,5})/i
 +      );
 +      // man 1 tor: transport exec path-to-binary [options]
 +      const execLine = ptLine.match(
 +        /(\S+)\s+(exec)\s+("(?:[^"\\]|\\.)*"|\S+)\s*(.*)/i
 +      );
 +      if (socksLine) {
 +        return {
 +          transports: socksLine[1].split(","),
 +          type: socksLine[2].toLowerCase(),
 +          ip: socksLine[3],
 +          port: parseInt(socksLine[4], 10),
 +        };
 +      } else if (execLine) {
 +        return {
 +          transports: execLine[1].split(","),
 +          type: execLine[2].toLowerCase(),
 +          pathToBinary: TorParsers.unescapeString(execLine[3]),
 +          options: execLine[4],
 +        };
 +      }
 +      throw new Error(
 +        `Received an invalid ClientTransportPlugin line: ${ptLine}`
 +      );
 +    });
 +  }
++
 +  /**
 +   * Send multiple configuration values to tor.
 +   *
 +   * @param {object} values The values to set
 +   */
 +  async setConf(values) {
 +    const args = Object.entries(values)
 +      .flatMap(([key, value]) => {
 +        if (value === undefined || value === null) {
 +          return [key];
 +        }
 +        if (Array.isArray(value)) {
 +          return value.length
 +            ? value.map(v => `${key}=${TorParsers.escapeString(v)}`)
 +            : key;
 +        } else if (typeof value === "string" || value instanceof String) {
 +          return `${key}=${TorParsers.escapeString(value)}`;
 +        } else if (typeof value === "boolean") {
 +          return `${key}=${value ? "1" : "0"}`;
 +        } else if (typeof value === "number") {
 +          return `${key}=${value}`;
 +        }
 +        throw new Error(`Unsupported type ${typeof value} (key ${key})`);
 +      })
 +      .join(" ");
 +    return this.#sendCommandSimple(`SETCONF ${args}`);
 +  }
++
 +  /**
 +   * Enable or disable the network.
 +   * Notice: switching from network disabled to network enabled will trigger a
 +   * bootstrap on C tor! (Or stop the current one).
 +   *
 +   * @param {boolean} enabled Tell whether the network should be enabled
 +   */
 +  async setNetworkEnabled(enabled) {
 +    return this.setConf({ DisableNetwork: !enabled });
 +  }
++
 +  /**
 +   * Ask Tor to write out its config options into its torrc.
 +   */
 +  async flushSettings() {
 +    return this.#sendCommandSimple("SAVECONF");
 +  }
++
 +  // Onion service authentication
++
 +  /**
 +   * Sends a ONION_CLIENT_AUTH_VIEW command to retrieve the list of private
 +   * keys.
 +   *
 +   * @returns {OnionAuthKeyInfo[]}
 +   */
 +  async onionAuthViewKeys() {
 +    const cmd = "onion_client_auth_view";
 +    const message = await this.sendCommand(cmd);
 +    // Either `250-CLIENT`, or `250 OK` if no keys are available.
 +    if (!message.startsWith("250")) {
 +      throw new TorError(cmd, message);
 +    }
 +    const re =
 +      /^250-CLIENT\s+(?<HSAddress>[A-Za-z2-7]+)\s+(?<KeyType>[^:]+):(?<PrivateKeyBlob>\S+)(?:\s(?<other>.+))?$/gim;
 +    return Array.from(message.matchAll(re), match => {
 +      // TODO: Change the consumer and make the fields more consistent with what
 +      // we get (e.g., separate key and type, and use a boolen for permanent).
 +      const info = {
 +        hsAddress: match.groups.HSAddress,
 +        typeAndKey: `${match.groups.KeyType}:${match.groups.PrivateKeyBlob}`,
 +      };
 +      const maybeFlags = match.groups.other?.match(/Flags=(\S+)/);
 +      if (maybeFlags) {
 +        info.Flags = maybeFlags[1];
 +      }
 +      return info;
 +    });
 +  }
++
 +  /**
 +   * Sends an ONION_CLIENT_AUTH_ADD command to add a private key to the Tor
 +   * configuration.
 +   *
 +   * @param {string} address The address of the onion service
 +   * @param {string} b64PrivateKey The private key of the service, in base64
 +   * @param {boolean} isPermanent Tell whether the key should be saved forever
 +   */
 +  async onionAuthAdd(address, b64PrivateKey, isPermanent) {
 +    this.#expectString(address, "address");
 +    this.#expectString(b64PrivateKey, "b64PrivateKey");
 +    const keyType = "x25519";
 +    let cmd = `onion_client_auth_add ${address} ${keyType}:${b64PrivateKey}`;
 +    if (isPermanent) {
 +      cmd += " Flags=Permanent";
 +    }
 +    const reply = await this.sendCommand(cmd);
 +    const status = reply.substring(0, 3);
 +    if (status !== "250" && status !== "251" && status !== "252") {
 +      throw new TorError(cmd, reply);
 +    }
 +  }
++
 +  /**
 +   * Sends an ONION_CLIENT_AUTH_REMOVE command to remove a private key from the
 +   * Tor configuration.
 +   *
 +   * @param {string} address The address of the onion service
 +   */
 +  async onionAuthRemove(address) {
 +    this.#expectString(address, "address");
 +    const cmd = `onion_client_auth_remove ${address}`;
 +    const reply = await this.sendCommand(cmd);
 +    const status = reply.substring(0, 3);
 +    if (status !== "250" && status !== "251") {
 +      throw new TorError(cmd, reply);
 +    }
 +  }
++
 +  // Daemon ownership
++
 +  /**
 +   * Instructs Tor to shut down when this control connection is closed.
 +   * If multiple connection sends this request, Tor will shut dwon when any of
 +   * them is closed.
 +   */
 +  async takeOwnership() {
 +    return this.#sendCommandSimple("TAKEOWNERSHIP");
 +  }
++
 +  /**
 +   * The __OwningControllerProcess argument can be used to make Tor periodically
 +   * check if a certain PID is still present, or terminate itself otherwise.
 +   * When switching to the ownership tied to the control port, this mechanism
 +   * should be stopped by calling this function.
 +   */
 +  async resetOwningControllerProcess() {
 +    return this.#sendCommandSimple("RESETCONF __OwningControllerProcess");
 +  }
++
 +  // Signals
++
 +  /**
 +   * Ask Tor to swtich to new circuits and clear the DNS cache.
 +   */
 +  async newnym() {
 +    return this.#sendCommandSimple("SIGNAL NEWNYM");
 +  }
++
 +  // Events monitoring
++
 +  /**
 +   * Enable receiving certain events.
 +   * As per control-spec.txt, any events turned on in previous calls but not
 +   * included in this one will be turned off.
 +   *
 +   * @param {string[]} types The events to enable. If empty, no events will be
 +   * watched.
 +   */
 +  setEvents(types) {
 +    if (!types.every(t => typeof t === "string" || t instanceof String)) {
 +      throw new Error("Event types must be strings");
 +    }
 +    return this.#sendCommandSimple("SETEVENTS " + types.join(" "));
 +  }
++
 +  /**
 +   * Watches for a particular type of asynchronous event.
 +   * Notice: we only observe `"650" SP...` events, currently (no `650+...` or
 +   * `650-...` events).
 +   * Also, you need to enable the events in the control port with SETEVENTS,
 +   * first.
 +   *
 +   * @param {string} type The event type to catch
 +   * @param {EventFilterCallback?} filter An optional callback to filter
 +   * events for which the callback will be called. If null, all events will be
 +   * passed.
 +   * @param {EventCallback} callback The callback that will handle the event
 +   * @param {boolean} raw Tell whether to ignore the data parser, even if
 +   * supported
 +   */
 +  watchEvent(type, filter, callback, raw = false) {
 +    this.#expectString(type, "type");
 +    const start = `650 ${type}`;
 +    this.#socket.addNotificationCallback(new RegExp(`^${start}`), message => {
 +      // Remove also the initial text
 +      const dataText = message.substring(start.length + 1);
 +      const parser = this.#eventParsers[type.toLowerCase()];
 +      const data = dataText && parser ? parser(dataText) : null;
 +      // FIXME: This is the original code, but we risk of not filtering on the
 +      // data, if we ask for raw data (which we always do at the moment, but we
 +      // do not use a filter either...)
 +      if (filter === null || filter(data)) {
 +        callback(data && !raw ? data : message);
 +      }
 +    });
 +  }
++
 +  // Other helpers
++
 +  /**
 +   * Parse a bootstrap status line.
 +   *
 +   * @param {string} line The line to parse, without the command/notification
 +   * prefix
 +   * @returns {object} An object with the bootstrap information received from
 +   * Tor. Its keys might vary, depending on the input
 +   */
 +  #parseBootstrapStatus(line) {
 +    const match = line.match(/^(NOTICE|WARN) BOOTSTRAP\s*(.*)/);
 +    if (!match) {
 +      throw Error(
 +        `Received an invalid response for the bootstrap phase: ${line}`
 +      );
 +    }
 +    const status = {
 +      TYPE: match[1],
 +      ...this.#getKeyValues(match[2]),
 +    };
 +    if (status.PROGRESS !== undefined) {
 +      status.PROGRESS = parseInt(status.PROGRESS, 10);
 +    }
 +    if (status.COUNT !== undefined) {
 +      status.COUNT = parseInt(status.COUNT, 10);
 +    }
 +    return status;
 +  }
++
 +  /**
 +   * Throw an exception when value is not a string.
 +   *
 +   * @param {any} value The value to check
 +   * @param {string} name The name of the `value` argument
 +   */
 +  #expectString(value, name) {
 +    if (typeof value !== "string" && !(value instanceof String)) {
 +      throw new Error(`The ${name} argument is expected to be a string.`);
 +    }
 +  }
++
 +  /**
 +   * Return an object with all the matches that are in the form `key="value"` or
 +   * `key=value`. The values will be unescaped, but no additional parsing will
 +   * be done (e.g., numbers will be returned as strings).
 +   * If keys are repeated, only the last one will be taken.
 +   *
 +   * @param {string} str The string to match tokens in
 +   * @returns {object} An object with all the various tokens. If none is found,
 +   * an empty object is returned.
 +   */
 +  #getKeyValues(str) {
 +    return Object.fromEntries(
 +      Array.from(
 +        str.matchAll(/\s*([^=]+)=("(?:[^"\\]|\\.)*"|\S+)\s*/g) || [],
 +        pair => [pair[1], TorParsers.unescapeString(pair[2])]
 +      )
 +    );
 +  }
++
 +  /**
 +   * Process multiple responses to a GETINFO or GETCONF request.
 +   *
 +   * @param {string} message The message to process
 +   * @returns {object[]} The keys depend on the message
 +   */
 +  #getMultipleResponseValues(message) {
 +    return info
 +      .keyValueStringsFromMessage(message)
 +      .map(info.stringToValue)
 +      .filter(x => x);
 +  }
 +}
++
 +const controlPortInfo = {};
++
 +/**
 + * Sets Tor control port connection parameters to be used in future calls to
 + * the controller() function.
 + *
 + * Example:
 + *   configureControlPortModule(undefined, "127.0.0.1", 9151, "MyPassw0rd");
 + *
 + * @param {nsIFile?} ipcFile An optional file to use to communicate to the
 + * control port on Unix platforms
 + * @param {string?} host The hostname to connect to the control port. Mutually
 + * exclusive with ipcFile
 + * @param {integer?} port The port number of the control port. To be used only
 + * with host. The default is 9151.
 + * @param {string} password The password of the control port in clear text.
 + */
 +export function configureControlPortModule(ipcFile, host, port, password) {
 +  controlPortInfo.ipcFile = ipcFile;
 +  controlPortInfo.host = host;
 +  controlPortInfo.port = port || 9151;
 +  controlPortInfo.password = password;
 +}
++
 +/**
 + * Instantiates and returns a controller object that is connected and
 + * authenticated to a Tor ControlPort using the connection parameters
 + * provided in the most recent call to configureControlPortModule().
 + *
 + * Example:
 + *     // Get a new controller
 + *     let c = await controller();
 + *     // Send command and receive a `250` reply or an error message:
 + *     let replyPromise = await c.getInfo("ip-to-country/16.16.16.16");
 + *     // Close the controller permanently
 + *     c.close();
 + */
 +export async function controller() {
 +  if (!controlPortInfo.ipcFile && !controlPortInfo.host) {
 +    throw new Error("Please call configureControlPortModule first");
 +  }
 +  let socket;
 +  if (controlPortInfo.ipcFile) {
 +    socket = AsyncSocket.fromIpcFile(controlPortInfo.ipcFile);
 +  } else {
 +    socket = AsyncSocket.fromSocketAddress(
 +      controlPortInfo.host,
 +      controlPortInfo.port
 +    );
 +  }
 +  const controller = new TorController(socket);
 +  try {
 +    await controller.authenticate(controlPortInfo.password);
 +  } catch (e) {
 +    try {
 +      controller.close();
 +    } catch (ec) {
 +      // TODO: Use a custom logger?
 +      console.error("Cannot close the socket", ec);
 +    }
 +    throw e;
 +  }
 +  return controller;
 +}

toolkit/components/tor-launcher/TorMonitorService.sys.mjs

@@ -15,14 +15,9 @@ const lazy = {};
  ChromeUtils.defineESModuleGetters(lazy, {
    TorProtocolService: "resource://gre/modules/TorProtocolService.sys.mjs",
 +  controller: "resource://gre/modules/TorControlPort.sys.mjs",
  });
 -ChromeUtils.defineModuleGetter(
 -  lazy,
 -  "controller",
 -  "resource://torbutton/modules/tor-control-port.js"
 -);
+-
  ChromeUtils.defineESModuleGetters(lazy, {
    TorProtocolService: "resource://gre/modules/TorProtocolService.sys.mjs",
  });
@@ -172,9 +167,7 @@ export const TorMonitorService = {
      const cmd = "GETINFO";
      const key = "status/bootstrap-phase";
      let reply = await this._connection.sendCommand(`${cmd} ${key}`);
 -    if (!reply) {
 -      throw new Error("We received an empty reply");
 -    }
++
      // A typical reply looks like:
      //  250-status/bootstrap-phase=NOTICE BOOTSTRAP PROGRESS=100 TAG=done SUMMARY="Done"
      //  250 OK
@@ -335,8 +328,7 @@ export const TorMonitorService = {
      let conn;
      try {
 -      const avoidCache = true;
 -      conn = await lazy.controller(avoidCache);
 +      conn = await lazy.controller();
      } catch (e) {
        logger.error("Cannot open a control port connection", e);
        if (conn) {
@@ -353,12 +345,10 @@ export const TorMonitorService = {
+     }
      // TODO: optionally monitor INFO and DEBUG log messages.
 -    let reply = await conn.sendCommand(
 -      "SETEVENTS " + Array.from(this._eventHandlers.keys()).join(" ")
 -    );
 -    reply = TorParsers.parseCommandResponse(reply);
 -    if (!TorParsers.commandSucceeded(reply)) {
 -      logger.error("SETEVENTS failed");
 +    try {
 +      await conn.setEvents(Array.from(this._eventHandlers.keys()));
 +    } catch (e) {
 +      logger.error("SETEVENTS failed", e);
        conn.close();
        return false;
+     }
@@ -405,18 +395,16 @@ export const TorMonitorService = {
    // Try to become the primary controller (TAKEOWNERSHIP).
    async _takeTorOwnership(conn) {
 -    const takeOwnership = "TAKEOWNERSHIP";
 -    let reply = await conn.sendCommand(takeOwnership);
 -    reply = TorParsers.parseCommandResponse(reply);
 -    if (!TorParsers.commandSucceeded(reply)) {
 -      logger.warn("Take ownership failed");
 -    } else {
 -      const resetConf = "RESETCONF __OwningControllerProcess";
 -      reply = await conn.sendCommand(resetConf);
 -      reply = TorParsers.parseCommandResponse(reply);
 -      if (!TorParsers.commandSucceeded(reply)) {
 -        logger.warn("Clear owning controller process failed");
 -      }
 +    try {
 +      conn.takeOwnership();
 +    } catch (e) {
 +      logger.warn("Take ownership failed", e);
 +      return;
 +    }
 +    try {
 +      conn.resetOwningControllerProcess();
 +    } catch (e) {
 +      logger.warn("Clear owning controller process failed", e);
+     }
    },

toolkit/components/tor-launcher/TorProtocolService.sys.mjs

@@ -19,16 +19,10 @@ ChromeUtils.defineModuleGetter(
    "TorMonitorService",
    "resource://gre/modules/TorMonitorService.jsm"
  );
 -ChromeUtils.defineModuleGetter(
 -  lazy,
 -  "configureControlPortModule",
 -  "resource://torbutton/modules/tor-control-port.js"
 -);
 -ChromeUtils.defineModuleGetter(
 -  lazy,
 -  "controller",
 -  "resource://torbutton/modules/tor-control-port.js"
 -);
 +ChromeUtils.defineESModuleGetters(lazy, {
 +  controller: "resource://gre/modules/TorControlPort.sys.mjs",
 +  configureControlPortModule: "resource://gre/modules/TorControlPort.sys.mjs",
 +});
  const TorTopics = Object.freeze({
    ProcessExited: "TorProcessExited",
@@ -285,8 +279,7 @@ export const TorProtocolService = {
      });
    },
 -  // TODO: transform the following 4 functions in getters. At the moment they
 -  // are also used in torbutton.
 +  // TODO: transform the following 4 functions in getters.
    // Returns Tor password string or null if an error occurs.
    torGetPassword() {
@@ -490,8 +483,6 @@ export const TorProtocolService = {
        TorLauncherUtil.setProxyConfiguration(this._SOCKSPortInfo);
        // Set the global control port info parameters.
 -      // These values may be overwritten by torbutton when it initializes, but
 -      // torbutton's values *should* be identical.
        lazy.configureControlPortModule(
          this._controlIPCFile,
          this._controlHost,
@@ -616,8 +607,7 @@ export const TorProtocolService = {
    // return it.
    async _getConnection() {
      if (!this._controlConnection) {
 -      const avoidCache = true;
 -      this._controlConnection = await lazy.controller(avoidCache);
 +      this._controlConnection = await lazy.controller();
+     }
      if (this._controlConnection.inUse) {
        await new Promise((resolve, reject) =>

toolkit/components/tor-launcher/moz.build

  EXTRA_JS_MODULES += [
      "TorBootstrapRequest.sys.mjs",
 +    "TorControlPort.sys.mjs",
      "TorDomainIsolator.sys.mjs",
      "TorLauncherUtil.sys.mjs",
      "TorMonitorService.sys.mjs",

toolkit/torbutton/chrome/content/torbutton.js deleted

 -// window globals
 -var torbutton_init;
+-
 -(() => {
 -  // Bug 1506 P1-P5: This is the main Torbutton overlay file. Much needs to be
 -  // preserved here, but in an ideal world, most of this code should perhaps be
 -  // moved into an XPCOM service, and much can also be tossed. See also
 -  // individual 1506 comments for details.
+-
 -  // TODO: check for leaks: http://www.mozilla.org/scriptable/avoiding-leaks.html
 -  // TODO: Double-check there are no strange exploits to defeat:
 -  //       http://kb.mozillazine.org/Links_to_local_pages_don%27t_work
+-
 -  /* global gBrowser, Services, AppConstants */
+-
 -  let { torbutton_log } = ChromeUtils.import(
 -    "resource://torbutton/modules/utils.js"
 -  );
 -  let { configureControlPortModule } = ChromeUtils.import(
 -    "resource://torbutton/modules/tor-control-port.js"
 -  );
+-
 -  const { TorProtocolService } = ChromeUtils.import(
 -    "resource://gre/modules/TorProtocolService.jsm"
 -  );
+-
 -  var m_tb_prefs = Services.prefs;
+-
 -  // status
 -  var m_tb_wasinited = false;
+-
 -  var m_tb_control_ipc_file = null; // Set if using IPC (UNIX domain socket).
 -  var m_tb_control_port = null; // Set if using TCP.
 -  var m_tb_control_host = null; // Set if using TCP.
 -  var m_tb_control_pass = null;
+-
 -  // Bug 1506 P2-P4: This code sets some version variables that are irrelevant.
 -  // It does read out some important environment variables, though. It is
 -  // called once per browser window.. This might belong in a component.
 -  torbutton_init = function () {
 -    torbutton_log(3, "called init()");
+-
 -    if (m_tb_wasinited) {
 -      return;
 -    }
 -    m_tb_wasinited = true;
+-
 -    // Bug 1506 P4: These vars are very important for New Identity
 -    if (Services.env.exists("TOR_CONTROL_PASSWD")) {
 -      m_tb_control_pass = Services.env.get("TOR_CONTROL_PASSWD");
 -    } else if (Services.env.exists("TOR_CONTROL_COOKIE_AUTH_FILE")) {
 -      var cookie_path = Services.env.get("TOR_CONTROL_COOKIE_AUTH_FILE");
 -      try {
 -        if ("" != cookie_path) {
 -          m_tb_control_pass = torbutton_read_authentication_cookie(cookie_path);
 -        }
 -      } catch (e) {
 -        torbutton_log(4, "unable to read authentication cookie");
 -      }
 -    } else {
 -      try {
 -        // Try to get password from Tor Launcher.
 -        m_tb_control_pass = TorProtocolService.torGetPassword();
 -      } catch (e) {}
 -    }
+-
 -    // Try to get the control port IPC file (an nsIFile) from Tor Launcher,
 -    // since Tor Launcher knows how to handle its own preferences and how to
 -    // resolve relative paths.
 -    try {
 -      m_tb_control_ipc_file = TorProtocolService.torGetControlIPCFile();
 -    } catch (e) {}
+-
 -    if (!m_tb_control_ipc_file) {
 -      if (Services.env.exists("TOR_CONTROL_PORT")) {
 -        m_tb_control_port = Services.env.get("TOR_CONTROL_PORT");
 -      } else {
 -        try {
 -          const kTLControlPortPref = "extensions.torlauncher.control_port";
 -          m_tb_control_port = m_tb_prefs.getIntPref(kTLControlPortPref);
 -        } catch (e) {
 -          // Since we want to disable some features when Tor Launcher is
 -          // not installed (e.g., New Identity), we do not set a default
 -          // port value here.
 -        }
 -      }
+-
 -      if (Services.env.exists("TOR_CONTROL_HOST")) {
 -        m_tb_control_host = Services.env.get("TOR_CONTROL_HOST");
 -      } else {
 -        try {
 -          const kTLControlHostPref = "extensions.torlauncher.control_host";
 -          m_tb_control_host = m_tb_prefs.getCharPref(kTLControlHostPref);
 -        } catch (e) {
 -          m_tb_control_host = "127.0.0.1";
 -        }
 -      }
 -    }
+-
 -    configureControlPortModule(
 -      m_tb_control_ipc_file,
 -      m_tb_control_host,
 -      m_tb_control_port,
 -      m_tb_control_pass
 -    );
+-
 -    torbutton_log(3, "init completed");
 -  };
+-
 -  // Bug 1506 P4: Control port interaction. Needed for New Identity.
 -  function torbutton_read_authentication_cookie(path) {
 -    var file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
 -    file.initWithPath(path);
 -    var fileStream = Cc[
 -      "@mozilla.org/network/file-input-stream;1"
 -    ].createInstance(Ci.nsIFileInputStream);
 -    fileStream.init(file, 1, 0, false);
 -    var binaryStream = Cc["@mozilla.org/binaryinputstream;1"].createInstance(
 -      Ci.nsIBinaryInputStream
 -    );
 -    binaryStream.setInputStream(fileStream);
 -    var array = binaryStream.readByteArray(fileStream.available());
 -    binaryStream.close();
 -    fileStream.close();
 -    return torbutton_array_to_hexdigits(array);
 -  }
+-
 -  // Bug 1506 P4: Control port interaction. Needed for New Identity.
 -  function torbutton_array_to_hexdigits(array) {
 -    return array
 -      .map(function (c) {
 -        return String("0" + c.toString(16)).slice(-2);
 -      })
 -      .join("");
 -  }
+-
 -  // ---------------------- Event handlers -----------------
+-
 -  // Bug 1506 P3: This is needed pretty much only for the window resizing.
 -  // See comments for individual functions for details
 -  function torbutton_new_window(event) {
 -    torbutton_log(3, "New window");
 -    if (!m_tb_wasinited) {
 -      torbutton_init();
 -    }
 -  }
 -  window.addEventListener("load", torbutton_new_window);
 -})();

toolkit/torbutton/components.conf deleted

 -Classes = [
 -    {
 -        "cid": "{f36d72c9-9718-4134-b550-e109638331d7}",
 -        "contract_ids": [
 -            "@torproject.org/torbutton-logger;1"
 -        ],
 -        "jsm": "resource://torbutton/modules/TorbuttonLogger.jsm",
 -        "constructor": "TorbuttonLogger",
 -    },
 -]

toolkit/torbutton/jar.mn

  #filter substitution
  torbutton.jar:
+-
 -% content torbutton %content/
+-
 -  content/torbutton.js                   (chrome/content/torbutton.js)
+-
 -  modules/       (modules/*)
+-
  % resource torbutton %
 +% category l10n-registry torbutton resource://torbutton/locale/{locale}/
  # browser branding
  % override chrome://branding/locale/brand.dtd chrome://torbutton/locale/brand.dtd
  % override chrome://branding/locale/brand.properties chrome://torbutton/locale/brand.properties
 -% category l10n-registry torbutton resource://torbutton/locale/{locale}/
  # Strings for the about:tbupdate page
  % override chrome://browser/locale/aboutTBUpdate.dtd chrome://torbutton/locale/aboutTBUpdate.dtd

toolkit/torbutton/modules/TorbuttonLogger.jsm deleted

 -// Bug 1506 P1: This is just a handy logger. If you have a better one, toss
 -// this in the trash.
+-
 -/*************************************************************************
 - * TBLogger (_javascript_ XPCOM component)
 - *
 - * Allows loglevel-based logging to different logging mechanisms.
 - *
 - *************************************************************************/
+-
 -var EXPORTED_SYMBOLS = ["TorbuttonLogger"];
+-
 -const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+-
 -function TorbuttonLogger() {
 -  // Register observer
 -  Services.prefs.addObserver("extensions.torbutton", this);
+-
 -  this.loglevel = Services.prefs.getIntPref("extensions.torbutton.loglevel", 4);
 -  this.logmethod = Services.prefs.getIntPref(
 -    "extensions.torbutton.logmethod",
 -    1
 -  );
+-
 -  try {
 -    var logMngr = Cc["@mozmonkey.com/debuglogger/manager;1"].getService(
 -      Ci.nsIDebugLoggerManager
 -    );
 -    this._debuglog = logMngr.registerLogger("torbutton");
 -  } catch (exErr) {
 -    this._debuglog = false;
 -  }
 -  this._console = Services.console;
+-
 -  // This JSObject is exported directly to chrome
 -  this.wrappedJSObject = this;
 -  this.log(3, "Torbutton debug output ready");
 -}
+-
 -/**
 - * JS XPCOM component registration goop:
 - *
 - * Everything below is boring boilerplate and can probably be ignored.
 - */
+-
 -TorbuttonLogger.prototype = {
 -  QueryInterface: ChromeUtils.generateQI([Ci.nsIClassInfo]),
+-
 -  wrappedJSObject: null, // Initialized by constructor
+-
 -  formatLog(str, level) {
 -    const padInt = n => String(n).padStart(2, "0");
 -    const logString = { 1: "VERB", 2: "DBUG", 3: "INFO", 4: "NOTE", 5: "WARN" };
 -    const d = new Date();
 -    const now =
 -      padInt(d.getUTCMonth() + 1) +
 -      "-" +
 -      padInt(d.getUTCDate()) +
 -      " " +
 -      padInt(d.getUTCHours()) +
 -      ":" +
 -      padInt(d.getUTCMinutes()) +
 -      ":" +
 -      padInt(d.getUTCSeconds());
 -    return `${now} Torbutton ${logString[level]}: ${str}`;
 -  },
+-
 -  // error console log
 -  eclog(level, str) {
 -    switch (this.logmethod) {
 -      case 0: // stderr
 -        if (this.loglevel <= level) {
 -          dump(this.formatLog(str, level) + "\n");
 -        }
 -        break;
 -      default:
 -        // errorconsole
 -        if (this.loglevel <= level) {
 -          this._console.logStringMessage(this.formatLog(str, level));
 -        }
 -        break;
 -    }
 -  },
+-
 -  safe_log(level, str, scrub) {
 -    if (this.loglevel < 4) {
 -      this.eclog(level, str + scrub);
 -    } else {
 -      this.eclog(level, str + " [scrubbed]");
 -    }
 -  },
+-
 -  log(level, str) {
 -    switch (this.logmethod) {
 -      case 2: // debuglogger
 -        if (this._debuglog) {
 -          this._debuglog.log(6 - level, this.formatLog(str, level));
 -          break;
 -        }
 -      // fallthrough
 -      case 0: // stderr
 -        if (this.loglevel <= level) {
 -          dump(this.formatLog(str, level) + "\n");
 -        }
 -        break;
 -      case 1: // errorconsole
 -        if (this.loglevel <= level) {
 -          this._console.logStringMessage(this.formatLog(str, level));
 -        }
 -        break;
 -      default:
 -        dump("Bad log method: " + this.logmethod);
 -    }
 -  },
+-
 -  // Pref observer interface implementation
+-
 -  // topic:   what event occurred
 -  // subject: what nsIPrefBranch we're observing
 -  // data:    which pref has been changed (relative to subject)
 -  observe(subject, topic, data) {
 -    if (topic != "nsPref:changed") {
 -      return;
 -    }
 -    switch (data) {
 -      case "extensions.torbutton.logmethod":
 -        this.logmethod = Services.prefs.getIntPref(
 -          "extensions.torbutton.logmethod"
 -        );
 -        if (this.logmethod === 0) {
 -          Services.prefs.setBoolPref("browser.dom.window.dump.enabled", true);
 -        } else if (
 -          Services.prefs.getIntPref("extensions.torlauncher.logmethod", 3) !== 0
 -        ) {
 -          // If Tor Launcher is not available or its log method is not 0
 -          // then let's reset the dump pref.
 -          Services.prefs.setBoolPref("browser.dom.window.dump.enabled", false);
 -        }
 -        break;
 -      case "extensions.torbutton.loglevel":
 -        this.loglevel = Services.prefs.getIntPref(
 -          "extensions.torbutton.loglevel"
 -        );
 -        break;
 -    }
 -  },
 -};

toolkit/torbutton/modules/tor-control-port.js deleted

 -// A module for TorBrowser that provides an asynchronous controller for
 -// Tor, through its ControlPort.
 -//
 -// This file is written in call stack order (later functions
 -// call earlier functions). The file can be processed
 -// with docco.js to produce pretty documentation.
 -//
 -// To import the module, use
 -//
 -//  let { configureControlPortModule, controller, wait_for_controller } =
 -//                Components.utils.import("path/to/tor-control-port.js", {});
 -//
 -// See the third-to-last function defined in this file:
 -//   configureControlPortModule(ipcFile, host, port, password)
 -// for usage of the configureControlPortModule function.
 -//
 -// See the last functions defined in this file:
 -//   controller(avoidCache), wait_for_controller(avoidCache)
 -// for usage of the controller functions.
+-
 -/* jshint esnext: true */
 -/* jshint -W097 */
 -/* global console */
 -"use strict";
+-
 -const { XPCOMUtils } = ChromeUtils.importESModule(
 -  "resource://gre/modules/XPCOMUtils.sys.mjs"
 -);
+-
 -ChromeUtils.defineModuleGetter(
 -  this,
 -  "TorMonitorService",
 -  "resource://gre/modules/TorMonitorService.jsm"
 -);
+-
 -XPCOMUtils.defineLazyServiceGetter(
 -  this,
 -  "logger",
 -  "@torproject.org/torbutton-logger;1",
 -  "nsISupports"
 -);
+-
 -// tor-launcher observer topics
 -const TorTopics = Object.freeze({
 -  ProcessIsReady: "TorProcessIsReady",
 -});
+-
 -// __log__.
 -// Logging function
 -let log = x =>
 -  logger.wrappedJSObject.eclog(3, x.trimRight().replace(/\r\n/g, "\n"));
+-
 -// ### announce this file
 -log("Loading tor-control-port.js\n");
+-
 -class AsyncSocket {
 -  constructor(ipcFile, host, port) {
 -    let sts = Cc["@mozilla.org/network/socket-transport-service;1"].getService(
 -      Ci.nsISocketTransportService
 -    );
 -    const OPEN_UNBUFFERED = Ci.nsITransport.OPEN_UNBUFFERED;
+-
 -    let socketTransport = ipcFile
 -      ? sts.createUnixDomainTransport(ipcFile)
 -      : sts.createTransport([], host, port, null, null);
+-
 -    this.outputStream = socketTransport
 -      .openOutputStream(OPEN_UNBUFFERED, 1, 1)
 -      .QueryInterface(Ci.nsIAsyncOutputStream);
 -    this.outputQueue = [];
+-
 -    this.inputStream = socketTransport
 -      .openInputStream(OPEN_UNBUFFERED, 1, 1)
 -      .QueryInterface(Ci.nsIAsyncInputStream);
 -    this.scriptableInputStream = Cc[
 -      "@mozilla.org/scriptableinputstream;1"
 -    ].createInstance(Ci.nsIScriptableInputStream);
 -    this.scriptableInputStream.init(this.inputStream);
 -    this.inputQueue = [];
 -  }
+-
 -  // asynchronously write string to underlying socket and return number of bytes written
 -  async write(str) {
 -    return new Promise((resolve, reject) => {
 -      // asyncWait next write request
 -      const tryAsyncWait = () => {
 -        if (this.outputQueue.length) {
 -          this.outputStream.asyncWait(
 -            this.outputQueue.at(0), // next request
 -            0,
 -            0,
 -            Services.tm.currentThread
 -          );
 -        }
 -      };
+-
 -      // output stream can only have 1 registered callback at a time, so multiple writes
 -      // need to be queued up (see nsIAsyncOutputStream.idl)
 -      this.outputQueue.push({
 -        // Implement an nsIOutputStreamCallback:
 -        onOutputStreamReady: () => {
 -          try {
 -            let bytesWritten = this.outputStream.write(str, str.length);
+-
 -            // remove this callback object from queue as it is now completed
 -            this.outputQueue.shift();
+-
 -            // request next wait if there is one
 -            tryAsyncWait();
+-
 -            // finally resolve promise
 -            resolve(bytesWritten);
 -          } catch (err) {
 -            // reject promise on error
 -            reject(err);
 -          }
 -        },
 -      });
+-
 -      // length 1 imples that there is no in-flight asyncWait, so we may immediately
 -      // follow through on this write
 -      if (this.outputQueue.length == 1) {
 -        tryAsyncWait();
 -      }
 -    });
 -  }
+-
 -  // asynchronously read string from underlying socket and return it
 -  async read() {
 -    return new Promise((resolve, reject) => {
 -      const tryAsyncWait = () => {
 -        if (this.inputQueue.length) {
 -          this.inputStream.asyncWait(
 -            this.inputQueue.at(0), // next input request
 -            0,
 -            0,
 -            Services.tm.currentThread
 -          );
 -        }
 -      };
+-
 -      this.inputQueue.push({
 -        onInputStreamReady: stream => {
 -          try {
 -            if (!this.scriptableInputStream.available()) {
 -              // This means EOF, but not closed yet. However, arriving at EOF
 -              // should be an error condition for us, since we are in a socket,
 -              // and EOF should mean peer disconnected.
 -              // If the stream has been closed, this function itself should
 -              // throw.
 -              reject(
 -                new Error("onInputStreamReady called without available bytes.")
 -              );
 -              return;
 -            }
+-
 -            // read our string from input stream
 -            let str = this.scriptableInputStream.read(
 -              this.scriptableInputStream.available()
 -            );
+-
 -            // remove this callback object from queue now that we have read
 -            this.inputQueue.shift();
+-
 -            // request next wait if there is one
 -            tryAsyncWait();
+-
 -            // finally resolve promise
 -            resolve(str);
 -          } catch (err) {
 -            reject(err);
 -          }
 -        },
 -      });
+-
 -      // length 1 imples that there is no in-flight asyncWait, so we may immediately
 -      // follow through on this read
 -      if (this.inputQueue.length == 1) {
 -        tryAsyncWait();
 -      }
 -    });
 -  }
+-
 -  close() {
 -    this.outputStream.close();
 -    this.inputStream.close();
 -  }
 -}
+-
 -class ControlSocket {
 -  constructor(asyncSocket) {
 -    this.socket = asyncSocket;
 -    this._isOpen = true;
 -    this.pendingData = "";
 -    this.pendingLines = [];
+-
 -    this.mainDispatcher = io.callbackDispatcher();
 -    this.notificationDispatcher = io.callbackDispatcher();
 -    // mainDispatcher pushes only async notifications (650) to notificationDispatcher
 -    this.mainDispatcher.addCallback(
 -      /^650/,
 -      this._handleNotification.bind(this)
 -    );
 -    // callback for handling responses and errors
 -    this.mainDispatcher.addCallback(
 -      /^[245]\d\d/,
 -      this._handleCommandReply.bind(this)
 -    );
+-
 -    this.commandQueue = [];
+-
 -    this._startMessagePump();
 -  }
+-
 -  // blocks until an entire line is read and returns it
 -  // immediately returns next line in queue (pendingLines) if present
 -  async _readLine() {
 -    // keep reading from socket until we have a full line to return
 -    while (!this.pendingLines.length) {
 -      // read data from our socket and spit on newline tokens
 -      this.pendingData += await this.socket.read();
 -      let lines = this.pendingData.split("\r\n");
+-
 -      // the last line will either be empty string, or a partial read of a response/event
 -      // so save it off for the next socket read
 -      this.pendingData = lines.pop();
+-
 -      // copy remaining full lines to our pendingLines list
 -      this.pendingLines = this.pendingLines.concat(lines);
 -    }
 -    return this.pendingLines.shift();
 -  }
+-
 -  // blocks until an entire message is ready and returns it
 -  async _readMessage() {
 -    // whether we are searching for the end of a multi-line values
 -    // See control-spec section 3.9
 -    let handlingMultlineValue = false;
 -    let endOfMessageFound = false;
 -    const message = [];
+-
 -    do {
 -      const line = await this._readLine();
 -      message.push(line);
+-
 -      if (handlingMultlineValue) {
 -        // look for end of multiline
 -        if (line.match(/^\.$/)) {
 -          handlingMultlineValue = false;
 -        }
 -      } else {
 -        // 'Multiline values' are possible. We avoid interrupting one by detecting it
 -        // and waiting for a terminating "." on its own line.
 -        // (See control-spec section 3.9 and https://trac.torproject.org/16990#comment:28
 -        // Ensure this is the first line of a new message
 -        // eslint-disable-next-line no-lonely-if
 -        if (message.length === 1 && line.match(/^\d\d\d\+.+?=$/)) {
 -          handlingMultlineValue = true;
 -        }
 -        // look for end of message (note the space character at end of the regex)
 -        else if (line.match(/^\d\d\d /)) {
 -          if (message.length == 1) {
 -            endOfMessageFound = true;
 -          } else {
 -            let firstReplyCode = message[0].substring(0, 3);
 -            let lastReplyCode = line.substring(0, 3);
 -            if (firstReplyCode == lastReplyCode) {
 -              endOfMessageFound = true;
 -            }
 -          }
 -        }
 -      }
 -    } while (!endOfMessageFound);
+-
 -    // join our lines back together to form one message
 -    return message.join("\r\n");
 -  }
+-
 -  async _startMessagePump() {
 -    try {
 -      while (true) {
 -        let message = await this._readMessage();
 -        log("controlPort >> " + message);
 -        this.mainDispatcher.pushMessage(message);
 -      }
 -    } catch (err) {
 -      this._isOpen = false;
 -      for (const cmd of this.commandQueue) {
 -        cmd.reject(err);
 -      }
 -      this.commandQueue = [];
 -    }
 -  }
+-
 -  _writeNextCommand() {
 -    let cmd = this.commandQueue[0];
 -    log("controlPort << " + cmd.commandString);
 -    this.socket.write(`${cmd.commandString}\r\n`).catch(cmd.reject);
 -  }
+-
 -  async sendCommand(commandString) {
 -    if (!this.isOpen()) {
 -      throw new Error("ControlSocket not open");
 -    }
+-
 -    // this promise is resolved either in _handleCommandReply, or
 -    // in _startMessagePump (on stream error)
 -    return new Promise((resolve, reject) => {
 -      let command = {
 -        commandString,
 -        resolve,
 -        reject,
 -      };
+-
 -      this.commandQueue.push(command);
 -      if (this.commandQueue.length == 1) {
 -        this._writeNextCommand();
 -      }
 -    });
 -  }
+-
 -  _handleCommandReply(message) {
 -    let cmd = this.commandQueue.shift();
 -    if (message.match(/^2/)) {
 -      cmd.resolve(message);
 -    } else if (message.match(/^[45]/)) {
 -      let myErr = new Error(cmd.commandString + " -> " + message);
 -      // Add Tor-specific information to the Error object.
 -      let idx = message.indexOf(" ");
 -      if (idx > 0) {
 -        myErr.torStatusCode = message.substring(0, idx);
 -        myErr.torMessage = message.substring(idx);
 -      } else {
 -        myErr.torStatusCode = message;
 -      }
 -      cmd.reject(myErr);
 -    } else {
 -      cmd.reject(
 -        new Error(
 -          `ControlSocket::_handleCommandReply received unexpected message:\n----\n${message}\n----`
 -        )
 -      );
 -    }
+-
 -    // send next command if one is available
 -    if (this.commandQueue.length) {
 -      this._writeNextCommand();
 -    }
 -  }
+-
 -  _handleNotification(message) {
 -    this.notificationDispatcher.pushMessage(message);
 -  }
+-
 -  close() {
 -    this.socket.close();
 -    this._isOpen = false;
 -  }
+-
 -  addNotificationCallback(regex, callback) {
 -    this.notificationDispatcher.addCallback(regex, callback);
 -  }
+-
 -  isOpen() {
 -    return this._isOpen;
 -  }
 -}
+-
 -// ## io
 -// I/O utilities namespace
+-
 -let io = {};
+-
 -// __io.callbackDispatcher()__.
 -// Returns dispatcher object with three member functions:
 -// dispatcher.addCallback(regex, callback), dispatcher.removeCallback(callback),
 -// and dispatcher.pushMessage(message).
 -// Pass pushMessage to another function that needs a callback with a single string
 -// argument. Whenever dispatcher.pushMessage receives a string, the dispatcher will
 -// check for any regex matches and pass the string on to the corresponding callback(s).
 -io.callbackDispatcher = function () {
 -  let callbackPairs = [],
 -    removeCallback = function (aCallback) {
 -      callbackPairs = callbackPairs.filter(function ([regex, callback]) {
 -        return callback !== aCallback;
 -      });
 -    },
 -    addCallback = function (regex, callback) {
 -      if (callback) {
 -        callbackPairs.push([regex, callback]);
 -      }
 -      return function () {
 -        removeCallback(callback);
 -      };
 -    },
 -    pushMessage = function (message) {
 -      for (let [regex, callback] of callbackPairs) {
 -        if (message.match(regex)) {
 -          callback(message);
 -        }
 -      }
 -    };
 -  return {
 -    pushMessage,
 -    removeCallback,
 -    addCallback,
 -  };
 -};
+-
 -// __io.controlSocket(ipcFile, host, port, password)__.
 -// Instantiates and returns a socket to a tor ControlPort at ipcFile or
 -// host:port, authenticating with the given password. Example:
 -//
 -//     // Open the socket
 -//     let socket = await io.controlSocket(undefined, "127.0.0.1", 9151, "MyPassw0rd");
 -//     // Send command and receive "250" response reply or error is thrown
 -//     await socket.sendCommand(commandText);
 -//     // Register or deregister for "650" notifications
 -//     // that match regex
 -//     socket.addNotificationCallback(regex, callback);
 -//     socket.removeNotificationCallback(callback);
 -//     // Close the socket permanently
 -//     socket.close();
 -io.controlSocket = async function (ipcFile, host, port, password) {
 -  let socket = new AsyncSocket(ipcFile, host, port);
 -  let controlSocket = new ControlSocket(socket);
+-
 -  // Log in to control port.
 -  await controlSocket.sendCommand("authenticate " + (password || ""));
 -  // Activate needed events.
 -  await controlSocket.sendCommand("setevents stream");
+-
 -  return controlSocket;
 -};
+-
 -// ## utils
 -// A namespace for utility functions
 -let utils = {};
+-
 -// __utils.identity(x)__.
 -// Returns its argument unchanged.
 -utils.identity = function (x) {
 -  return x;
 -};
+-
 -// __utils.isString(x)__.
 -// Returns true iff x is a string.
 -utils.isString = function (x) {
 -  return typeof x === "string" || x instanceof String;
 -};
+-
 -// __utils.capture(string, regex)__.
 -// Takes a string and returns an array of capture items, where regex must have a single
 -// capturing group and use the suffix /.../g to specify a global search.
 -utils.capture = function (string, regex) {
 -  let matches = [];
 -  // Special trick to use string.replace for capturing multiple matches.
 -  string.replace(regex, function (a, captured) {
 -    matches.push(captured);
 -  });
 -  return matches;
 -};
+-
 -// __utils.extractor(regex)__.
 -// Returns a function that takes a string and returns an array of regex matches. The
 -// regex must use the suffix /.../g to specify a global search.
 -utils.extractor = function (regex) {
 -  return function (text) {
 -    return utils.capture(text, regex);
 -  };
 -};
+-
 -// __utils.splitLines(string)__.
 -// Splits a string into an array of strings, each corresponding to a line.
 -utils.splitLines = function (string) {
 -  return string.split(/\r?\n/);
 -};
+-
 -// __utils.splitAtSpaces(string)__.
 -// Splits a string into chunks between spaces. Does not split at spaces
 -// inside pairs of quotation marks.
 -utils.splitAtSpaces = utils.extractor(/((\S*?"(.*?)")+\S*|\S+)/g);
+-
 -// __utils.splitAtFirst(string, regex)__.
 -// Splits a string at the first instance of regex match. If no match is
 -// found, returns the whole string.
 -utils.splitAtFirst = function (string, regex) {
 -  let match = string.match(regex);
 -  return match
 -    ? [
 -        string.substring(0, match.index),
 -        string.substring(match.index + match[0].length),
 -      ]
 -    : string;
 -};
+-
 -// __utils.splitAtEquals(string)__.
 -// Splits a string into chunks between equals. Does not split at equals
 -// inside pairs of quotation marks.
 -utils.splitAtEquals = utils.extractor(/(([^=]*?"(.*?)")+[^=]*|[^=]+)/g);
+-
 -// __utils.mergeObjects(arrayOfObjects)__.
 -// Takes an array of objects like [{"a":"b"},{"c":"d"}] and merges to a single object.
 -// Pure function.
 -utils.mergeObjects = function (arrayOfObjects) {
 -  let result = {};
 -  for (let obj of arrayOfObjects) {
 -    for (let key in obj) {
 -      result[key] = obj[key];
 -    }
 -  }
 -  return result;
 -};
+-
 -// __utils.listMapData(parameterString, listNames)__.
 -// Takes a list of parameters separated by spaces, of which the first several are
 -// unnamed, and the remainder are named, in the form `NAME=VALUE`. Apply listNames
 -// to the unnamed parameters, and combine them in a map with the named parameters.
 -// Example: `40 FAILED 0 95.78.59.36:80 REASON=CANT_ATTACH`
 -//
 -//     utils.listMapData("40 FAILED 0 95.78.59.36:80 REASON=CANT_ATTACH",
 -//                       ["streamID", "event", "circuitID", "IP"])
 -//     // --> {"streamID" : "40", "event" : "FAILED", "circuitID" : "0",
 -//     //      "address" : "95.78.59.36:80", "REASON" : "CANT_ATTACH"}"
 -utils.listMapData = function (parameterString, listNames) {
 -  // Split out the space-delimited parameters.
 -  let parameters = utils.splitAtSpaces(parameterString),
 -    dataMap = {};
 -  // Assign listNames to the first n = listNames.length parameters.
 -  for (let i = 0; i < listNames.length; ++i) {
 -    dataMap[listNames[i]] = parameters[i];
 -  }
 -  // Read key-value pairs and copy these to the dataMap.
 -  for (let i = listNames.length; i < parameters.length; ++i) {
 -    let [key, value] = utils.splitAtEquals(parameters[i]);
 -    if (key && value) {
 -      dataMap[key] = value;
 -    }
 -  }
 -  return dataMap;
 -};
+-
 -// __utils.rejectPromise(errorMessage)__.
 -// Returns a rejected promise with the given error message.
 -utils.rejectPromise = errorMessage => Promise.reject(new Error(errorMessage));
+-
 -// ## info
 -// A namespace for functions related to tor's GETINFO and GETCONF command.
 -let info = {};
+-
 -// __info.keyValueStringsFromMessage(messageText)__.
 -// Takes a message (text) response to GETINFO or GETCONF and provides
 -// a series of key-value strings, which are either multiline (with a `250+` prefix):
 -//
 -//     250+config/defaults=
 -//     AccountingMax "0 bytes"
 -//     AllowDotExit "0"
 -//     .
 -//
 -// or single-line (with a `250-` or `250 ` prefix):
 -//
 -//     250-version=0.2.6.0-alpha-dev (git-b408125288ad6943)
 -info.keyValueStringsFromMessage = utils.extractor(
 -  /^(250\+[\s\S]+?^\.|250[- ].+?)$/gim
 -);
+-
 -// __info.applyPerLine(transformFunction)__.
 -// Returns a function that splits text into lines,
 -// and applies transformFunction to each line.
 -info.applyPerLine = function (transformFunction) {
 -  return function (text) {
 -    return utils.splitLines(text.trim()).map(transformFunction);
 -  };
 -};
+-
 -// __info.routerStatusParser(valueString)__.
 -// Parses a router status entry as, described in
 -// https://gitweb.torproject.org/torspec.git/tree/dir-spec.txt
 -// (search for "router status entry")
 -info.routerStatusParser = function (valueString) {
 -  let lines = utils.splitLines(valueString),
 -    objects = [];
 -  for (let line of lines) {
 -    // Drop first character and grab data following it.
 -    let myData = line.substring(2),
 -      // Accumulate more maps with data, depending on the first character in the line.
 -      dataFun = {
 -        r: data =>
 -          utils.listMapData(data, [
 -            "nickname",
 -            "identity",
 -            "digest",
 -            "publicationDate",
 -            "publicationTime",
 -            "IP",
 -            "ORPort",
 -            "DirPort",
 -          ]),
 -        a: data => ({ IPv6: data }),
 -        s: data => ({ statusFlags: utils.splitAtSpaces(data) }),
 -        v: data => ({ version: data }),
 -        w: data => utils.listMapData(data, []),
 -        p: data => ({ portList: data.split(",") }),
 -      }[line.charAt(0)];
 -    if (dataFun !== undefined) {
 -      objects.push(dataFun(myData));
 -    }
 -  }
 -  return utils.mergeObjects(objects);
 -};
+-
 -// __info.circuitStatusParser(line)__.
 -// Parse the output of a circuit status line.
 -info.circuitStatusParser = function (line) {
 -  let data = utils.listMapData(line, ["id", "status", "circuit"]),
 -    circuit = data.circuit;
 -  // Parse out the individual circuit IDs and names.
 -  if (circuit) {
 -    data.circuit = circuit.split(",").map(function (x) {
 -      return x.split(/~|=/);
 -    });
 -  }
 -  return data;
 -};
+-
 -// __info.streamStatusParser(line)__.
 -// Parse the output of a stream status line.
 -info.streamStatusParser = function (text) {
 -  return utils.listMapData(text, [
 -    "StreamID",
 -    "StreamStatus",
 -    "CircuitID",
 -    "Target",
 -  ]);
 -};
+-
 -// TODO: fix this parsing logic to handle bridgeLine correctly
 -// fingerprint/id is an optional parameter
 -// __info.bridgeParser(bridgeLine)__.
 -// Takes a single line from a `getconf bridge` result and returns
 -// a map containing the bridge's type, address, and ID.
 -info.bridgeParser = function (bridgeLine) {
 -  let result = {},
 -    tokens = bridgeLine.split(/\s+/);
 -  // First check if we have a "vanilla" bridge:
 -  if (tokens[0].match(/^\d+\.\d+\.\d+\.\d+/)) {
 -    result.type = "vanilla";
 -    [result.address, result.ID] = tokens;
 -    // Several bridge types have a similar format:
 -  } else {
 -    result.type = tokens[0];
 -    if (
 -      [
 -        "flashproxy",
 -        "fte",
 -        "meek",
 -        "meek_lite",
 -        "obfs3",
 -        "obfs4",
 -        "scramblesuit",
 -        "snowflake",
 -      ].includes(result.type)
 -    ) {
 -      [result.address, result.ID] = tokens.slice(1);
 -    }
 -  }
 -  return result.type ? result : null;
 -};
+-
 -// __info.parsers__.
 -// A map of GETINFO and GETCONF keys to parsing function, which convert
 -// result strings to _javascript_ data.
 -info.parsers = {
 -  "ns/id/": info.routerStatusParser,
 -  "ip-to-country/": utils.identity,
 -  "circuit-status": info.applyPerLine(info.circuitStatusParser),
 -  bridge: info.bridgeParser,
 -  // Currently unused parsers:
 -  //  "ns/name/" : info.routerStatusParser,
 -  //  "stream-status" : info.applyPerLine(info.streamStatusParser),
 -  //  "version" : utils.identity,
 -  //  "config-file" : utils.identity,
 -};
+-
 -// __info.getParser(key)__.
 -// Takes a key and determines the parser function that should be used to
 -// convert its corresponding valueString to _javascript_ data.
 -info.getParser = function (key) {
 -  return (
 -    info.parsers[key] ||
 -    info.parsers[key.substring(0, key.lastIndexOf("/") + 1)]
 -  );
 -};
+-
 -// __info.stringToValue(string)__.
 -// Converts a key-value string as from GETINFO or GETCONF to a value.
 -info.stringToValue = function (string) {
 -  // key should look something like `250+circuit-status=` or `250-circuit-status=...`
 -  // or `250 circuit-status=...`
 -  let matchForKey = string.match(/^250[ +-](.+?)=/),
 -    key = matchForKey ? matchForKey[1] : null;
 -  if (key === null) {
 -    return null;
 -  }
 -  // matchResult finds a single-line result for `250-` or `250 `,
 -  // or a multi-line one for `250+`.
 -  let matchResult =
 -      string.match(/^250[ -].+?=(.*)$/) ||
 -      string.match(/^250\+.+?=([\s\S]*?)^\.$/m),
 -    // Retrieve the captured group (the text of the value in the key-value pair)
 -    valueString = matchResult ? matchResult[1] : null,
 -    // Get the parser function for the key found.
 -    parse = info.getParser(key.toLowerCase());
 -  if (parse === undefined) {
 -    throw new Error("No parser found for '" + key + "'");
 -  }
 -  // Return value produced by the parser.
 -  return parse(valueString);
 -};
+-
 -// __info.getMultipleResponseValues(message)__.
 -// Process multiple responses to a GETINFO or GETCONF request.
 -info.getMultipleResponseValues = function (message) {
 -  return info
 -    .keyValueStringsFromMessage(message)
 -    .map(info.stringToValue)
 -    .filter(utils.identity);
 -};
+-
 -// __info.getInfo(controlSocket, key)__.
 -// Sends GETINFO for a single key. Returns a promise with the result.
 -info.getInfo = function (aControlSocket, key) {
 -  if (!utils.isString(key)) {
 -    return utils.rejectPromise("key argument should be a string");
 -  }
 -  return aControlSocket
 -    .sendCommand("getinfo " + key)
 -    .then(response => info.getMultipleResponseValues(response)[0]);
 -};
+-
 -// __info.getConf(aControlSocket, key)__.
 -// Sends GETCONF for a single key. Returns a promise with the result.
 -info.getConf = function (aControlSocket, key) {
 -  // GETCONF with a single argument returns results with
 -  // one or more lines that look like `250[- ]key=value`.
 -  // Any GETCONF lines that contain a single keyword only are currently dropped.
 -  // So we can use similar parsing to that for getInfo.
 -  if (!utils.isString(key)) {
 -    return utils.rejectPromise("key argument should be a string");
 -  }
 -  return aControlSocket
 -    .sendCommand("getconf " + key)
 -    .then(info.getMultipleResponseValues);
 -};
+-
 -// ## onionAuth
 -// A namespace for functions related to tor's ONION_CLIENT_AUTH_* commands.
 -let onionAuth = {};
+-
 -onionAuth.keyInfoStringsFromMessage = utils.extractor(/^250-CLIENT\s+(.+)$/gim);
+-
 -onionAuth.keyInfoObjectsFromMessage = function (message) {
 -  let keyInfoStrings = onionAuth.keyInfoStringsFromMessage(message);
 -  return keyInfoStrings.map(infoStr =>
 -    utils.listMapData(infoStr, ["hsAddress", "typeAndKey"])
 -  );
 -};
+-
 -// __onionAuth.viewKeys()__.
 -// Sends a ONION_CLIENT_AUTH_VIEW command to retrieve the list of private keys.
 -// Returns a promise that is fulfilled with an array of key info objects which
 -// contain the following properties:
 -//   hsAddress
 -//   typeAndKey
 -//   Flags (e.g., "Permanent")
 -onionAuth.viewKeys = function (aControlSocket) {
 -  let cmd = "onion_client_auth_view";
 -  return aControlSocket
 -    .sendCommand(cmd)
 -    .then(onionAuth.keyInfoObjectsFromMessage);
 -};
+-
 -// __onionAuth.add(controlSocket, hsAddress, b64PrivateKey, isPermanent)__.
 -// Sends a ONION_CLIENT_AUTH_ADD command to add a private key to the
 -// Tor configuration.
 -onionAuth.add = function (
 -  aControlSocket,
 -  hsAddress,
 -  b64PrivateKey,
 -  isPermanent
 -) {
 -  if (!utils.isString(hsAddress)) {
 -    return utils.rejectPromise("hsAddress argument should be a string");
 -  }
+-
 -  if (!utils.isString(b64PrivateKey)) {
 -    return utils.rejectPromise("b64PrivateKey argument should be a string");
 -  }
+-
 -  const keyType = "x25519";
 -  let cmd = `onion_client_auth_add ${hsAddress} ${keyType}:${b64PrivateKey}`;
 -  if (isPermanent) {
 -    cmd += " Flags=Permanent";
 -  }
 -  return aControlSocket.sendCommand(cmd);
 -};
+-
 -// __onionAuth.remove(controlSocket, hsAddress)__.
 -// Sends a ONION_CLIENT_AUTH_REMOVE command to remove a private key from the
 -// Tor configuration.
 -onionAuth.remove = function (aControlSocket, hsAddress) {
 -  if (!utils.isString(hsAddress)) {
 -    return utils.rejectPromise("hsAddress argument should be a string");
 -  }
+-
 -  let cmd = `onion_client_auth_remove ${hsAddress}`;
 -  return aControlSocket.sendCommand(cmd);
 -};
+-
 -// ## event
 -// Handlers for events
+-
 -let event = {};
+-
 -// __event.parsers__.
 -// A map of EVENT keys to parsing functions, which convert result strings to _javascript_
 -// data.
 -event.parsers = {
 -  stream: info.streamStatusParser,
 -  // Currently unused:
 -  // "circ" : info.circuitStatusParser,
 -};
+-
 -// __event.messageToData(type, message)__.
 -// Extract the data from an event. Note, at present
 -// we only extract streams that look like `"650" SP...`
 -event.messageToData = function (type, message) {
 -  let dataText = message.match(/^650 \S+?\s(.*)/m)[1];
 -  return dataText && type.toLowerCase() in event.parsers
 -    ? event.parsers[type.toLowerCase()](dataText)
 -    : null;
 -};
+-
 -// __event.watchEvent(controlSocket, type, filter, onData)__.
 -// Watches for a particular type of event. If filter(data) returns true, the event's
 -// data is passed to the onData callback. Returns a zero arg function that
 -// stops watching the event. Note: we only observe `"650" SP...` events
 -// currently (no `650+...` or `650-...` events).
 -event.watchEvent = function (controlSocket, type, filter, onData, raw = false) {
 -  controlSocket.addNotificationCallback(
 -    new RegExp("^650 " + type),
 -    function (message) {
 -      let data = event.messageToData(type, message);
 -      if (filter === null || filter(data)) {
 -        if (raw || !data) {
 -          onData(message);
 -          return;
 -        }
 -        onData(data);
 -      }
 -    }
 -  );
 -};
+-
 -// ## tor
 -// Things related to the main controller.
 -let tor = {};
+-
 -// __tor.controllerCache__.
 -// A map from "unix:socketpath" or "host:port" to controller objects. Prevents
 -// redundant instantiation of control sockets.
 -tor.controllerCache = new Map();
+-
 -// __tor.controller(ipcFile, host, port, password)__.
 -// Creates a tor controller at the given ipcFile or host and port, with the
 -// given password.
 -tor.controller = async function (ipcFile, host, port, password) {
 -  let socket = await io.controlSocket(ipcFile, host, port, password);
 -  return {
 -    getInfo: key => info.getInfo(socket, key),
 -    getConf: key => info.getConf(socket, key),
 -    onionAuthViewKeys: () => onionAuth.viewKeys(socket),
 -    onionAuthAdd: (hsAddress, b64PrivateKey, isPermanent) =>
 -      onionAuth.add(socket, hsAddress, b64PrivateKey, isPermanent),
 -    onionAuthRemove: hsAddress => onionAuth.remove(socket, hsAddress),
 -    watchEvent: (type, filter, onData, raw = false) => {
 -      event.watchEvent(socket, type, filter, onData, raw);
 -    },
 -    isOpen: () => socket.isOpen(),
 -    close: () => {
 -      socket.close();
 -    },
 -    sendCommand: cmd => socket.sendCommand(cmd),
 -  };
 -};
+-
 -// ## Export
+-
 -let controlPortInfo = {};
+-
 -// __configureControlPortModule(ipcFile, host, port, password)__.
 -// Sets Tor control port connection parameters to be used in future calls to
 -// the controller() function. Example:
 -//     configureControlPortModule(undefined, "127.0.0.1", 9151, "MyPassw0rd");
 -var configureControlPortModule = function (ipcFile, host, port, password) {
 -  controlPortInfo.ipcFile = ipcFile;
 -  controlPortInfo.host = host;
 -  controlPortInfo.port = port || 9151;
 -  controlPortInfo.password = password;
 -};
+-
 -// __controller(avoidCache)__.
 -// Instantiates and returns a controller object that is connected and
 -// authenticated to a Tor ControlPort using the connection parameters
 -// provided in the most recent call to configureControlPortModule(), if
 -// the controller doesn't yet exist. Otherwise returns the existing
 -// controller to the given ipcFile or host:port. Throws on error.
 -//
 -// Example:
 -//
 -//     // Get a new controller
 -//     const avoidCache = true;
 -//     let c = controller(avoidCache);
 -//     // Send command and receive `250` reply or error message in a promise:
 -//     let replyPromise = c.getInfo("ip-to-country/16.16.16.16");
 -//     // Close the controller permanently
 -//     c.close();
 -var controller = async function (avoidCache) {
 -  if (!controlPortInfo.ipcFile && !controlPortInfo.host) {
 -    throw new Error("Please call configureControlPortModule first");
 -  }
+-
 -  const dest = controlPortInfo.ipcFile
 -    ? `unix:${controlPortInfo.ipcFile.path}`
 -    : `${controlPortInfo.host}:${controlPortInfo.port}`;
+-
 -  // constructor shorthand
 -  const newTorController = async () => {
 -    return tor.controller(
 -      controlPortInfo.ipcFile,
 -      controlPortInfo.host,
 -      controlPortInfo.port,
 -      controlPortInfo.password
 -    );
 -  };
+-
 -  // avoid cache so always return a new controller
 -  if (avoidCache) {
 -    return newTorController();
 -  }
+-
 -  // first check our cache and see if we already have one
 -  let cachedController = tor.controllerCache.get(dest);
 -  if (cachedController && cachedController.isOpen()) {
 -    return cachedController;
 -  }
+-
 -  // create a new one and store in the map
 -  cachedController = await newTorController();
 -  // overwrite the close() function to prevent consumers from closing a shared/cached controller
 -  cachedController.close = () => {
 -    throw new Error("May not close cached Tor Controller as it may be in use");
 -  };
+-
 -  tor.controllerCache.set(dest, cachedController);
 -  return cachedController;
 -};
+-
 -// __wait_for_controller(avoidCache)
 -// Same as controller() function, but explicitly waits until there is a tor daemon
 -// to connect to (either launched by tor-launcher, or if we have an existing system
 -// tor daemon)
 -var wait_for_controller = function (avoidCache) {
 -  // if tor process is running (either ours or system) immediately return controller
 -  if (!TorMonitorService.ownsTorDaemon || TorMonitorService.isRunning) {
 -    return controller(avoidCache);
 -  }
+-
 -  // otherwise we must wait for tor to finish launching before resolving
 -  return new Promise((resolve, reject) => {
 -    let observer = {
 -      observe: async (subject, topic, data) => {
 -        if (topic === TorTopics.ProcessIsReady) {
 -          try {
 -            resolve(await controller(avoidCache));
 -          } catch (err) {
 -            reject(err);
 -          }
 -          Services.obs.removeObserver(observer, TorTopics.ProcessIsReady);
 -        }
 -      },
 -    };
 -    Services.obs.addObserver(observer, TorTopics.ProcessIsReady);
 -  });
 -};
+-
 -// Export functions for external use.
 -var EXPORTED_SYMBOLS = [
 -  "configureControlPortModule",
 -  "controller",
 -  "wait_for_controller",
 -];

toolkit/torbutton/modules/utils.js deleted

 -// # Utils.js
 -// Various helpful utility functions.
+-
 -// ### Import Mozilla Services
 -const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+-
 -// ## Pref utils
+-
 -// __prefs__. A shortcut to Mozilla Services.prefs.
 -let prefs = Services.prefs;
+-
 -// __getPrefValue(prefName)__
 -// Returns the current value of a preference, regardless of its type.
 -var getPrefValue = function (prefName) {
 -  switch (prefs.getPrefType(prefName)) {
 -    case prefs.PREF_BOOL:
 -      return prefs.getBoolPref(prefName);
 -    case prefs.PREF_INT:
 -      return prefs.getIntPref(prefName);
 -    case prefs.PREF_STRING:
 -      return prefs.getCharPref(prefName);
 -    default:
 -      return null;
 -  }
 -};
+-
 -// __bindPref(prefName, prefHandler, init)__
 -// Applies prefHandler whenever the value of the pref changes.
 -// If init is true, applies prefHandler to the current value.
 -// Returns a zero-arg function that unbinds the pref.
 -var bindPref = function (prefName, prefHandler, init = false) {
 -  let update = () => {
 -      prefHandler(getPrefValue(prefName));
 -    },
 -    observer = {
 -      observe(subject, topic, data) {
 -        if (data === prefName) {
 -          update();
 -        }
 -      },
 -    };
 -  prefs.addObserver(prefName, observer);
 -  if (init) {
 -    update();
 -  }
 -  return () => {
 -    prefs.removeObserver(prefName, observer);
 -  };
 -};
+-
 -// __bindPrefAndInit(prefName, prefHandler)__
 -// Applies prefHandler to the current value of pref specified by prefName.
 -// Re-applies prefHandler whenever the value of the pref changes.
 -// Returns a zero-arg function that unbinds the pref.
 -var bindPrefAndInit = (prefName, prefHandler) =>
 -  bindPref(prefName, prefHandler, true);
+-
 -// ## Observers
+-
 -// __observe(topic, callback)__.
 -// Observe the given topic. When notification of that topic
 -// occurs, calls callback(subject, data). Returns a zero-arg
 -// function that stops observing.
 -var observe = function (topic, callback) {
 -  let observer = {
 -    observe(aSubject, aTopic, aData) {
 -      if (topic === aTopic) {
 -        callback(aSubject, aData);
 -      }
 -    },
 -  };
 -  Services.obs.addObserver(observer, topic);
 -  return () => Services.obs.removeObserver(observer, topic);
 -};
+-
 -// ## Environment variables
+-
 -// __getEnv(name)__.
 -// Reads the environment variable of the given name.
 -var getEnv = function (name) {
 -  return Services.env.exists(name) ? Services.env.get(name) : undefined;
 -};
+-
 -// __getLocale
 -// Returns the app locale to be used in tor-related urls.
 -var getLocale = function () {
 -  const locale = Services.locale.appLocaleAsBCP47;
 -  if (locale === "ja-JP-macos") {
 -    // We don't want to distinguish the mac locale.
 -    return "ja";
 -  }
 -  return locale;
 -};
+-
 -// ## Windows
+-
 -// __dialogsByName__.
 -// Map of window names to dialogs.
 -let dialogsByName = {};
+-
 -// __showDialog(parent, url, name, features, arg1, arg2, ...)__.
 -// Like window.openDialog, but if the window is already
 -// open, just focuses it instead of opening a new one.
 -var showDialog = function (parent, url, name, features) {
 -  let existingDialog = dialogsByName[name];
 -  if (existingDialog && !existingDialog.closed) {
 -    existingDialog.focus();
 -    return existingDialog;
 -  }
 -  let newDialog = parent.openDialog.apply(parent, Array.slice(arguments, 1));
 -  dialogsByName[name] = newDialog;
 -  return newDialog;
 -};
+-
 -// ## Tor control protocol utility functions
+-
 -let _torControl = {
 -  // Unescape Tor Control string aStr (removing surrounding "" and \ escapes).
 -  // Based on Vidalia's src/common/stringutil.cpp:string_unescape().
 -  // Returns the unescaped string. Throws upon failure.
 -  // Within Tor Launcher, the file components/tl-protocol.js also contains a
 -  // copy of _strUnescape().
 -  _strUnescape(aStr) {
 -    if (!aStr) {
 -      return aStr;
 -    }
+-
 -    var len = aStr.length;
 -    if (len < 2 || '"' != aStr.charAt(0) || '"' != aStr.charAt(len - 1)) {
 -      return aStr;
 -    }
+-
 -    const kHexRE = /[0-9A-Fa-f]{2}/;
 -    const kOctalRE = /[0-7]{3}/;
 -    var rv = "";
 -    var i = 1;
 -    var lastCharIndex = len - 2;
 -    while (i <= lastCharIndex) {
 -      var c = aStr.charAt(i);
 -      if ("\\" == c) {
 -        if (++i > lastCharIndex) {
 -          throw new Error("missing character after \\");
 -        }
+-
 -        c = aStr.charAt(i);
 -        if ("n" == c) {
 -          rv += "\n";
 -        } else if ("r" == c) {
 -          rv += "\r";
 -        } else if ("t" == c) {
 -          rv += "\t";
 -        } else if ("x" == c) {
 -          if (i + 2 > lastCharIndex) {
 -            throw new Error("not enough hex characters");
 -          }
+-
 -          let s = aStr.substr(i + 1, 2);
 -          if (!kHexRE.test(s)) {
 -            throw new Error("invalid hex characters");
 -          }
+-
 -          let val = parseInt(s, 16);
 -          rv += String.fromCharCode(val);
 -          i += 3;
 -        } else if (this._isDigit(c)) {
 -          let s = aStr.substr(i, 3);
 -          if (i + 2 > lastCharIndex) {
 -            throw new Error("not enough octal characters");
 -          }
+-
 -          if (!kOctalRE.test(s)) {
 -            throw new Error("invalid octal characters");
 -          }
+-
 -          let val = parseInt(s, 8);
 -          rv += String.fromCharCode(val);
 -          i += 3;
 -        } // "\\" and others
 -        else {
 -          rv += c;
 -          ++i;
 -        }
 -      } else if ('"' == c) {
 -        throw new Error('unescaped " within string');
 -      } else {
 -        rv += c;
 -        ++i;
 -      }
 -    }
+-
 -    // Convert from UTF-8 to Unicode. TODO: is UTF-8 always used in protocol?
 -    return decodeURIComponent(escape(rv));
 -  }, // _strUnescape()
+-
 -  // Within Tor Launcher, the file components/tl-protocol.js also contains a
 -  // copy of _isDigit().
 -  _isDigit(aChar) {
 -    const kRE = /^\d$/;
 -    return aChar && kRE.test(aChar);
 -  },
 -}; // _torControl
+-
 -// __unescapeTorString(str, resultObj)__.
 -// Unescape Tor Control string str (removing surrounding "" and \ escapes).
 -// Returns the unescaped string. Throws upon failure.
 -var unescapeTorString = function (str) {
 -  return _torControl._strUnescape(str);
 -};
+-
 -var m_tb_torlog = Cc["@torproject.org/torbutton-logger;1"].getService(
 -  Ci.nsISupports
 -).wrappedJSObject;
+-
 -var m_tb_string_bundle = torbutton_get_stringbundle();
+-
 -function torbutton_safelog(nLevel, sMsg, scrub) {
 -  m_tb_torlog.safe_log(nLevel, sMsg, scrub);
 -  return true;
 -}
+-
 -function torbutton_log(nLevel, sMsg) {
 -  m_tb_torlog.log(nLevel, sMsg);
+-
 -  // So we can use it in boolean expressions to determine where the
 -  // short-circuit is..
 -  return true;
 -}
+-
 -// load localization strings
 -function torbutton_get_stringbundle() {
 -  var o_stringbundle = false;
+-
 -  try {
 -    var oBundle = Services.strings;
 -    o_stringbundle = oBundle.createBundle(
 -      "chrome://torbutton/locale/torbutton.properties"
 -    );
 -  } catch (err) {
 -    o_stringbundle = false;
 -  }
 -  if (!o_stringbundle) {
 -    torbutton_log(5, "ERROR (init): failed to find torbutton-bundle");
 -  }
+-
 -  return o_stringbundle;
 -}
+-
 -function torbutton_get_property_string(propertyname) {
 -  try {
 -    if (!m_tb_string_bundle) {
 -      m_tb_string_bundle = torbutton_get_stringbundle();
 -    }
+-
 -    return m_tb_string_bundle.GetStringFromName(propertyname);
 -  } catch (e) {
 -    torbutton_log(4, "Unlocalized string " + propertyname);
 -  }
+-
 -  return propertyname;
 -}
+-
 -// Export utility functions for external use.
 -let EXPORTED_SYMBOLS = [
 -  "bindPref",
 -  "bindPrefAndInit",
 -  "getEnv",
 -  "getLocale",
 -  "getPrefValue",
 -  "observe",
 -  "showDialog",
 -  "show_torbrowser_manual",
 -  "unescapeTorString",
 -  "torbutton_safelog",
 -  "torbutton_log",
 -  "torbutton_get_property_string",
 -];

toolkit/torbutton/moz.build

@@ -3,8 +3,4 @@
  # 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/.
 -JAR_MANIFESTS += ['jar.mn']
+-
 -XPCOM_MANIFESTS += [
 -    "components.conf",
 -]
 +JAR_MANIFESTS += ["jar.mn"]

tools/lint/eslint/eslint-plugin-mozilla/lib/environments/browser-window.js

@@ -90,11 +90,7 @@ function getGlobalScriptIncludes(scriptPath) {
            "browser/components/screenshots/content/"
+         )
          .replace("chrome://browser/content/", "browser/base/content/")
 -        .replace("chrome://global/content/", "toolkit/content/")
 -        .replace(
 -          "chrome://torbutton/content/",
 -          "toolkit/torbutton/chrome/content/"
 -        );
 +        .replace("chrome://global/content/", "toolkit/content/");
        for (let mapping of Object.getOwnPropertyNames(MAPPINGS)) {
          if (sourceFile.includes(mapping)) {