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

4 Aug 2023


      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
=====================================
@@ -0,0 +1,1534 @@
+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#no...).
+        // 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
=====================================
@@ -1,5 +1,6 @@
 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
=====================================
@@ -1,148 +0,0 @@
-// 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
=====================================
@@ -1,10 +0,0 @@
-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
=====================================
@@ -1,19 +1,12 @@
 #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
=====================================
@@ -1,147 +0,0 @@
-// 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
=====================================
@@ -1,1002 +0,0 @@
-// 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
=====================================
@@ -1,276 +0,0 @@
-// # 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)) {
View it on GitLab: https://gitlab.torproject.org/tpo/applications/tor-browser/-/compare/f67d72d...
-- 
View it on GitLab: https://gitlab.torproject.org/tpo/applications/tor-browser/-/compare/f67d72d...
You're receiving this email because of your account on gitlab.torproject.org.





    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

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