--- a/toolkit/modules/moz.build
+++ b/toolkit/modules/moz.build
@@ -101,16 +101,20 @@ if CONFIG['MOZ_WIDGET_TOOLKIT'] in ('win
EXTRA_PP_JS_MODULES += [
'AppConstants.jsm',
]
if 'Android' != CONFIG['OS_TARGET']:
EXTRA_JS_MODULES += [
'LightweightThemeConsumer.jsm',
]
+
+ DIRS += [
+ 'subprocess',
+ ]
else:
DEFINES['ANDROID'] = True
if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
EXTRA_JS_MODULES += [
'WindowsRegistry.jsm',
]
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/.eslintrc
@@ -0,0 +1,26 @@
+{
+ "extends": "../../components/extensions/.eslintrc",
+
+ "env": {
+ "worker": true,
+ },
+
+ "globals": {
+ "ChromeWorker": false,
+ "Components": false,
+ "LIBC": true,
+ "Library": true,
+ "OS": false,
+ "Services": false,
+ "SubprocessConstants": true,
+ "ctypes": false,
+ "debug": true,
+ "dump": false,
+ "libc": true,
+ "unix": true,
+ },
+
+ "rules": {
+ "no-console": 0,
+ },
+}
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/Subprocess.jsm
@@ -0,0 +1,145 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* 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/. */
+
+/*
+ * These modules are loosely based on the subprocess.jsm module created
+ * by Jan Gerber and Patrick Brunschwig, though the implementation
+ * differs drastically.
+ */
+
+"use strict";
+
+let EXPORTED_SYMBOLS = ["Subprocess"];
+
+/* exported Subprocess */
+
+var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+Cu.import("resource://gre/modules/AppConstants.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/subprocess/subprocess_common.jsm");
+
+if (AppConstants.platform == "win") {
+ XPCOMUtils.defineLazyModuleGetter(this, "SubprocessImpl",
+ "resource://gre/modules/subprocess/subprocess_win.jsm");
+} else {
+ XPCOMUtils.defineLazyModuleGetter(this, "SubprocessImpl",
+ "resource://gre/modules/subprocess/subprocess_unix.jsm");
+}
+
+/**
+ * Allows for creation of and communication with OS-level sub-processes.
+ * @namespace
+ */
+var Subprocess = {
+ /**
+ * Launches a process, and returns a handle to it.
+ *
+ * @param {object} options
+ * An object describing the process to launch.
+ * @param {string} options.command
+ * The name of the execuable to launch. If not a full path, it is
+ * resolved to an executable by searching the directories in $PATH.
+ * @param {string[]} [options.arguments]
+ * A list of strings to pass as arguments to the process.
+ * @param {object} [options.environment]
+ * An object containing a key and value for each environment variable
+ * to pass to the process.
+ * @param {boolean} [options.environmentAppend]
+ * If true, append the environment variables passed in `environment` to
+ * the existing set of environment variables. Otherwise, the values in
+ * 'environment' constitute the entire set of environment variables
+ * passed to the new process.
+ * @param {string} [options.stderr]
+ * Defines how the process's stderr output is handled. One of:
+ *
+ * - "ignore": (default) The process's standard error is not
+ * redirected.
+ * - "stdout": The process's stderr is merged with its stdout.
+ * - "pipe": The process's stderr is redirected to a pipe, which can
+ * be read from via its `stderr` property.
+ *
+ * @param {string} [options.workdir]
+ * The working directory in which to launch the new process.
+ *
+ * @returns {Promise<Process>}
+ *
+ * @rejects {Error}
+ * May be rejected with an Error object if the process can not be
+ * launched. The object will include an `errorCode` property with
+ * one of the following values if it was rejected for the
+ * corresponding reason:
+ *
+ * - Subprocess.ERROR_BAD_EXECUTABLE: The given command could not
+ * be found, or the file that it references is not executable.
+ */
+ call(options) {
+ options = Object.assign({}, options);
+
+ options.stderr = options.stderr || "ignore";
+ options.workdir = options.workdir || null;
+
+ let environment = {};
+ if (!options.environment || options.environmentAppend) {
+ environment = this.getEnvironment();
+ }
+
+ if (options.environment) {
+ Object.assign(environment, options.environment);
+ }
+
+ options.environment = Object.keys(environment)
+ .map(key => `${key}=${environment[key]}`);
+
+ options.arguments = Array.from(options.arguments || []);
+
+ return this.pathSearch(options.command, environment).then(command => {
+ options.arguments.unshift(options.command);
+ options.command = command;
+
+ return SubprocessImpl.call(options);
+ });
+ },
+
+ /**
+ * Returns an object with a key-value pair for every variable in the process's
+ * current environment.
+ *
+ * @returns {object}
+ */
+ getEnvironment() {
+ let environment = Object.create(null);
+ for (let [k, v] of SubprocessImpl.getEnvironment()) {
+ environment[k] = v;
+ }
+ return environment;
+ },
+
+ /**
+ * Searches for the given executable file in the system executable
+ * file paths as specified by the PATH environment variable.
+ *
+ * On Windows, if the unadorned filename cannot be found, the
+ * extensions in the semicolon-separated list in the PATHSEP
+ * environment variable are successively appended to the original
+ * name and searched for in turn.
+ *
+ * @param {string} bin
+ * The name of the executable to find.
+ * @param {object} environment
+ * An object containing a key for each environment variable to be used
+ * in the search.
+ * @returns {Promise<string>}
+ */
+ pathSearch(command, environment) {
+ // Promise.resolve lets us get around returning one of the Promise.jsm
+ // pseudo-promises returned by Task.jsm.
+ let path = SubprocessImpl.pathSearch(command, environment);
+ return Promise.resolve(path);
+ },
+};
+
+Object.assign(Subprocess, SubprocessConstants);
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/moz.build
@@ -0,0 +1,30 @@
+# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+EXTRA_JS_MODULES += [
+ 'Subprocess.jsm',
+]
+
+EXTRA_JS_MODULES.subprocess += [
+ 'subprocess_common.jsm',
+ 'subprocess_shared.js',
+ 'subprocess_worker_common.js',
+]
+
+if CONFIG['OS_TARGET'] == 'WINNT':
+ EXTRA_JS_MODULES.subprocess += [
+ 'subprocess_shared_win.js',
+ 'subprocess_win.jsm',
+ 'subprocess_worker_win.js',
+ ]
+else:
+ EXTRA_JS_MODULES.subprocess += [
+ 'subprocess_shared_unix.js',
+ 'subprocess_unix.jsm',
+ 'subprocess_worker_unix.js',
+ ]
+
+XPCSHELL_TESTS_MANIFESTS += ['test/xpcshell/xpcshell.ini']
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/subprocess_common.jsm
@@ -0,0 +1,607 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+/* eslint-disable mozilla/balanced-listeners */
+
+/* exported BaseProcess, PromiseWorker */
+
+var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.importGlobalProperties(["TextDecoder"]);
+
+Services.scriptloader.loadSubScript("resource://gre/modules/subprocess/subprocess_shared.js", this);
+
+var EXPORTED_SYMBOLS = ["BaseProcess", "PromiseWorker", "SubprocessConstants"];
+
+const BUFFER_SIZE = 4096;
+
+let nextResponseId = 0;
+
+/**
+ * Wraps a ChromeWorker so that messages sent to it return a promise which
+ * resolves when the message has been received and the operation it triggers is
+ * complete.
+ */
+class PromiseWorker extends ChromeWorker {
+ constructor(url) {
+ super(url);
+
+ this.listeners = new Map();
+ this.pendingResponses = new Map();
+
+ this.addListener("failure", this.onFailure.bind(this));
+ this.addListener("success", this.onSuccess.bind(this));
+ this.addListener("debug", this.onDebug.bind(this));
+
+ this.addEventListener("message", this.onmessage);
+ }
+
+ /**
+ * Adds a listener for the given message from the worker. Any message received
+ * from the worker with a `data.msg` property matching the given `msg`
+ * parameter are passed to the given listener.
+ *
+ * @param {string} msg
+ * The message to listen for.
+ * @param {function(Event)} listener
+ * The listener to call when matching messages are received.
+ */
+ addListener(msg, listener) {
+ if (!this.listeners.has(msg)) {
+ this.listeners.set(msg, new Set());
+ }
+ this.listeners.get(msg).add(listener);
+ }
+
+ /**
+ * Removes the given message listener.
+ *
+ * @param {string} msg
+ * The message to stop listening for.
+ * @param {function(Event)} listener
+ * The listener to remove.
+ */
+ removeListener(msg, listener) {
+ let listeners = this.listeners.get(msg);
+ if (listeners) {
+ listeners.delete(listener);
+
+ if (!listeners.size) {
+ this.listeners.delete(msg);
+ }
+ }
+ }
+
+ onmessage(event) {
+ let {msg} = event.data;
+ let listeners = this.listeners.get(msg) || new Set();
+
+ for (let listener of listeners) {
+ try {
+ listener(event.data);
+ } catch (e) {
+ Cu.reportError(e);
+ }
+ }
+ }
+
+ /**
+ * Called when a message sent to the worker has failed, and rejects its
+ * corresponding promise.
+ *
+ * @private
+ */
+ onFailure({msgId, error}) {
+ this.pendingResponses.get(msgId).reject(error);
+ this.pendingResponses.delete(msgId);
+ }
+
+ /**
+ * Called when a message sent to the worker has succeeded, and resolves its
+ * corresponding promise.
+ *
+ * @private
+ */
+ onSuccess({msgId, data}) {
+ this.pendingResponses.get(msgId).resolve(data);
+ this.pendingResponses.delete(msgId);
+ }
+
+ onDebug({message}) {
+ dump(`Worker debug: ${message}\n`);
+ }
+
+ /**
+ * Calls the given method in the worker, and returns a promise which resolves
+ * or rejects when the method has completed.
+ *
+ * @param {string} method
+ * The name of the method to call.
+ * @param {Array} args
+ * The arguments to pass to the method.
+ * @param {Array} [transferList]
+ * A list of objects to transfer to the worker, rather than cloning.
+ * @returns {Promise}
+ */
+ call(method, args, transferList = []) {
+ let msgId = nextResponseId++;
+
+ return new Promise((resolve, reject) => {
+ this.pendingResponses.set(msgId, {resolve, reject});
+
+ let message = {
+ msg: method,
+ msgId,
+ args,
+ };
+
+ this.postMessage(message, transferList);
+ });
+ }
+}
+
+/**
+ * Represents an input or output pipe connected to a subprocess.
+ *
+ * @property {integer} fd
+ * The file descriptor number of the pipe on the child process's side.
+ * @readonly
+ */
+class Pipe {
+ /**
+ * @param {Process} process
+ * The child process that this pipe is connected to.
+ * @param {integer} fd
+ * The file descriptor number of the pipe on the child process's side.
+ * @param {integer} id
+ * The internal ID of the pipe, which ties it to the corresponding Pipe
+ * object on the Worker side.
+ */
+ constructor(process, fd, id) {
+ this.id = id;
+ this.fd = fd;
+ this.processId = process.id;
+ this.worker = process.worker;
+
+ /**
+ * @property {boolean} closed
+ * True if the file descriptor has been closed, and can no longer
+ * be read from or written to. Pending IO operations may still
+ * complete, but new operations may not be initiated.
+ * @readonly
+ */
+ this.closed = false;
+ }
+
+ /**
+ * Closes the end of the pipe which belongs to this process.
+ *
+ * @param {boolean} force
+ * If true, the pipe is closed immediately, regardless of any pending
+ * IO operations. If false, the pipe is closed after any existing
+ * pending IO operations have completed.
+ * @returns {Promise<object>}
+ * Resolves to an object with no properties once the pipe has been
+ * closed.
+ */
+ close(force = false) {
+ this.closed = true;
+ return this.worker.call("close", [this.id, force]);
+ }
+}
+
+/**
+ * Represents an output-only pipe, to which data may be written.
+ */
+class OutputPipe extends Pipe {
+ constructor(...args) {
+ super(...args);
+
+ this.encoder = new TextEncoder();
+ }
+
+ /**
+ * Writes the given data to the stream.
+ *
+ * When given an array buffer or typed array, ownership of the buffer is
+ * transferred to the IO worker, and it may no longer be used from this
+ * thread.
+ *
+ * @param {ArrayBuffer|TypedArray|string} buffer
+ * Data to write to the stream.
+ * @returns {Promise<object>}
+ * Resolves to an object with a `bytesWritten` property, containing
+ * the number of bytes successfully written, once the operation has
+ * completed.
+ *
+ * @rejects {object}
+ * May be rejected with an Error object, or an object with similar
+ * properties. The object will include an `errorCode` property with
+ * one of the following values if it was rejected for the
+ * corresponding reason:
+ *
+ * - Subprocess.ERROR_END_OF_FILE: The pipe was closed before
+ * all of the data in `buffer` could be written to it.
+ */
+ write(buffer) {
+ if (typeof buffer === "string") {
+ buffer = this.encoder.encode(buffer);
+ }
+
+ if (Cu.getClassName(buffer, true) !== "ArrayBuffer") {
+ if (buffer.byteLength === buffer.buffer.byteLength) {
+ buffer = buffer.buffer;
+ } else {
+ buffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+ }
+ }
+
+ let args = [this.id, buffer];
+
+ return this.worker.call("write", args, [buffer]);
+ }
+}
+
+/**
+ * Represents an input-only pipe, from which data may be read.
+ */
+class InputPipe extends Pipe {
+ constructor(...args) {
+ super(...args);
+
+ this.buffers = [];
+ this.dataAvailable = 0;
+
+ this.decoder = new TextDecoder();
+
+ this.pendingReads = [];
+
+ this._pendingBufferRead = null;
+
+ this.fillBuffer();
+ }
+
+ /**
+ * @property {integer} bufferSize
+ * The current size of the input buffer. This varies depending on
+ * the size of pending read operations.
+ * @readonly
+ */
+ get bufferSize() {
+ if (this.pendingReads.length) {
+ return Math.max(this.pendingReads[0].length, BUFFER_SIZE);
+ }
+ return BUFFER_SIZE;
+ }
+
+ /**
+ * Attempts to fill the input buffer.
+ *
+ * @private
+ */
+ fillBuffer() {
+ let dataWanted = this.bufferSize - this.dataAvailable;
+
+ if (!this._pendingBufferRead && dataWanted > 0) {
+ this._pendingBufferRead = this._read(dataWanted);
+
+ this._pendingBufferRead.then((result) => {
+ this._pendingBufferRead = null;
+
+ if (result) {
+ this.onInput(result.buffer);
+
+ this.fillBuffer();
+ }
+ });
+ }
+ }
+
+ _read(size) {
+ let args = [this.id, size];
+
+ return this.worker.call("read", args).catch(e => {
+ this.closed = true;
+
+ for (let {reject} of this.pendingReads.splice(0)) {
+ reject(e);
+ }
+ });
+ }
+
+ /**
+ * Adds the given data to the end of the input buffer.
+ *
+ * @private
+ */
+ onInput(buffer) {
+ this.buffers.push(buffer);
+ this.dataAvailable += buffer.byteLength;
+ this.checkPendingReads();
+ }
+
+ /**
+ * Checks the topmost pending read operations and fulfills as many as can be
+ * filled from the current input buffer.
+ *
+ * @private
+ */
+ checkPendingReads() {
+ this.fillBuffer();
+
+ let reads = this.pendingReads;
+ while (reads.length && reads[0].length <= this.dataAvailable) {
+ let pending = this.pendingReads.shift();
+
+ let result;
+ let byteLength = this.buffers[0].byteLength;
+ if (byteLength == pending.length) {
+ result = this.buffers.shift();
+ } else if (byteLength > pending.length) {
+ let buffer = this.buffers[0];
+
+ this.buffers[0] = buffer.slice(pending.length);
+ result = ArrayBuffer.transfer(buffer, pending.length);
+ } else {
+ result = ArrayBuffer.transfer(this.buffers.shift(), pending.length);
+ let u8result = new Uint8Array(result);
+
+ while (byteLength < pending.length) {
+ let buffer = this.buffers[0];
+ let u8buffer = new Uint8Array(buffer);
+
+ let remaining = pending.length - byteLength;
+
+ if (buffer.byteLength <= remaining) {
+ this.buffers.shift();
+
+ u8result.set(u8buffer, byteLength);
+ } else {
+ this.buffers[0] = buffer.slice(remaining);
+
+ u8result.set(u8buffer.subarray(0, remaining), byteLength);
+ }
+
+ byteLength += Math.min(buffer.byteLength, remaining);
+ }
+ }
+
+ this.dataAvailable -= result.byteLength;
+ pending.resolve(result);
+ }
+ }
+
+ /**
+ * Reads exactly `length` bytes of binary data from the input stream. The read
+ * operation will not complete until enough data is available to fulfill the
+ * request.
+ *
+ * @param {integer} length
+ * The number of bytes to read.
+ * @returns {Promise<ArrayBuffer>}
+ *
+ * @rejects {object}
+ * May be rejected with an Error object, or an object with similar
+ * properties. The object will include an `errorCode` property with
+ * one of the following values if it was rejected for the
+ * corresponding reason:
+ *
+ * - Subprocess.ERROR_END_OF_FILE: The pipe was closed before
+ * enough input could be read to satisfy the request.
+ */
+ read(length) {
+ if (length == 0) {
+ return Promise.resolve(new ArrayBuffer(0));
+ }
+
+ return new Promise((resolve, reject) => {
+ this.pendingReads.push({length, resolve, reject});
+ this.checkPendingReads();
+ });
+ }
+
+ /**
+ * Reads exactly `length` bytes from the input stream, and parses them as
+ * UTF-8 JSON data.
+ *
+ * @param {integer} length
+ * The number of bytes to read.
+ * @returns {Promise<object>}
+ *
+ * @rejects {object}
+ * May be rejected with an Error object, or an object with similar
+ * properties. The object will include an `errorCode` property with
+ * one of the following values if it was rejected for the
+ * corresponding reason:
+ *
+ * - Subprocess.ERROR_END_OF_FILE: The pipe was closed before
+ * enough input could be read to satisfy the request.
+ * - Subprocess.ERROR_INVALID_JSON: The data read from the pipe
+ * could not be parsed as a valid JSON string.
+ */
+ readJSON(length) {
+ return this.readString(length).then(string => {
+ try {
+ return JSON.parse(string);
+ } catch (e) {
+ e.errorCode = SubprocessConstants.ERROR_INVALID_JSON;
+ throw e;
+ }
+ });
+ }
+
+ /**
+ * Reads exactly `length` bytes of UTF-8 data from the input stream, and
+ * converts them to a JavaScript string.
+ *
+ * @param {integer} length
+ * The number of bytes to read.
+ * @param {object} [options]
+ * An options object as expected by TextDecoder.decode.
+ * @returns {Promise<string>}
+ *
+ * @rejects {object}
+ * May be rejected with an Error object, or an object with similar
+ * properties. The object will include an `errorCode` property with
+ * one of the following values if it was rejected for the
+ * corresponding reason:
+ *
+ * - Subprocess.ERROR_END_OF_FILE: The pipe was closed before
+ * enough input could be read to satisfy the request.
+ */
+ readString(length, options = null) {
+ return this.read(length).then(buffer => {
+ return this.decoder.decode(buffer, options);
+ });
+ }
+
+ /**
+ * Reads 4 bytes from the input stream, and parses them as an unsigned
+ * integer, in native byte order.
+ *
+ * @returns {Promise<integer>}
+ *
+ * @rejects {object}
+ * May be rejected with an Error object, or an object with similar
+ * properties. The object will include an `errorCode` property with
+ * one of the following values if it was rejected for the
+ * corresponding reason:
+ *
+ * - Subprocess.ERROR_END_OF_FILE: The pipe was closed before
+ * enough input could be read to satisfy the request.
+ */
+ readUint32() {
+ return this.read(4).then(buffer => {
+ return new Uint32Array(buffer)[0];
+ });
+ }
+}
+
+/**
+ * Represents a currently-running process, and allows interaction with it.
+ *
+ * @property {integer} pid
+ * The process ID of the process, assigned by the operating system.
+ * @readonly
+ */
+class BaseProcess {
+ /**
+ * @param {PromiseWorker} worker
+ * The worker instance which owns the process.
+ * @param {integer} processId
+ * The internal ID of the Process object, which ties it to the
+ * corresponding process on the Worker side.
+ * @param {integer[]} fds
+ * An array of internal Pipe IDs, one for each standard file descriptor
+ * in the child process.
+ * @param {integer} pid
+ * The operating system process ID of the process.
+ */
+ constructor(worker, processId, fds, pid) {
+ this.id = processId;
+ this.worker = worker;
+ this.pid = pid;
+
+ this.exitCode = null;
+
+ this.exitPromise = new Promise(resolve => {
+ this.worker.call("wait", [this.id]).then(({exitCode}) => {
+ resolve(Object.freeze({exitCode}));
+ this.exitCode = exitCode;
+ });
+ });
+
+ if (fds[0] !== undefined) {
+ /**
+ * @property {OutputPipe} stdin
+ * A Pipe object which allows writing to the process's standard
+ * input.
+ * @readonly
+ */
+ this.stdin = new OutputPipe(this, 0, fds[0]);
+ }
+ if (fds[1] !== undefined) {
+ /**
+ * @property {InputPipe} stdout
+ * A Pipe object which allows reading from the process's standard
+ * output.
+ * @readonly
+ */
+ this.stdout = new InputPipe(this, 1, fds[1]);
+ }
+ if (fds[2] !== undefined) {
+ /**
+ * @property {InputPipe} [stderr]
+ * An optional Pipe object which allows reading from the
+ * process's standard error output.
+ * @readonly
+ */
+ this.stderr = new InputPipe(this, 2, fds[2]);
+ }
+ }
+
+ /**
+ * Spawns a process, and resolves to a BaseProcess instance on success.
+ *
+ * @param {object} options
+ * An options object as passed to `Subprocess.call`.
+ *
+ * @returns {Promise<BaseProcess>}
+ */
+ static create(options) {
+ let worker = this.getWorker();
+
+ return worker.call("spawn", [options]).then(({processId, fds, pid}) => {
+ return new this(worker, processId, fds, pid);
+ });
+ }
+
+ static get WORKER_URL() {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Gets the current subprocess worker, or spawns a new one if it does not
+ * currently exist.
+ *
+ * @returns {PromiseWorker}
+ */
+ static getWorker() {
+ if (!this._worker) {
+ this._worker = new PromiseWorker(this.WORKER_URL);
+ }
+ return this._worker;
+ }
+
+ /**
+ * Kills the process.
+ *
+ * @param {boolean} [force=false]
+ * If true, forcibly terminates the process. Otherwise, attempts to
+ * kill the process in a way that it can override, if it chooses.
+ *
+ * @returns {Promise<object>}
+ * Resolves to an object with no properties when the process has been
+ * killed.
+ */
+ kill(force = false) {
+ return this.worker.call("kill", [this.id, force]);
+ }
+
+ /**
+ * Returns a promise which resolves to the process's exit code, once it has
+ * exited.
+ *
+ * @returns {Promise<object>}
+ * Resolves to an object with an `exitCode` property, containing the
+ * process's exit code, once the process has exited.
+ */
+ wait() {
+ return this.exitPromise;
+ }
+}
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/subprocess_shared.js
@@ -0,0 +1,93 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+/* exported Library, SubprocessConstants */
+
+if (!ArrayBuffer.transfer) {
+ /**
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/transfer
+ */
+ ArrayBuffer.transfer = function(buffer, size = buffer.byteLength) {
+ let u8out = new Uint8Array(size);
+ let u8buffer = new Uint8Array(buffer, 0, Math.min(size, buffer.byteLength));
+
+ u8out.set(u8buffer);
+
+ return u8out.buffer;
+ };
+}
+
+var libraries = {};
+
+class Library {
+ constructor(name, names, definitions) {
+ if (name in libraries) {
+ return libraries[name];
+ }
+
+ for (let name of names) {
+ try {
+ if (!this.library) {
+ this.library = ctypes.open(name);
+ }
+ } catch (e) {
+ // Ignore errors until we've tried all the options.
+ }
+ }
+ if (!this.library) {
+ throw new Error("Could not load libc");
+ }
+
+ libraries[name] = this;
+
+ for (let symbol of Object.keys(definitions)) {
+ this.declare(symbol, ...definitions[symbol]);
+ }
+ }
+
+ declare(name, ...args) {
+ Object.defineProperty(this, name, {
+ configurable: true,
+ get() {
+ Object.defineProperty(this, name, {
+ configurable: true,
+ value: this.library.declare(name, ...args),
+ });
+
+ return this[name];
+ },
+ });
+ }
+}
+
+/**
+ * Holds constants which apply to various Subprocess operations.
+ * @namespace
+ */
+const SubprocessConstants = {
+ /**
+ * @property {integer} ERROR_END_OF_FILE
+ * The operation failed because the end of the file was reached.
+ * @constant
+ */
+ ERROR_END_OF_FILE: 0xff7a0001,
+ /**
+ * @property {integer} ERROR_INVALID_JSON
+ * The operation failed because an invalid JSON was encountered.
+ * @constant
+ */
+ ERROR_INVALID_JSON: 0xff7a0002,
+ /**
+ * @property {integer} ERROR_BAD_EXECUTABLE
+ * The operation failed because the given file did not exist, or
+ * could not be executed.
+ * @constant
+ */
+ ERROR_BAD_EXECUTABLE: 0xff7a0003,
+};
+
+Object.freeze(SubprocessConstants);
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/subprocess_shared_unix.js
@@ -0,0 +1,157 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+/* exported libc */
+
+const LIBC = OS.Constants.libc;
+
+const LIBC_CHOICES = ["libc.so", "libSystem.B.dylib", "a.out"];
+
+const unix = {
+ pid_t: ctypes.int32_t,
+
+ pollfd: new ctypes.StructType("pollfd", [
+ {"fd": ctypes.int},
+ {"events": ctypes.short},
+ {"revents": ctypes.short},
+ ]),
+
+ posix_spawn_file_actions_t: ctypes.uint8_t.array(
+ LIBC.OSFILE_SIZEOF_POSIX_SPAWN_FILE_ACTIONS_T),
+
+ WEXITSTATUS(status) {
+ return (status >> 8) & 0xff;
+ },
+
+ WTERMSIG(status) {
+ return status & 0x7f;
+ },
+};
+
+var libc = new Library("libc", LIBC_CHOICES, {
+ environ: [ctypes.char.ptr.ptr],
+
+ // Darwin-only.
+ _NSGetEnviron: [
+ ctypes.default_abi,
+ ctypes.char.ptr.ptr.ptr,
+ ],
+
+ chdir: [
+ ctypes.default_abi,
+ ctypes.int,
+ ctypes.char.ptr, /* path */
+ ],
+
+ close: [
+ ctypes.default_abi,
+ ctypes.int,
+ ctypes.int, /* fildes */
+ ],
+
+ fcntl: [
+ ctypes.default_abi,
+ ctypes.int,
+ ctypes.int, /* fildes */
+ ctypes.int, /* cmd */
+ ctypes.int, /* ... */
+ ],
+
+ getcwd: [
+ ctypes.default_abi,
+ ctypes.char.ptr,
+ ctypes.char.ptr, /* buf */
+ ctypes.size_t, /* size */
+ ],
+
+ kill: [
+ ctypes.default_abi,
+ ctypes.int,
+ unix.pid_t, /* pid */
+ ctypes.int, /* signal */
+ ],
+
+ pipe: [
+ ctypes.default_abi,
+ ctypes.int,
+ ctypes.int.array(2), /* pipefd */
+ ],
+
+ poll: [
+ ctypes.default_abi,
+ ctypes.int,
+ unix.pollfd.array(), /* fds */
+ ctypes.unsigned_int, /* nfds */
+ ctypes.int, /* timeout */
+ ],
+
+ posix_spawn: [
+ ctypes.default_abi,
+ ctypes.int,
+ unix.pid_t.ptr, /* pid */
+ ctypes.char.ptr, /* path */
+ unix.posix_spawn_file_actions_t.ptr, /* file_actions */
+ ctypes.voidptr_t, /* attrp */
+ ctypes.char.ptr.ptr, /* argv */
+ ctypes.char.ptr.ptr, /* envp */
+ ],
+
+ posix_spawn_file_actions_addclose: [
+ ctypes.default_abi,
+ ctypes.int,
+ unix.posix_spawn_file_actions_t.ptr, /* file_actions */
+ ctypes.int, /* fildes */
+ ],
+
+ posix_spawn_file_actions_adddup2: [
+ ctypes.default_abi,
+ ctypes.int,
+ unix.posix_spawn_file_actions_t.ptr, /* file_actions */
+ ctypes.int, /* fildes */
+ ctypes.int, /* newfildes */
+ ],
+
+ posix_spawn_file_actions_destroy: [
+ ctypes.default_abi,
+ ctypes.int,
+ unix.posix_spawn_file_actions_t.ptr, /* file_actions */
+ ],
+
+ posix_spawn_file_actions_init: [
+ ctypes.default_abi,
+ ctypes.int,
+ unix.posix_spawn_file_actions_t.ptr, /* file_actions */
+ ],
+
+ read: [
+ ctypes.default_abi,
+ ctypes.int,
+ ctypes.int, /* fildes */
+ ctypes.char.ptr, /* buf */
+ ctypes.size_t, /* nbyte */
+ ],
+
+ waitpid: [
+ ctypes.default_abi,
+ unix.pid_t,
+ unix.pid_t, /* pid */
+ ctypes.int.ptr, /* status */
+ ctypes.int, /* options */
+ ],
+
+ write: [
+ ctypes.default_abi,
+ ctypes.size_t,
+ ctypes.int, /* fildes */
+ ctypes.char.ptr, /* buf */
+ ctypes.size_t, /* nbyte */
+ ],
+});
+
+unix.Fd = function(fd) {
+ return ctypes.CDataFinalizer(ctypes.int(fd), libc.close);
+};
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/subprocess_shared_win.js
@@ -0,0 +1,346 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+/* exported LIBC, Win, createPipe, libc */
+
+const LIBC = OS.Constants.libc;
+
+const Win = OS.Constants.Win;
+
+const LIBC_CHOICES = ["kernel32.dll"];
+
+const win32 = {
+ // On Windows 64, winapi_abi is an alias for default_abi.
+ WINAPI: ctypes.winapi_abi,
+
+ BYTE: ctypes.uint8_t,
+ WORD: ctypes.uint16_t,
+ DWORD: ctypes.uint32_t,
+
+ UINT: ctypes.unsigned_int,
+ UCHAR: ctypes.unsigned_char,
+
+ BOOL: ctypes.bool,
+
+ HANDLE: ctypes.voidptr_t,
+ PVOID: ctypes.voidptr_t,
+ LPVOID: ctypes.voidptr_t,
+
+ CHAR: ctypes.char,
+ WCHAR: ctypes.jschar,
+
+ ULONG_PTR: ctypes.uintptr_t,
+};
+
+Object.assign(win32, {
+ LPSTR: win32.CHAR.ptr,
+ LPWSTR: win32.WCHAR.ptr,
+
+ LPBYTE: win32.BYTE.ptr,
+ LPDWORD: win32.DWORD.ptr,
+ LPHANDLE: win32.HANDLE.ptr,
+});
+
+Object.assign(win32, {
+ LPCSTR: win32.LPSTR,
+ LPCWSTR: win32.LPWSTR,
+ LPCVOID: win32.LPVOID,
+});
+
+Object.assign(win32, {
+ CREATE_NEW_CONSOLE: 0x00000010,
+ CREATE_UNICODE_ENVIRONMENT: 0x00000400,
+ CREATE_NO_WINDOW: 0x08000000,
+
+ STARTF_USESTDHANDLES: 0x0100,
+
+ DUPLICATE_CLOSE_SOURCE: 0x01,
+ DUPLICATE_SAME_ACCESS: 0x02,
+
+ ERROR_HANDLE_EOF: 38,
+ ERROR_BROKEN_PIPE: 109,
+
+ FILE_FLAG_OVERLAPPED: 0x40000000,
+
+ PIPE_TYPE_BYTE: 0x00,
+
+ PIPE_ACCESS_INBOUND: 0x01,
+ PIPE_ACCESS_OUTBOUND: 0x02,
+ PIPE_ACCESS_DUPLEX: 0x03,
+
+ PIPE_WAIT: 0x00,
+ PIPE_NOWAIT: 0x01,
+
+ STILL_ACTIVE: 259,
+
+ // These constants are 32-bit unsigned integers, but Windows defines
+ // them as negative integers cast to an unsigned type.
+ STD_INPUT_HANDLE: -10 + 0x100000000,
+ STD_OUTPUT_HANDLE: -11 + 0x100000000,
+ STD_ERROR_HANDLE: -12 + 0x100000000,
+
+ WAIT_TIMEOUT: 0x00000102,
+ WAIT_FAILED: 0xffffffff,
+});
+
+Object.assign(win32, {
+ OVERLAPPED: new ctypes.StructType("OVERLAPPED", [
+ {"Internal": win32.ULONG_PTR},
+ {"InternalHigh": win32.ULONG_PTR},
+ {"Offset": win32.DWORD},
+ {"OffsetHigh": win32.DWORD},
+ {"hEvent": win32.HANDLE},
+ ]),
+
+ PROCESS_INFORMATION: new ctypes.StructType("PROCESS_INFORMATION", [
+ {"hProcess": win32.HANDLE},
+ {"hThread": win32.HANDLE},
+ {"dwProcessId": win32.DWORD},
+ {"dwThreadId": win32.DWORD},
+ ]),
+
+ SECURITY_ATTRIBUTES: new ctypes.StructType("SECURITY_ATTRIBUTES", [
+ {"nLength": win32.DWORD},
+ {"lpSecurityDescriptor": win32.LPVOID},
+ {"bInheritHandle": win32.BOOL},
+ ]),
+
+ STARTUPINFOW: new ctypes.StructType("STARTUPINFOW", [
+ {"cb": win32.DWORD},
+ {"lpReserved": win32.LPWSTR},
+ {"lpDesktop": win32.LPWSTR},
+ {"lpTitle": win32.LPWSTR},
+ {"dwX": win32.DWORD},
+ {"dwY": win32.DWORD},
+ {"dwXSize": win32.DWORD},
+ {"dwYSize": win32.DWORD},
+ {"dwXCountChars": win32.DWORD},
+ {"dwYCountChars": win32.DWORD},
+ {"dwFillAttribute": win32.DWORD},
+ {"dwFlags": win32.DWORD},
+ {"wShowWindow": win32.WORD},
+ {"cbReserved2": win32.WORD},
+ {"lpReserved2": win32.LPBYTE},
+ {"hStdInput": win32.HANDLE},
+ {"hStdOutput": win32.HANDLE},
+ {"hStdError": win32.HANDLE},
+ ]),
+});
+
+var libc = new Library("libc", LIBC_CHOICES, {
+ CloseHandle: [
+ win32.WINAPI,
+ win32.BOOL,
+ win32.HANDLE, /* hObject */
+ ],
+
+ CreateEventW: [
+ win32.WINAPI,
+ win32.HANDLE,
+ win32.SECURITY_ATTRIBUTES.ptr, /* opt lpEventAttributes */
+ win32.BOOL, /* bManualReset */
+ win32.BOOL, /* bInitialState */
+ win32.LPWSTR, /* lpName */
+ ],
+
+ CreateFileW: [
+ win32.WINAPI,
+ win32.HANDLE,
+ win32.LPWSTR, /* lpFileName */
+ win32.DWORD, /* dwDesiredAccess */
+ win32.DWORD, /* dwShareMode */
+ win32.SECURITY_ATTRIBUTES.ptr, /* opt lpSecurityAttributes */
+ win32.DWORD, /* dwCreationDisposition */
+ win32.DWORD, /* dwFlagsAndAttributes */
+ win32.HANDLE, /* opt hTemplateFile */
+ ],
+
+ CreateNamedPipeW: [
+ win32.WINAPI,
+ win32.HANDLE,
+ win32.LPWSTR, /* lpName */
+ win32.DWORD, /* dwOpenMode */
+ win32.DWORD, /* dwPipeMode */
+ win32.DWORD, /* nMaxInstances */
+ win32.DWORD, /* nOutBufferSize */
+ win32.DWORD, /* nInBufferSize */
+ win32.DWORD, /* nDefaultTimeOut */
+ win32.SECURITY_ATTRIBUTES.ptr, /* opt lpSecurityAttributes */
+ ],
+
+ CreatePipe: [
+ win32.WINAPI,
+ win32.BOOL,
+ win32.LPHANDLE, /* out hReadPipe */
+ win32.LPHANDLE, /* out hWritePipe */
+ win32.SECURITY_ATTRIBUTES.ptr, /* opt lpPipeAttributes */
+ win32.DWORD, /* nSize */
+ ],
+
+ CreateProcessW: [
+ win32.WINAPI,
+ win32.BOOL,
+ win32.LPCWSTR, /* lpApplicationName */
+ win32.LPWSTR, /* lpCommandLine */
+ win32.SECURITY_ATTRIBUTES.ptr, /* lpProcessAttributes */
+ win32.SECURITY_ATTRIBUTES.ptr, /* lpThreadAttributes */
+ win32.BOOL, /* bInheritHandle */
+ win32.DWORD, /* dwCreationFlags */
+ win32.LPVOID, /* opt lpEnvironment */
+ win32.LPCWSTR, /* opt lpCurrentDirectory */
+ win32.STARTUPINFOW.ptr, /* lpStartupInfo */
+ win32.PROCESS_INFORMATION.ptr, /* out lpProcessInformation */
+ ],
+
+ DuplicateHandle: [
+ win32.WINAPI,
+ win32.BOOL,
+ win32.HANDLE, /* hSourceProcessHandle */
+ win32.HANDLE, /* hSourceHandle */
+ win32.HANDLE, /* hTargetProcessHandle */
+ win32.LPHANDLE, /* out lpTargetHandle */
+ win32.DWORD, /* dwDesiredAccess */
+ win32.BOOL, /* bInheritHandle */
+ win32.DWORD, /* dwOptions */
+ ],
+
+ FreeEnvironmentStringsW: [
+ win32.WINAPI,
+ win32.BOOL,
+ win32.LPCWSTR, /* lpszEnvironmentBlock */
+ ],
+
+ GetCurrentProcess: [
+ win32.WINAPI,
+ win32.HANDLE,
+ ],
+
+ GetCurrentProcessId: [
+ win32.WINAPI,
+ win32.DWORD,
+ ],
+
+ GetEnvironmentStringsW: [
+ win32.WINAPI,
+ win32.LPCWSTR,
+ ],
+
+ GetExitCodeProcess: [
+ win32.WINAPI,
+ win32.BOOL,
+ win32.HANDLE, /* hProcess */
+ win32.LPDWORD, /* lpExitCode */
+ ],
+
+ GetLastError: [
+ win32.WINAPI,
+ win32.DWORD,
+ ],
+
+ GetOverlappedResult: [
+ win32.WINAPI,
+ win32.BOOL,
+ win32.HANDLE, /* hFile */
+ win32.OVERLAPPED.ptr, /* lpOverlapped */
+ win32.LPDWORD, /* lpNumberOfBytesTransferred */
+ win32.BOOL, /* bWait */
+ ],
+
+ GetStdHandle: [
+ win32.WINAPI,
+ win32.HANDLE,
+ win32.DWORD, /* nStdHandle */
+ ],
+
+ ReadFile: [
+ win32.WINAPI,
+ win32.BOOL,
+ win32.HANDLE, /* hFile */
+ win32.LPVOID, /* out lpBuffer */
+ win32.DWORD, /* nNumberOfBytesToRead */
+ win32.LPDWORD, /* opt out lpNumberOfBytesRead */
+ win32.OVERLAPPED.ptr, /* opt in/out lpOverlapped */
+ ],
+
+ TerminateProcess: [
+ win32.WINAPI,
+ win32.BOOL,
+ win32.HANDLE, /* hProcess */
+ win32.UINT, /* uExitCode */
+ ],
+
+ WaitForMultipleObjects: [
+ win32.WINAPI,
+ win32.DWORD,
+ win32.DWORD, /* nCount */
+ win32.HANDLE.ptr, /* hHandles */
+ win32.BOOL, /* bWaitAll */
+ win32.DWORD, /* dwMilliseconds */
+ ],
+
+ WaitForSingleObject: [
+ win32.WINAPI,
+ win32.DWORD,
+ win32.HANDLE, /* hHandle */
+ win32.BOOL, /* bWaitAll */
+ win32.DWORD, /* dwMilliseconds */
+ ],
+
+ WriteFile: [
+ win32.WINAPI,
+ win32.BOOL,
+ win32.HANDLE, /* hFile */
+ win32.LPCVOID, /* lpBuffer */
+ win32.DWORD, /* nNumberOfBytesToRead */
+ win32.LPDWORD, /* opt out lpNumberOfBytesWritten */
+ win32.OVERLAPPED.ptr, /* opt in/out lpOverlapped */
+ ],
+});
+
+
+let nextNamedPipeId = 0;
+
+win32.Handle = function(handle) {
+ return ctypes.CDataFinalizer(win32.HANDLE(handle), libc.CloseHandle);
+};
+
+win32.createPipe = function(secAttr, readFlags = 0, writeFlags = 0, size = 0) {
+ readFlags |= win32.PIPE_ACCESS_INBOUND;
+ writeFlags |= Win.FILE_ATTRIBUTE_NORMAL;
+
+ if (size == 0) {
+ size = 4096;
+ }
+
+ let pid = libc.GetCurrentProcessId();
+ let pipeName = String.raw`\\.\Pipe\SubProcessPipe.${pid}.${nextNamedPipeId++}`;
+
+ let readHandle = libc.CreateNamedPipeW(
+ pipeName, readFlags,
+ win32.PIPE_TYPE_BYTE | win32.PIPE_WAIT,
+ 1, /* number of connections */
+ size, /* output buffer size */
+ size, /* input buffer size */
+ 0, /* timeout */
+ secAttr.address());
+
+ if (readHandle == Win.INVALID_HANDLE_VALUE) {
+ return [];
+ }
+
+ let writeHandle = libc.CreateFileW(
+ pipeName, Win.GENERIC_WRITE, 0, secAttr.address(),
+ Win.OPEN_EXISTING, writeFlags, 0);
+
+ if (writeHandle == Win.INVALID_HANDLE_VALUE) {
+ libc.CloseHandle(readHandle);
+ return [];
+ }
+
+ return [win32.Handle(readHandle),
+ win32.Handle(writeHandle)];
+};
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/subprocess_unix.jsm
@@ -0,0 +1,114 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+/* eslint-disable mozilla/balanced-listeners */
+
+/* exported SubprocessImpl */
+
+/* globals BaseProcess */
+
+var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+var EXPORTED_SYMBOLS = ["SubprocessImpl"];
+
+Cu.import("resource://gre/modules/ctypes.jsm");
+Cu.import("resource://gre/modules/osfile.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/subprocess/subprocess_common.jsm");
+
+Services.scriptloader.loadSubScript("resource://gre/modules/subprocess/subprocess_shared.js", this);
+Services.scriptloader.loadSubScript("resource://gre/modules/subprocess/subprocess_shared_unix.js", this);
+
+class Process extends BaseProcess {
+ static get WORKER_URL() {
+ return "resource://gre/modules/subprocess/subprocess_worker_unix.js";
+ }
+}
+
+function* isExecutable(path) {
+ try {
+ let info = yield OS.File.stat(path);
+
+ // FIXME: We really want access(path, X_OK) here, but OS.File does not
+ // support it.
+ return !info.isDir && (info.unixMode & 0o111);
+ } catch (e) {
+ return false;
+ }
+}
+
+var SubprocessUnix = {
+ call(options) {
+ return Process.create(options);
+ },
+
+ * getEnvironment() {
+ let environ;
+ if (OS.Constants.Sys.Name == "Darwin") {
+ environ = libc._NSGetEnviron().contents;
+ } else {
+ environ = libc.environ;
+ }
+
+ for (let envp = environ; !envp.contents.isNull(); envp = envp.increment()) {
+ let str = envp.contents.readString();
+
+ let idx = str.indexOf("=");
+ if (idx >= 0) {
+ yield [str.slice(0, idx),
+ str.slice(idx + 1)];
+ }
+ }
+ },
+
+ /**
+ * Searches for the given executable file in the system executable
+ * file paths as specified by the PATH environment variable.
+ *
+ * On Windows, if the unadorned filename cannot be found, the
+ * extensions in the semicolon-separated list in the PATHEXT
+ * environment variable are successively appended to the original
+ * name and searched for in turn.
+ *
+ * @param {string} bin
+ * The name of the executable to find.
+ * @param {object} environment
+ * An object containing a key for each environment variable to be used
+ * in the search.
+ * @returns {Promise<string>}
+ */
+ pathSearch: Task.async(function* (bin, environment) {
+ let split = OS.Path.split(bin);
+ if (split.absolute) {
+ if (yield isExecutable(bin)) {
+ return bin;
+ }
+ let error = new Error(`File at path "${bin}" does not exist, or is not executable`);
+ error.errorCode = SubprocessConstants.ERROR_BAD_EXECUTABLE;
+ throw error;
+ }
+
+ let dirs = [];
+ if (environment.PATH) {
+ dirs = environment.PATH.split(":");
+ }
+
+ for (let dir of dirs) {
+ let path = OS.Path.join(dir, bin);
+
+ if (yield isExecutable(path)) {
+ return path;
+ }
+ }
+ let error = new Error(`Executable not found: ${bin}`);
+ error.errorCode = SubprocessConstants.ERROR_BAD_EXECUTABLE;
+ throw error;
+ }),
+};
+
+var SubprocessImpl = SubprocessUnix;
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/subprocess_win.jsm
@@ -0,0 +1,132 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+/* eslint-disable mozilla/balanced-listeners */
+
+/* exported SubprocessImpl */
+
+/* globals BaseProcess */
+
+var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+var EXPORTED_SYMBOLS = ["SubprocessImpl"];
+
+Cu.import("resource://gre/modules/ctypes.jsm");
+Cu.import("resource://gre/modules/osfile.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/subprocess/subprocess_common.jsm");
+
+Services.scriptloader.loadSubScript("resource://gre/modules/subprocess/subprocess_shared.js", this);
+Services.scriptloader.loadSubScript("resource://gre/modules/subprocess/subprocess_shared_win.js", this);
+
+class Process extends BaseProcess {
+ static get WORKER_URL() {
+ return "resource://gre/modules/subprocess/subprocess_worker_win.js";
+ }
+}
+
+function* fileExists(path) {
+ try {
+ let info = yield OS.File.stat(path);
+ return !(info.isDir || info.isSymlink);
+ } catch (e) {
+ return false;
+ }
+}
+
+var SubprocessWin = {
+ call(options) {
+ return Process.create(options);
+ },
+
+
+ * getEnvironment() {
+ let env = libc.GetEnvironmentStringsW();
+ try {
+ for (let p = env, q = env; ; p = p.increment()) {
+ if (p.contents == "\0") {
+ if (String(p) == String(q)) {
+ break;
+ }
+
+ let str = q.readString();
+ q = p.increment();
+
+ let idx = str.indexOf("=");
+ if (idx == 0) {
+ idx = str.indexOf("=", 1);
+ }
+
+ if (idx >= 0) {
+ yield [str.slice(0, idx), str.slice(idx + 1)];
+ }
+ }
+ }
+ } finally {
+ libc.FreeEnvironmentStringsW(env);
+ }
+ },
+
+ /**
+ * Searches for the given executable file in the system executable
+ * file paths as specified by the PATH environment variable.
+ *
+ * On Windows, if the unadorned filename cannot be found, the
+ * extensions in the semicolon-separated list in the PATHEXT
+ * environment variable are successively appended to the original
+ * name and searched for in turn.
+ *
+ * @param {string} bin
+ * The name of the executable to find.
+ * @param {object} environment
+ * An object containing a key for each environment variable to be used
+ * in the search.
+ * @returns {Promise<string>}
+ */
+ pathSearch: Task.async(function* (bin, environment) {
+ let split = OS.Path.split(bin);
+ if (split.absolute) {
+ if (yield fileExists(bin)) {
+ return bin;
+ }
+ let error = new Error(`File at path "${bin}" does not exist, or is not a normal file`);
+ error.errorCode = SubprocessConstants.ERROR_BAD_EXECUTABLE;
+ throw error;
+ }
+
+ let dirs = [];
+ let exts = [];
+ if (environment.PATH) {
+ dirs = environment.PATH.split(";");
+ }
+ if (environment.PATHEXT) {
+ exts = environment.PATHEXT.split(";");
+ }
+
+ for (let dir of dirs) {
+ let path = OS.Path.join(dir, bin);
+
+ if (yield fileExists(path)) {
+ return path;
+ }
+
+ for (let ext of exts) {
+ let file = path + ext;
+
+ if (yield fileExists(file)) {
+ return file;
+ }
+ }
+ }
+ let error = new Error(`Executable not found: ${bin}`);
+ error.errorCode = SubprocessConstants.ERROR_BAD_EXECUTABLE;
+ throw error;
+ }),
+};
+
+var SubprocessImpl = SubprocessWin;
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/subprocess_worker_common.js
@@ -0,0 +1,183 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+/* exported BasePipe, BaseProcess, debug */
+/* globals Process, io */
+
+function debug(message) {
+ self.postMessage({msg: "debug", message});
+}
+
+class BasePipe {
+ constructor() {
+ this.closing = false;
+ this.closed = false;
+
+ this.closedPromise = new Promise(resolve => {
+ this.resolveClosed = resolve;
+ });
+
+ this.pending = [];
+ }
+
+ shiftPending() {
+ let result = this.pending.shift();
+
+ if (this.closing && this.pending.length == 0) {
+ this.close();
+ }
+
+ return result;
+ }
+}
+
+let nextProcessId = 0;
+
+class BaseProcess {
+ constructor(options) {
+ this.id = nextProcessId++;
+
+ this.exitCode = null;
+
+ this.exitPromise = new Promise(resolve => {
+ this.resolveExit = resolve;
+ });
+ this.exitPromise.then(() => {
+ // The input file descriptors will be closed after poll
+ // reports that their input buffers are empty. If we close
+ // them now, we may lose output.
+ this.pipes[0].close(true);
+ });
+
+ this.pid = null;
+ this.pipes = [];
+
+ this.stringArrays = [];
+
+ this.spawn(options);
+ }
+
+ /**
+ * Creates a null-terminated array of pointers to null-terminated C-strings,
+ * and returns it.
+ *
+ * @param {string[]} strings
+ * The strings to convert into a C string array.
+ *
+ * @returns {ctypes.char.ptr.array()}
+ */
+ stringArray(strings) {
+ let result = ctypes.char.ptr.array(strings.length + 1)();
+
+ let cstrings = strings.map(str => ctypes.char.array()(str));
+ for (let [i, cstring] of cstrings.entries()) {
+ result[i] = cstring;
+ }
+
+ // Char arrays used in char arg and environment vectors must be
+ // explicitly kept alive in a JS object, or they will be reaped
+ // by the GC if it runs before our process is started.
+ this.stringArrays.push(cstrings);
+
+ return result;
+ }
+}
+
+let requests = {
+ close(pipeId, force = false) {
+ let pipe = io.getPipe(pipeId);
+
+ return pipe.close(force).then(() => ({data: {}}));
+ },
+
+ spawn(options) {
+ let process = new Process(options);
+ let processId = process.id;
+
+ io.addProcess(process);
+
+ let fds = process.pipes.map(pipe => pipe.id);
+
+ return {data: {processId, fds, pid: process.pid}};
+ },
+
+ kill(processId, force = false) {
+ let process = io.getProcess(processId);
+
+ process.kill(force ? 9 : 15);
+
+ return {data: {}};
+ },
+
+ wait(processId) {
+ let process = io.getProcess(processId);
+
+ process.wait();
+
+ return process.exitPromise.then(exitCode => {
+ io.cleanupProcess(process);
+ return {data: {exitCode}};
+ });
+ },
+
+ read(pipeId, count) {
+ let pipe = io.getPipe(pipeId);
+
+ return pipe.read(count).then(buffer => {
+ return {data: {buffer}};
+ });
+ },
+
+ write(pipeId, buffer) {
+ let pipe = io.getPipe(pipeId);
+
+ return pipe.write(buffer).then(bytesWritten => {
+ return {data: {bytesWritten}};
+ });
+ },
+};
+
+onmessage = event => {
+ let {msg, msgId, args} = event.data;
+
+ new Promise(resolve => {
+ resolve(requests[msg](...args));
+ }).then(result => {
+ let response = {
+ msg: "success",
+ msgId,
+ data: result.data,
+ };
+
+ self.postMessage(response, result.transfer || []);
+ }).catch(error => {
+ if (error instanceof Error) {
+ error = {
+ message: error.message,
+ fileName: error.fileName,
+ lineNumber: error.lineNumber,
+ column: error.column,
+ stack: error.stack,
+ errorCode: error.errorCode,
+ };
+ }
+
+ self.postMessage({
+ msg: "failure",
+ msgId,
+ error,
+ });
+ }).catch(error => {
+ console.error(error);
+
+ self.postMessage({
+ msg: "failure",
+ msgId,
+ error: {},
+ });
+ });
+};
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/subprocess_worker_unix.js
@@ -0,0 +1,539 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+/* exported Process */
+/* globals BaseProcess, BasePipe */
+
+importScripts("resource://gre/modules/subprocess/subprocess_shared.js",
+ "resource://gre/modules/subprocess/subprocess_shared_unix.js",
+ "resource://gre/modules/subprocess/subprocess_worker_common.js");
+
+const POLL_INTERVAL = 50;
+const POLL_TIMEOUT = 0;
+
+let io;
+
+let nextPipeId = 0;
+
+class Pipe extends BasePipe {
+ constructor(process, fd) {
+ super();
+
+ this.process = process;
+ this.fd = fd;
+ this.id = nextPipeId++;
+ }
+
+ get pollEvents() {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Closes the file descriptor.
+ *
+ * @param {boolean} [force=false]
+ * If true, the file descriptor is closed immediately. If false, the
+ * file descriptor is closed after all current pending IO operations
+ * have completed.
+ *
+ * @returns {Promise<void>}
+ * Resolves when the file descriptor has been closed.
+ */
+ close(force = false) {
+ if (!force && this.pending.length) {
+ this.closing = true;
+ return this.closedPromise;
+ }
+
+ for (let {reject} of this.pending) {
+ let error = new Error("File closed");
+ error.errorCode = SubprocessConstants.ERROR_END_OF_FILE;
+ reject(error);
+ }
+ this.pending.length = 0;
+
+ if (!this.closed) {
+ this.fd.dispose();
+
+ this.closed = true;
+ this.resolveClosed();
+
+ io.pipes.delete(this.id);
+ io.updatePollFds();
+ }
+ return this.closedPromise;
+ }
+
+ /**
+ * Called when an error occurred while polling our file descriptor.
+ */
+ onError() {
+ this.close(true);
+ this.process.wait();
+ }
+}
+
+class InputPipe extends Pipe {
+ /**
+ * A bit mask of poll() events which we currently wish to be notified of on
+ * this file descriptor.
+ */
+ get pollEvents() {
+ if (this.pending.length) {
+ return LIBC.POLLIN;
+ }
+ return 0;
+ }
+
+ /**
+ * Asynchronously reads at most `length` bytes of binary data from the file
+ * descriptor into an ArrayBuffer of the same size. Returns a promise which
+ * resolves when the operation is complete.
+ *
+ * @param {integer} length
+ * The number of bytes to read.
+ *
+ * @returns {Promise<ArrayBuffer>}
+ */
+ read(length) {
+ if (this.closing || this.closed) {
+ throw new Error("Attempt to read from closed pipe");
+ }
+
+ return new Promise((resolve, reject) => {
+ this.pending.push({resolve, reject, length});
+ io.updatePollFds();
+ });
+ }
+
+ /**
+ * Synchronously reads at most `count` bytes of binary data into an
+ * ArrayBuffer, and returns that buffer. If no data can be read without
+ * blocking, returns null instead.
+ *
+ * @param {integer} count
+ * The number of bytes to read.
+ *
+ * @returns {ArrayBuffer|null}
+ */
+ readBuffer(count) {
+ let buffer = new ArrayBuffer(count);
+
+ let read = libc.read(this.fd, buffer, buffer.byteLength);
+ if (read < 0 && ctypes.errno != LIBC.EAGAIN) {
+ this.onError();
+ }
+
+ if (read <= 0) {
+ return null;
+ }
+
+ if (read < buffer.byteLength) {
+ return ArrayBuffer.transfer(buffer, read);
+ }
+
+ return buffer;
+ }
+
+
+ /**
+ * Called when one of the IO operations matching the `pollEvents` mask may be
+ * performed without blocking.
+ */
+ onReady() {
+ let reads = this.pending;
+ while (reads.length) {
+ let {resolve, length} = reads[0];
+
+ let buffer = this.readBuffer(length);
+ if (buffer) {
+ this.shiftPending();
+ resolve(buffer);
+ } else {
+ break;
+ }
+ }
+
+ if (reads.length == 0) {
+ io.updatePollFds();
+ }
+ }
+}
+
+class OutputPipe extends Pipe {
+ /**
+ * A bit mask of poll() events which we currently wish to be notified of on
+ * this file discriptor.
+ */
+ get pollEvents() {
+ if (this.pending.length) {
+ return LIBC.POLLOUT;
+ }
+ return 0;
+ }
+
+ /**
+ * Asynchronously writes the given buffer to our file descriptor, and returns
+ * a promise which resolves when the operation is complete.
+ *
+ * @param {ArrayBuffer} buffer
+ * The buffer to write.
+ *
+ * @returns {Promise<integer>}
+ * Resolves to the number of bytes written when the operation is
+ * complete.
+ */
+ write(buffer) {
+ if (this.closing || this.closed) {
+ throw new Error("Attempt to write to closed pipe");
+ }
+
+ return new Promise((resolve, reject) => {
+ this.pending.push({resolve, reject, buffer, length: buffer.byteLength});
+ io.updatePollFds();
+ });
+ }
+
+ /**
+ * Attempts to synchronously write the given buffer to our file descriptor.
+ * Writes only as many bytes as can be written without blocking, and returns
+ * the number of byes successfully written.
+ *
+ * Closes the file descriptor if an IO error occurs.
+ *
+ * @param {ArrayBuffer} buffer
+ * The buffer to write.
+ *
+ * @returns {integer}
+ * The number of bytes successfully written.
+ */
+ writeBuffer(buffer) {
+ let bytesWritten = libc.write(this.fd, buffer, buffer.byteLength);
+
+ if (bytesWritten < 0 && ctypes.errno != LIBC.EAGAIN) {
+ this.onError();
+ }
+
+ return bytesWritten;
+ }
+
+ /**
+ * Called when one of the IO operations matching the `pollEvents` mask may be
+ * performed without blocking.
+ */
+ onReady() {
+ let writes = this.pending;
+ while (writes.length) {
+ let {buffer, resolve, length} = writes[0];
+
+ let written = this.writeBuffer(buffer);
+
+ if (written == buffer.byteLength) {
+ resolve(length);
+ this.shiftPending();
+ } else if (written > 0) {
+ writes[0].buffer = buffer.slice(written);
+ } else {
+ break;
+ }
+ }
+
+ if (writes.length == 0) {
+ io.updatePollFds();
+ }
+ }
+}
+
+class Process extends BaseProcess {
+ /**
+ * Each Process object opens an additional pipe from the target object, which
+ * will be automatically closed when the process exits, but otherwise
+ * carries no data.
+ *
+ * This property contains a bit mask of poll() events which we wish to be
+ * notified of on this descriptor. We're not expecting any input from this
+ * pipe, but we need to poll for input until the process exits in order to be
+ * notified when the pipe closes.
+ */
+ get pollEvents() {
+ if (this.exitCode === null) {
+ return LIBC.POLLIN;
+ }
+ return 0;
+ }
+
+ /**
+ * Kills the process with the given signal.
+ *
+ * @param {integer} signal
+ */
+ kill(signal) {
+ libc.kill(this.pid, signal);
+ this.wait();
+ }
+
+ /**
+ * Initializes the IO pipes for use as standard input, output, and error
+ * descriptors in the spawned process.
+ *
+ * @returns {unix.Fd[]}
+ * The array of file descriptors belonging to the spawned process.
+ */
+ initPipes(options) {
+ let stderr = options.stderr;
+
+ let our_pipes = [];
+ let their_pipes = new Map();
+
+ let pipe = input => {
+ let fds = ctypes.int.array(2)();
+
+ let res = libc.pipe(fds);
+ if (res == -1) {
+ throw new Error("Unable to create pipe");
+ }
+
+ fds = Array.from(fds, unix.Fd);
+
+ if (input) {
+ fds.reverse();
+ }
+
+ if (input) {
+ our_pipes.push(new InputPipe(this, fds[1]));
+ } else {
+ our_pipes.push(new OutputPipe(this, fds[1]));
+ }
+
+ libc.fcntl(fds[0], LIBC.F_SETFD, LIBC.FD_CLOEXEC);
+ libc.fcntl(fds[1], LIBC.F_SETFD, LIBC.FD_CLOEXEC);
+ libc.fcntl(fds[1], LIBC.F_SETFL, LIBC.O_NONBLOCK);
+
+ return fds[0];
+ };
+
+ their_pipes.set(0, pipe(false));
+ their_pipes.set(1, pipe(true));
+
+ if (stderr == "pipe") {
+ their_pipes.set(2, pipe(true));
+ } else if (stderr == "stdout") {
+ their_pipes.set(2, their_pipes[1]);
+ }
+
+ // Create an additional pipe that we can use to monitor for process exit.
+ their_pipes.set(3, pipe(true));
+ this.fd = our_pipes.pop().fd;
+
+ this.pipes = our_pipes;
+
+ return their_pipes;
+ }
+
+ spawn(options) {
+ let {command, arguments: args} = options;
+
+ let argv = this.stringArray(args);
+ let envp = this.stringArray(options.environment);
+
+ let actions = unix.posix_spawn_file_actions_t();
+ let actionsp = actions.address();
+
+ let fds = this.initPipes(options);
+
+ let cwd;
+ try {
+ if (options.workdir) {
+ cwd = ctypes.char.array(LIBC.PATH_MAX)();
+ libc.getcwd(cwd, cwd.length);
+
+ if (libc.chdir(options.workdir) < 0) {
+ throw new Error(`Unable to change working directory to ${options.workdir}`);
+ }
+ }
+
+ libc.posix_spawn_file_actions_init(actionsp);
+ for (let [i, fd] of fds.entries()) {
+ libc.posix_spawn_file_actions_adddup2(actionsp, fd, i);
+ }
+
+ let pid = unix.pid_t();
+ let rv = libc.posix_spawn(pid.address(), command, actionsp, null, argv, envp);
+
+ if (rv != 0) {
+ for (let pipe of this.pipes) {
+ pipe.close();
+ }
+ throw new Error(`Failed to execute command "${command}"`);
+ }
+
+ this.pid = pid.value;
+ } finally {
+ libc.posix_spawn_file_actions_destroy(actionsp);
+
+ this.stringArrays.length = 0;
+
+ if (cwd) {
+ libc.chdir(cwd);
+ }
+ for (let fd of fds.values()) {
+ fd.dispose();
+ }
+ }
+ }
+
+ /**
+ * Called when input is available on our sentinel file descriptor.
+ *
+ * @see pollEvents
+ */
+ onReady() {
+ // We're not actually expecting any input on this pipe. If we get any, we
+ // can't poll the pipe any further without reading it.
+ if (this.wait() == undefined) {
+ this.kill(9);
+ }
+ }
+
+ /**
+ * Called when an error occurred while polling our sentinel file descriptor.
+ *
+ * @see pollEvents
+ */
+ onError() {
+ this.wait();
+ }
+
+ /**
+ * Attempts to wait for the process's exit status, without blocking. If
+ * successful, resolves the `exitPromise` to the process's exit value.
+ *
+ * @returns {integer|null}
+ * The process's exit status, if it has already exited.
+ */
+ wait() {
+ if (this.exitCode !== null) {
+ return this.exitCode;
+ }
+
+ let status = ctypes.int();
+
+ let res = libc.waitpid(this.pid, status.address(), LIBC.WNOHANG);
+ if (res == this.pid) {
+ let sig = unix.WTERMSIG(status.value);
+ if (sig) {
+ this.exitCode = -sig;
+ } else {
+ this.exitCode = unix.WEXITSTATUS(status.value);
+ }
+
+ this.fd.dispose();
+ this.resolveExit(this.exitCode);
+ return this.exitCode;
+ }
+ }
+}
+
+io = {
+ pollFds: null,
+ pollHandlers: null,
+
+ pipes: new Map(),
+
+ processes: new Map(),
+
+ interval: null,
+
+ getPipe(pipeId) {
+ let pipe = this.pipes.get(pipeId);
+
+ if (!pipe) {
+ let error = new Error("File closed");
+ error.errorCode = SubprocessConstants.ERROR_END_OF_FILE;
+ throw error;
+ }
+ return pipe;
+ },
+
+ getProcess(processId) {
+ let process = this.processes.get(processId);
+
+ if (!process) {
+ throw new Error(`Invalid process ID: ${processId}`);
+ }
+ return process;
+ },
+
+ updatePollFds() {
+ let handlers = [...this.pipes.values(),
+ ...this.processes.values()];
+
+ handlers = handlers.filter(handler => handler.pollEvents);
+
+ let pollfds = unix.pollfd.array(handlers.length)();
+
+ for (let [i, handler] of handlers.entries()) {
+ let pollfd = pollfds[i];
+
+ pollfd.fd = handler.fd;
+ pollfd.events = handler.pollEvents;
+ pollfd.revents = 0;
+ }
+
+ this.pollFds = pollfds;
+ this.pollHandlers = handlers;
+
+ if (pollfds.length && !this.interval) {
+ this.interval = setInterval(this.poll.bind(this), POLL_INTERVAL);
+ } else if (!pollfds.length && this.interval) {
+ clearInterval(this.interval);
+ this.interval = null;
+ }
+ },
+
+ poll() {
+ let handlers = this.pollHandlers;
+ let pollfds = this.pollFds;
+
+ let count = libc.poll(pollfds, pollfds.length, POLL_TIMEOUT);
+
+ for (let i = 0; count && i < pollfds.length; i++) {
+ let pollfd = pollfds[i];
+ if (pollfd.revents) {
+ count--;
+
+ let handler = handlers[i];
+ try {
+ if (pollfd.revents & handler.pollEvents) {
+ handler.onReady();
+ }
+ if (pollfd.revents & (LIBC.POLLERR | LIBC.POLLHUP | LIBC.POLLNVAL)) {
+ handler.onError();
+ }
+ } catch (e) {
+ console.error(e);
+ debug(`Worker error: ${e} :: ${e.stack}`);
+ handler.onError();
+ }
+
+ pollfd.revents = 0;
+ }
+ }
+ },
+
+ addProcess(process) {
+ this.processes.set(process.id, process);
+
+ for (let pipe of process.pipes) {
+ this.pipes.set(pipe.id, pipe);
+ }
+ },
+
+ cleanupProcess(process) {
+ this.processes.delete(process.id);
+ },
+};
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/subprocess_worker_win.js
@@ -0,0 +1,585 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+/* exported Process */
+/* globals BaseProcess, BasePipe, win32 */
+
+importScripts("resource://gre/modules/subprocess/subprocess_shared.js",
+ "resource://gre/modules/subprocess/subprocess_shared_win.js",
+ "resource://gre/modules/subprocess/subprocess_worker_common.js");
+
+const POLL_INTERVAL = 50;
+const POLL_TIMEOUT = 0;
+
+const TERMINATE_EXIT_CODE = 0x7f;
+
+let io;
+
+let nextPipeId = 0;
+
+class Pipe extends BasePipe {
+ constructor(process, origHandle) {
+ super();
+
+ let handle = win32.HANDLE();
+
+ let curProc = libc.GetCurrentProcess();
+ libc.DuplicateHandle(curProc, origHandle, curProc, handle.address(),
+ 0, false /* inheritable */, win32.DUPLICATE_SAME_ACCESS);
+
+ origHandle.dispose();
+
+ this.id = nextPipeId++;
+ this.process = process;
+
+ this.handle = win32.Handle(handle);
+
+ let event = libc.CreateEventW(null, false, false, null);
+
+ this.overlapped = win32.OVERLAPPED();
+ this.overlapped.hEvent = event;
+
+ this._event = win32.Handle(event);
+
+ this.buffer = null;
+ }
+
+ get event() {
+ if (this.pending.length) {
+ return this._event;
+ }
+ return null;
+ }
+
+ maybeClose() {}
+
+ /**
+ * Closes the file handle.
+ *
+ * @param {boolean} [force=false]
+ * If true, the file handle is closed immediately. If false, the
+ * file handle is closed after all current pending IO operations
+ * have completed.
+ *
+ * @returns {Promise<void>}
+ * Resolves when the file handle has been closed.
+ */
+ close(force = false) {
+ if (!force && this.pending.length) {
+ this.closing = true;
+ return this.closedPromise;
+ }
+
+ for (let {reject} of this.pending) {
+ let error = new Error("File closed");
+ error.errorCode = SubprocessConstants.ERROR_END_OF_FILE;
+ reject(error);
+ }
+ this.pending.length = 0;
+
+ this.buffer = null;
+
+ if (!this.closed) {
+ this.handle.dispose();
+ this._event.dispose();
+
+ io.pipes.delete(this.handle);
+
+ this.handle = null;
+ this.closed = true;
+ this.resolveClosed();
+
+ io.updatePollEvents();
+ }
+ return this.closedPromise;
+ }
+
+ /**
+ * Called when an error occurred while attempting an IO operation on our file
+ * handle.
+ */
+ onError() {
+ this.close(true);
+ }
+}
+
+class InputPipe extends Pipe {
+ /**
+ * Queues the next chunk of data to be read from the pipe if, and only if,
+ * there is no IO operation currently pending.
+ */
+ readNext() {
+ if (this.buffer === null) {
+ this.readBuffer(this.pending[0].length);
+ }
+ }
+
+ /**
+ * Closes the pipe if there is a pending read operation with no more
+ * buffered data to be read.
+ */
+ maybeClose() {
+ if (this.buffer) {
+ let read = win32.DWORD();
+
+ let ok = libc.GetOverlappedResult(
+ this.handle, this.overlapped.address(),
+ read.address(), false);
+
+ if (!ok) {
+ this.onError();
+ }
+ }
+ }
+
+ /**
+ * Asynchronously reads at most `length` bytes of binary data from the file
+ * descriptor into an ArrayBuffer of the same size. Returns a promise which
+ * resolves when the operation is complete.
+ *
+ * @param {integer} length
+ * The number of bytes to read.
+ *
+ * @returns {Promise<ArrayBuffer>}
+ */
+ read(length) {
+ if (this.closing || this.closed) {
+ throw new Error("Attempt to read from closed pipe");
+ }
+
+ return new Promise((resolve, reject) => {
+ this.pending.push({resolve, reject, length});
+ this.readNext();
+ });
+ }
+
+ /**
+ * Initializes an overapped IO read operation to read exactly `count` bytes
+ * into a new ArrayBuffer, which is stored in the `buffer` property until the
+ * operation completes.
+ *
+ * @param {integer} count
+ * The number of bytes to read.
+ */
+ readBuffer(count) {
+ this.buffer = new ArrayBuffer(count);
+
+ let ok = libc.ReadFile(this.handle, this.buffer, count,
+ null, this.overlapped.address());
+
+ if (!ok && (!this.process.handle || libc.GetLastError())) {
+ this.onError();
+ } else {
+ io.updatePollEvents();
+ }
+ }
+
+ /**
+ * Called when our pending overlapped IO operation has completed, whether
+ * successfully or in failure.
+ */
+ onReady() {
+ let read = win32.DWORD();
+
+ let ok = libc.GetOverlappedResult(
+ this.handle, this.overlapped.address(),
+ read.address(), false);
+
+ read = read.value;
+
+ if (!ok) {
+ this.onError();
+ } else if (read > 0) {
+ let buffer = this.buffer;
+ this.buffer = null;
+
+ let {resolve} = this.shiftPending();
+
+ if (read == buffer.byteLength) {
+ resolve(buffer);
+ } else {
+ resolve(ArrayBuffer.transfer(buffer, read));
+ }
+
+ if (this.pending.length) {
+ this.readNext();
+ } else {
+ io.updatePollEvents();
+ }
+ }
+ }
+}
+
+class OutputPipe extends Pipe {
+ /**
+ * Queues the next chunk of data to be written to the pipe if, and only if,
+ * there is no IO operation currently pending.
+ */
+ writeNext() {
+ if (this.buffer === null) {
+ this.writeBuffer(this.pending[0].buffer);
+ }
+ }
+
+ /**
+ * Asynchronously writes the given buffer to our file descriptor, and returns
+ * a promise which resolves when the operation is complete.
+ *
+ * @param {ArrayBuffer} buffer
+ * The buffer to write.
+ *
+ * @returns {Promise<integer>}
+ * Resolves to the number of bytes written when the operation is
+ * complete.
+ */
+ write(buffer) {
+ if (this.closing || this.closed) {
+ throw new Error("Attempt to write to closed pipe");
+ }
+
+ return new Promise((resolve, reject) => {
+ this.pending.push({resolve, reject, buffer});
+ this.writeNext();
+ });
+ }
+
+ /**
+ * Initializes an overapped IO read operation to write the data in `buffer` to
+ * our file descriptor.
+ *
+ * @param {ArrayBuffer} buffer
+ * The buffer to write.
+ */
+ writeBuffer(buffer) {
+ this.buffer = buffer;
+
+ let ok = libc.WriteFile(this.handle, buffer, buffer.byteLength,
+ null, this.overlapped.address());
+
+ if (!ok && libc.GetLastError()) {
+ this.onError();
+ } else {
+ io.updatePollEvents();
+ }
+ }
+
+ /**
+ * Called when our pending overlapped IO operation has completed, whether
+ * successfully or in failure.
+ */
+ onReady() {
+ let written = win32.DWORD();
+
+ let ok = libc.GetOverlappedResult(
+ this.handle, this.overlapped.address(),
+ written.address(), false);
+
+ written = written.value;
+
+ if (!ok || written != this.buffer.byteLength) {
+ this.onError();
+ } else if (written > 0) {
+ let {resolve} = this.shiftPending();
+
+ this.buffer = null;
+ resolve(written);
+
+ if (this.pending.length) {
+ this.writeNext();
+ } else {
+ io.updatePollEvents();
+ }
+ }
+ }
+}
+
+class Process extends BaseProcess {
+ /**
+ * Returns our process handle for use as an event in a WaitForMultipleObjects
+ * call.
+ */
+ get event() {
+ return this.handle;
+ }
+
+ /**
+ * Forcibly terminates the process.
+ */
+ kill(exitCode) {
+ libc.TerminateProcess(this.handle, TERMINATE_EXIT_CODE);
+ }
+
+ /**
+ * Initializes the IO pipes for use as standard input, output, and error
+ * descriptors in the spawned process.
+ *
+ * @returns {win32.Handle[]}
+ * The array of file handles belonging to the spawned process.
+ */
+ initPipes({stderr}) {
+ let our_pipes = [];
+ let their_pipes = [];
+
+ let secAttr = new win32.SECURITY_ATTRIBUTES();
+ secAttr.nLength = win32.SECURITY_ATTRIBUTES.size;
+ secAttr.bInheritHandle = true;
+
+ let pipe = input => {
+ if (input) {
+ let handles = win32.createPipe(secAttr, win32.FILE_FLAG_OVERLAPPED);
+ our_pipes.push(new InputPipe(this, handles[0]));
+ return handles[1];
+ } else {
+ let handles = win32.createPipe(secAttr, 0, win32.FILE_FLAG_OVERLAPPED);
+ our_pipes.push(new OutputPipe(this, handles[1]));
+ return handles[0];
+ }
+ };
+
+ their_pipes[0] = pipe(false);
+ their_pipes[1] = pipe(true);
+
+ if (stderr == "pipe") {
+ their_pipes[2] = pipe(true);
+ } else {
+ let srcHandle;
+ if (stderr == "stdout") {
+ srcHandle = their_pipes[1];
+ } else {
+ srcHandle = libc.GetStdHandle(win32.STD_ERROR_HANDLE);
+ }
+
+ let handle = win32.HANDLE();
+
+ let curProc = libc.GetCurrentProcess();
+ let ok = libc.DuplicateHandle(curProc, srcHandle, curProc, handle.address(),
+ 0, true /* inheritable */,
+ win32.DUPLICATE_SAME_ACCESS);
+
+ their_pipes[2] = ok && win32.Handle(handle);
+ }
+
+ if (!their_pipes.every(handle => handle)) {
+ throw new Error("Failed to create pipe");
+ }
+
+ this.pipes = our_pipes;
+
+ return their_pipes;
+ }
+
+ /**
+ * Creates a null-separated, null-terminated string list.
+ */
+ stringList(strings) {
+ // Remove empty strings, which would terminate the list early.
+ strings = strings.filter(string => string);
+
+ let string = strings.join("\0") + "\0\0";
+
+ return win32.WCHAR.array()(string);
+ }
+
+ /**
+ * Quotes a string for use as a single command argument, using Windows quoting
+ * conventions.
+ *
+ * @see https://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx
+ */
+ quoteString(str) {
+ if (!/[\s"]/.test(str)) {
+ return str;
+ }
+
+ let escaped = str.replace(/(\\*)("|$)/g, (m0, m1, m2) => {
+ if (m2) {
+ m2 = `\\${m2}`;
+ }
+ return `${m1}${m1}${m2}`;
+ });
+
+ return `"${escaped}"`;
+ }
+
+ spawn(options) {
+ let {command, arguments: args} = options;
+
+ args = args.map(arg => this.quoteString(arg));
+
+ let envp = this.stringList(options.environment);
+
+ let handles = this.initPipes(options);
+
+ let processFlags = win32.CREATE_NO_WINDOW
+ | win32.CREATE_UNICODE_ENVIRONMENT;
+
+ let startupInfo = new win32.STARTUPINFOW();
+ startupInfo.cb = win32.STARTUPINFOW.size;
+ startupInfo.dwFlags = win32.STARTF_USESTDHANDLES;
+
+ startupInfo.hStdInput = handles[0];
+ startupInfo.hStdOutput = handles[1];
+ startupInfo.hStdError = handles[2];
+
+ let procInfo = new win32.PROCESS_INFORMATION();
+
+ let ok = libc.CreateProcessW(
+ command, args.join(" "),
+ null, /* Security attributes */
+ null, /* Thread security attributes */
+ true, /* Inherits handles */
+ processFlags, envp, options.workdir,
+ startupInfo.address(),
+ procInfo.address());
+
+ for (let handle of handles) {
+ handle.dispose();
+ }
+
+ if (!ok) {
+ for (let pipe of this.pipes) {
+ pipe.close();
+ }
+ throw new Error("Failed to create process");
+ }
+
+ libc.CloseHandle(procInfo.hThread);
+
+ this.handle = win32.Handle(procInfo.hProcess);
+ this.pid = procInfo.dwProcessId;
+ }
+
+ /**
+ * Called when our process handle is signaled as active, meaning the process
+ * has exited.
+ */
+ onReady() {
+ this.wait();
+ }
+
+ /**
+ * Attempts to wait for the process's exit status, without blocking. If
+ * successful, resolves the `exitPromise` to the process's exit value.
+ *
+ * @returns {integer|null}
+ * The process's exit status, if it has already exited.
+ */
+ wait() {
+ if (this.exitCode !== null) {
+ return this.exitCode;
+ }
+
+ let status = win32.DWORD();
+
+ let ok = libc.GetExitCodeProcess(this.handle, status.address());
+ if (ok && status.value != win32.STILL_ACTIVE) {
+ let exitCode = status.value;
+ if (exitCode == TERMINATE_EXIT_CODE) {
+ // Process forcibly terminated.
+ exitCode = -9;
+ }
+
+ this.resolveExit(exitCode);
+ this.exitCode = exitCode;
+
+ this.handle.dispose();
+ this.handle = null;
+
+ for (let pipe of this.pipes) {
+ pipe.maybeClose();
+ }
+
+ io.updatePollEvents();
+
+ return exitCode;
+ }
+ }
+}
+
+io = {
+ events: null,
+ eventHandlers: null,
+
+ pipes: new Map(),
+
+ processes: new Map(),
+
+ interval: null,
+
+ getPipe(pipeId) {
+ let pipe = this.pipes.get(pipeId);
+
+ if (!pipe) {
+ let error = new Error("File closed");
+ error.errorCode = SubprocessConstants.ERROR_END_OF_FILE;
+ throw error;
+ }
+ return pipe;
+ },
+
+ getProcess(processId) {
+ let process = this.processes.get(processId);
+
+ if (!process) {
+ throw new Error(`Invalid process ID: ${processId}`);
+ }
+ return process;
+ },
+
+ updatePollEvents() {
+ let handlers = [...this.pipes.values(),
+ ...this.processes.values()];
+
+ handlers = handlers.filter(handler => handler.event);
+
+ this.eventHandlers = handlers;
+
+ let handles = handlers.map(handler => handler.event);
+ this.events = win32.HANDLE.array()(handles);
+
+ if (handles.length && !this.interval) {
+ this.interval = setInterval(this.poll.bind(this), POLL_INTERVAL);
+ } else if (!handlers.length && this.interval) {
+ clearInterval(this.interval);
+ this.interval = null;
+ }
+ },
+
+ poll() {
+ for (;;) {
+ let events = this.events;
+ let handlers = this.eventHandlers;
+
+ let result = libc.WaitForMultipleObjects(events.length, events,
+ false, POLL_TIMEOUT);
+
+ if (result < handlers.length) {
+ try {
+ handlers[result].onReady();
+ } catch (e) {
+ console.error(e);
+ debug(`Worker error: ${e} :: ${e.stack}`);
+ handlers[result].onError();
+ }
+ } else {
+ break;
+ }
+ }
+ },
+
+ addProcess(process) {
+ this.processes.set(process.id, process);
+
+ for (let pipe of process.pipes) {
+ this.pipes.set(pipe.id, pipe);
+ }
+ },
+
+ cleanupProcess(process) {
+ this.processes.delete(process.id);
+ },
+};
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/test/xpcshell/.eslintrc
@@ -0,0 +1,3 @@
+{
+ "extends": "../../../../../testing/xpcshell/xpcshell.eslintrc",
+}
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/test/xpcshell/data_test_script.py
@@ -0,0 +1,35 @@
+#!/usr/bin/env python2
+from __future__ import print_function
+
+import os
+import struct
+import sys
+
+
+def output(line):
+ sys.stdout.write(struct.pack('@I', len(line)))
+ sys.stdout.write(line)
+ sys.stdout.flush()
+
+
+def echo_loop():
+ while True:
+ line = sys.stdin.readline()
+ if not line:
+ break
+
+ output(line)
+
+cmd = sys.argv[1]
+if cmd == 'echo':
+ echo_loop()
+elif cmd == 'exit':
+ sys.exit(int(sys.argv[2]))
+elif cmd == 'env':
+ for var in sys.argv[2:]:
+ output(os.environ.get(var, ""))
+elif cmd == 'pwd':
+ output(os.path.abspath(os.curdir))
+elif cmd == 'print_args':
+ for arg in sys.argv[2:]:
+ output(arg)
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/test/xpcshell/head.js
@@ -0,0 +1,14 @@
+"use strict";
+
+const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "AppConstants",
+ "resource://gre/modules/AppConstants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "OS",
+ "resource://gre/modules/osfile.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Services",
+ "resource://gre/modules/Services.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Subprocess",
+ "resource://gre/modules/Subprocess.jsm");
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/test/xpcshell/test_subprocess.js
@@ -0,0 +1,427 @@
+"use strict";
+
+Cu.import("resource://gre/modules/Timer.jsm");
+
+
+const env = Cc["@mozilla.org/process/environment;1"].getService(Ci.nsIEnvironment);
+
+const PYTHON = env.get("PYTHON");
+
+const PYTHON_BIN = OS.Path.basename(PYTHON);
+const PYTHON_DIR = OS.Path.dirname(PYTHON);
+
+const TEST_SCRIPT = do_get_file("data_test_script.py").path;
+
+let read = pipe => {
+ return pipe.readUint32().then(count => {
+ return pipe.readString(count);
+ });
+};
+
+
+add_task(function* test_subprocess_io() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "echo"],
+ });
+
+ const LINE1 = "I'm a leaf on the wind.\n";
+ const LINE2 = "Watch how I soar.\n";
+
+
+ let outputPromise = read(proc.stdout);
+
+ yield new Promise(resolve => setTimeout(resolve, 100));
+
+ let [output] = yield Promise.all([
+ outputPromise,
+ proc.stdin.write(LINE1),
+ ]);
+
+ equal(output, LINE1, "Got expected output");
+
+
+ // Make sure it succeeds whether the write comes before or after the
+ // read.
+ let inputPromise = proc.stdin.write(LINE2);
+
+ yield new Promise(resolve => setTimeout(resolve, 100));
+
+ [output] = yield Promise.all([
+ read(proc.stdout),
+ inputPromise,
+ ]);
+
+ equal(output, LINE2, "Got expected output");
+
+
+ let JSON_BLOB = {foo: {bar: "baz"}};
+
+ inputPromise = proc.stdin.write(JSON.stringify(JSON_BLOB) + "\n");
+
+ output = yield proc.stdout.readUint32().then(count => {
+ return proc.stdout.readJSON(count);
+ });
+
+ Assert.deepEqual(output, JSON_BLOB, "Got expected JSON output");
+
+
+ yield proc.stdin.close();
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 0, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_huge_io() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "echo"],
+ });
+
+ const LINE = "I'm a leaf on the wind.\n";
+ const BUFFER_SIZE = 4096;
+
+ // Create a message that's ~3/4 the input buffer size.
+ let msg = Array(BUFFER_SIZE * .75 / 16 | 0).fill("0123456789abcdef").join("") + "\n";
+
+ // This sequence of writes and reads crosses several buffer size
+ // boundaries, and causes some branches of the read buffer code to be
+ // exercised which are not exercised by other tests.
+ proc.stdin.write(msg);
+ proc.stdin.write(msg);
+ proc.stdin.write(LINE);
+
+ let output = yield read(proc.stdout);
+ equal(output, msg, "Got the expected output");
+
+ output = yield read(proc.stdout);
+ equal(output, msg, "Got the expected output");
+
+ output = yield read(proc.stdout);
+ equal(output, LINE, "Got the expected output");
+
+ proc.stdin.close();
+
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 0, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_lazy_close_output() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "echo"],
+ });
+
+ const LINE1 = "I'm a leaf on the wind.\n";
+ const LINE2 = "Watch how I soar.\n";
+
+ let writePromises = [
+ proc.stdin.write(LINE1),
+ proc.stdin.write(LINE2),
+ ];
+ let closedPromise = proc.stdin.close();
+
+
+ let output1 = yield read(proc.stdout);
+ let output2 = yield read(proc.stdout);
+
+ yield Promise.all([...writePromises, closedPromise]);
+
+ equal(output1, LINE1, "Got expected output");
+ equal(output2, LINE2, "Got expected output");
+
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 0, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_lazy_close_input() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "echo"],
+ });
+
+ let readPromise = proc.stdout.readUint32();
+ let closedPromise = proc.stdout.close();
+
+
+ const LINE = "I'm a leaf on the wind.\n";
+
+ proc.stdin.write(LINE);
+ proc.stdin.close();
+
+ let len = yield readPromise;
+ equal(len, LINE.length);
+
+ yield closedPromise;
+
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 0, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_force_close() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "echo"],
+ });
+
+ let readPromise = proc.stdout.readUint32();
+ let closedPromise = proc.stdout.close(true);
+
+ yield Assert.rejects(
+ readPromise,
+ function(e) {
+ equal(e.errorCode, Subprocess.ERROR_END_OF_FILE,
+ "Got the expected error code");
+ return /File closed/.test(e.message);
+ },
+ "Promise should be rejected when file is closed");
+
+ yield closedPromise;
+ yield proc.stdin.close();
+
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 0, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_eof() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "echo"],
+ });
+
+ let readPromise = proc.stdout.readUint32();
+
+ yield proc.stdin.close();
+
+ yield Assert.rejects(
+ readPromise,
+ function(e) {
+ equal(e.errorCode, Subprocess.ERROR_END_OF_FILE,
+ "Got the expected error code");
+ return /File closed/.test(e.message);
+ },
+ "Promise should be rejected on EOF");
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 0, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_invalid_json() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "echo"],
+ });
+
+ const LINE = "I'm a leaf on the wind.\n";
+
+ proc.stdin.write(LINE);
+ proc.stdin.close();
+
+ let count = yield proc.stdout.readUint32();
+ let readPromise = proc.stdout.readJSON(count);
+
+ yield Assert.rejects(
+ readPromise,
+ function(e) {
+ equal(e.errorCode, Subprocess.ERROR_INVALID_JSON,
+ "Got the expected error code");
+ return /SyntaxError/.test(e);
+ },
+ "Promise should be rejected on EOF");
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 0, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_wait() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "exit", "42"],
+ });
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 42, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_pathSearch() {
+ let proc = yield Subprocess.call({
+ command: PYTHON_BIN,
+ arguments: ["-u", TEST_SCRIPT, "exit", "13"],
+ environment: {
+ PATH: PYTHON_DIR,
+ },
+ });
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 13, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_workdir() {
+ let procDir = yield OS.File.getCurrentDirectory();
+ let tmpDir = OS.Constants.Path.tmpDir;
+
+ notEqual(procDir, tmpDir,
+ "Current process directory must not be the current temp directory");
+
+ function* pwd(options) {
+ let proc = yield Subprocess.call(Object.assign({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "pwd"],
+ }, options));
+
+ let pwd = read(proc.stdout);
+
+ let {exitCode} = yield proc.wait();
+ equal(exitCode, 0, "Got expected exit code");
+
+ return pwd;
+ }
+
+ let dir = yield pwd({});
+ equal(dir, procDir, "Process should normally launch in current process directory");
+
+ dir = yield pwd({workdir: tmpDir});
+ equal(dir, tmpDir, "Process should launch in the directory specified in `workdir`");
+
+ dir = yield OS.File.getCurrentDirectory();
+ equal(dir, procDir, "`workdir` should not change the working directory of the current process");
+});
+
+
+if (AppConstants.platform != "win") {
+ // Windows does not support killing processes gracefully.
+ //
+ // Note: Using a conditional task here causes the harness to skip the
+ // rest of the tests, so we conditionally add the task instead.
+ add_task(function* test_subprocess_term() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "echo"],
+ });
+
+ yield proc.kill(false);
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, -15, "Got expected exit code");
+ });
+}
+
+add_task(function* test_subprocess_kill() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "echo"],
+ });
+
+ yield proc.kill(true);
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, -9, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_arguments() {
+ let args = [
+ String.raw`C:\Program Files\Company\Program.exe`,
+ String.raw`foo bar baz`,
+ String.raw`"foo bar baz"`,
+ `Thing\\`,
+ String.raw`Thing \" with "" quotes\\" \\`,
+ ];
+
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "print_args", ...args],
+ });
+
+ for (let [i, arg] of args.entries()) {
+ let val = yield read(proc.stdout);
+ equal(val, arg, `Got correct value for args[${i}]`);
+ }
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 0, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_environment() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "env", "PATH", "FOO"],
+ environment: {
+ FOO: "BAR",
+ },
+ });
+
+ let path = yield read(proc.stdout);
+ let foo = yield read(proc.stdout);
+
+ equal(path, "", "Got expected $PATH value");
+ equal(foo, "BAR", "Got expected $FOO value");
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 0, "Got expected exit code");
+});
+
+
+add_task(function* test_subprocess_environmentAppend() {
+ let proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "env", "PATH", "FOO"],
+ environmentAppend: true,
+ environment: {
+ FOO: "BAR",
+ },
+ });
+
+ let path = yield read(proc.stdout);
+ let foo = yield read(proc.stdout);
+
+ equal(path, env.get("PATH"), "Got expected $PATH value");
+ equal(foo, "BAR", "Got expected $FOO value");
+
+ let {exitCode} = yield proc.wait();
+
+ equal(exitCode, 0, "Got expected exit code");
+
+ proc = yield Subprocess.call({
+ command: PYTHON,
+ arguments: ["-u", TEST_SCRIPT, "env", "PATH", "FOO"],
+ environmentAppend: true,
+ });
+
+ path = yield read(proc.stdout);
+ foo = yield read(proc.stdout);
+
+ equal(path, env.get("PATH"), "Got expected $PATH value");
+ equal(foo, "", "Got expected $FOO value");
+
+ ({exitCode} = yield proc.wait());
+
+ equal(exitCode, 0, "Got expected exit code");
+});
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/test/xpcshell/test_subprocess_getEnvironment.js
@@ -0,0 +1,17 @@
+"use strict";
+
+let env = Cc["@mozilla.org/process/environment;1"].getService(Ci.nsIEnvironment);
+
+add_task(function* test_getEnvironment() {
+ env.set("FOO", "BAR");
+
+ let environment = Subprocess.getEnvironment();
+
+ equal(environment.FOO, "BAR");
+ equal(environment.PATH, env.get("PATH"));
+
+ env.set("FOO", null);
+
+ environment = Subprocess.getEnvironment();
+ equal(environment.FOO || "", "");
+});
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/test/xpcshell/test_subprocess_pathSearch.js
@@ -0,0 +1,73 @@
+"use strict";
+
+let env = Cc["@mozilla.org/process/environment;1"].getService(Ci.nsIEnvironment);
+
+const PYTHON = env.get("PYTHON");
+
+const PYTHON_BIN = OS.Path.basename(PYTHON);
+const PYTHON_DIR = OS.Path.dirname(PYTHON);
+
+const DOES_NOT_EXIST = OS.Path.join(OS.Constants.Path.tmpDir,
+ "ThisPathDoesNotExist");
+
+const PATH_SEP = AppConstants.platform == "win" ? ";" : ":";
+
+
+add_task(function* test_pathSearchAbsolute() {
+ let env = {};
+
+ let path = yield Subprocess.pathSearch(PYTHON, env);
+ equal(path, PYTHON, "Full path resolves even with no PATH.");
+
+ env.PATH = "";
+ path = yield Subprocess.pathSearch(PYTHON, env);
+ equal(path, PYTHON, "Full path resolves even with empty PATH.");
+
+ yield Assert.rejects(
+ Subprocess.pathSearch(DOES_NOT_EXIST, env),
+ function(e) {
+ equal(e.errorCode, Subprocess.ERROR_BAD_EXECUTABLE,
+ "Got the expected error code");
+ return /File at path .* does not exist, or is not (executable|a normal file)/.test(e.message);
+ },
+ "Absolute path should throw for a nonexistent execuable");
+});
+
+
+add_task(function* test_pathSearchRelative() {
+ let env = {};
+
+ yield Assert.rejects(
+ Subprocess.pathSearch(PYTHON_BIN, env),
+ function(e) {
+ equal(e.errorCode, Subprocess.ERROR_BAD_EXECUTABLE,
+ "Got the expected error code");
+ return /Executable not found:/.test(e.message);
+ },
+ "Relative path should not be found when PATH is missing");
+
+ env.PATH = [DOES_NOT_EXIST, PYTHON_DIR].join(PATH_SEP);
+
+ let path = yield Subprocess.pathSearch(PYTHON_BIN, env);
+ equal(path, PYTHON, "Correct executable should be found in the path");
+});
+
+
+add_task({
+ skip_if: () => AppConstants.platform != "win",
+}, function* test_pathSearch_PATHEXT() {
+ ok(PYTHON_BIN.endsWith(".exe"), "Python executable must end with .exe");
+
+ const python_bin = PYTHON_BIN.slice(0, -4);
+
+ let env = {
+ PATH: PYTHON_DIR,
+ PATHEXT: [".com", ".exe", ".foobar"].join(";"),
+ };
+
+ let path = yield Subprocess.pathSearch(python_bin, env);
+ equal(path, PYTHON, "Correct executable should be found in the path, with guessed extension");
+});
+// IMPORTANT: Do not add any tests beyond this point without removing
+// the `skip_if` condition from the previous task, or it will prevent
+// all succeeding tasks from running when it does not match.
new file mode 100644
--- /dev/null
+++ b/toolkit/modules/subprocess/test/xpcshell/xpcshell.ini
@@ -0,0 +1,12 @@
+[DEFAULT]
+head = head.js
+tail =
+firefox-appdir = browser
+skip-if = os == 'android'
+subprocess = true
+support-files =
+ data_test_script.py
+
+[test_subprocess.js]
+[test_subprocess_getEnvironment.js]
+[test_subprocess_pathSearch.js]