The Tor Browser: addon-sdk/source/lib/sdk/system/child_process/subprocess.js@6474c204b198 (annotated)

addon-sdk/source/lib/sdk/system/child_process/subprocess.js@6474c204b198 (annotated)

addon-sdk/source/lib/sdk/system/child_process/subprocess.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // -*- coding: utf-8 -*-
 // vim: et:ts=4:sw=4:sts=4:ft=javascript
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "MPL"); you may not use this file
  * except in compliance with the MPL. You may obtain a copy of
  * the MPL at http://www.mozilla.org/MPL/
  *
  * Software distributed under the MPL is distributed on an "AS
  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  * implied. See the MPL for the specific language governing
  * rights and limitations under the MPL.
  *
  * The Original Code is subprocess.jsm.
  *
  * The Initial Developer of this code is Jan Gerber.
  * Portions created by Jan Gerber <j@mailb.org>
  * are Copyright (C) 2011 Jan Gerber.
  * All Rights Reserved.
  *
  * Contributor(s):
  * Patrick Brunschwig <patrick@enigmail.net>
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either the GNU General Public License Version 2 or later (the "GPL"), or
  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  * ***** END LICENSE BLOCK ***** */
 /*
  * This object allows to start a process, and read/write data to/from it
  * using stdin/stdout/stderr streams.
  * Usage example:
  *
  *  var p = subprocess.call({
  *    command:     '/bin/foo',
  *    arguments:   ['-v', 'foo'],
  *    environment: [ "XYZ=abc", "MYVAR=def" ],
  *    charset: 'UTF-8',
  *    workdir: '/home/foo',
  *    //stdin: "some value to write to stdin\nfoobar",
  *    stdin: function(stdin) {
  *      stdin.write("some value to write to stdin\nfoobar");
  *      stdin.close();
  *    },
  *    stdout: function(data) {
  *      dump("got data on stdout:" + data + "\n");
  *    },
  *    stderr: function(data) {
  *      dump("got data on stderr:" + data + "\n");
  *    },
  *    done: function(result) {
  *      dump("process terminated with " + result.exitCode + "\n");
  *    },
  *    mergeStderr: false
  *  });
  *  p.wait(); // wait for the subprocess to terminate
  *            // this will block the main thread,
  *            // only do if you can wait that long
  *
  *
  * Description of parameters:
  * --------------------------
  * Apart from <command>, all arguments are optional.
  *
  * command:     either a |nsIFile| object pointing to an executable file or a
  *              String containing the platform-dependent path to an executable
  *              file.
  *
  * arguments:   optional string array containing the arguments to the command.
  *
  * environment: optional string array containing environment variables to pass
  *              to the command. The array elements must have the form
  *              "VAR=data". Please note that if environment is defined, it
  *              replaces any existing environment variables for the subprocess.
  *
  * charset:     Output is decoded with given charset and a string is returned.
  *              If charset is undefined, "UTF-8" is used as default.
  *              To get binary data, set this to null and the returned string
  *              is not decoded in any way.
  *
  * workdir:     optional; String containing the platform-dependent path to a
  *              directory to become the current working directory of the subprocess.
  *
  * stdin:       optional input data for the process to be passed on standard
  *              input. stdin can either be a string or a function.
  *              A |string| gets written to stdin and stdin gets closed;
  *              A |function| gets passed an object with write and close function.
  *              Please note that the write() function will return almost immediately;
  *              data is always written asynchronously on a separate thread.
  *
  * stdout:      an optional function that can receive output data from the
  *              process. The stdout-function is called asynchronously; it can be
  *              called mutliple times during the execution of a process.
  *              At a minimum at each occurance of \n or \r.
  *              Please note that null-characters might need to be escaped
  *              with something like 'data.replace(/\0/g, "\\0");'.
  *
  * stderr:      an optional function that can receive stderr data from the
  *              process. The stderr-function is called asynchronously; it can be
  *              called mutliple times during the execution of a process. Please
  *              note that null-characters might need to be escaped with
  *              something like 'data.replace(/\0/g, "\\0");'.
  *              (on windows it only gets called once right now)
  *
  * done:        optional function that is called when the process has terminated.
  *              The exit code from the process available via result.exitCode. If
  *              stdout is not defined, then the output from stdout is available
  *              via result.stdout. stderr data is in result.stderr
  *
  * mergeStderr: optional boolean value. If true, stderr is merged with stdout;
  *              no data will be provided to stderr.
  *
  *
  * Description of object returned by subprocess.call(...)
  * ------------------------------------------------------
  * The object returned by subprocess.call offers a few methods that can be
  * executed:
  *
  * wait():         waits for the subprocess to terminate. It is not required to use
  *                 wait; done will be called in any case when the subprocess terminated.
  *
  * kill(hardKill): kill the subprocess. Any open pipes will be closed and
  *                 done will be called.
  *                 hardKill [ignored on Windows]:
  *                  - false: signal the process terminate (SIGTERM)
  *                  - true:  kill the process (SIGKILL)
  *
  *
  * Other methods in subprocess
  * ---------------------------
  *
  * registerDebugHandler(functionRef):   register a handler that is called to get
  *                                      debugging information
  * registerLogHandler(functionRef):     register a handler that is called to get error
  *                                      messages
  *
  * example:
  *    subprocess.registerLogHandler( function(s) { dump(s); } );
  */
 'use strict';
 const { Cc, Ci, Cu, ChromeWorker } = require("chrome");
 Cu.import("resource://gre/modules/ctypes.jsm");
 const NS_LOCAL_FILE = "@mozilla.org/file/local;1";
 const Runtime = require("sdk/system/runtime");
 const Environment = require("sdk/system/environment").env;
 const DEFAULT_ENVIRONMENT = [];
 if (Runtime.OS == "Linux" && "DISPLAY" in Environment) {
   DEFAULT_ENVIRONMENT.push("DISPLAY=" + Environment.DISPLAY);
 }
 /*
 Fake require statements to ensure worker scripts are packaged:
 require("./subprocess_worker_win.js");
 require("./subprocess_worker_unix.js");
 */
 const URL_PREFIX = module.uri.replace(/subprocess\.js/, "");
 const WORKER_URL_WIN = URL_PREFIX + "subprocess_worker_win.js";
 const WORKER_URL_UNIX = URL_PREFIX + "subprocess_worker_unix.js";
 //Windows API definitions
 if (ctypes.size_t.size == 8) {
     var WinABI = ctypes.default_abi;
 } else {
     var WinABI = ctypes.winapi_abi;
 }
 const WORD = ctypes.uint16_t;
 const DWORD = ctypes.uint32_t;
 const LPDWORD = DWORD.ptr;
 const UINT = ctypes.unsigned_int;
 const BOOL = ctypes.bool;
 const HANDLE = ctypes.size_t;
 const HWND = HANDLE;
 const HMODULE = HANDLE;
 const WPARAM = ctypes.size_t;
 const LPARAM = ctypes.size_t;
 const LRESULT = ctypes.size_t;
 const ULONG_PTR = ctypes.uintptr_t;
 const PVOID = ctypes.voidptr_t;
 const LPVOID = PVOID;
 const LPCTSTR = ctypes.jschar.ptr;
 const LPCWSTR = ctypes.jschar.ptr;
 const LPTSTR = ctypes.jschar.ptr;
 const LPSTR = ctypes.char.ptr;
 const LPCSTR = ctypes.char.ptr;
 const LPBYTE = ctypes.char.ptr;
 const CREATE_NEW_CONSOLE = 0x00000010;
 const CREATE_NO_WINDOW = 0x08000000;
 const CREATE_UNICODE_ENVIRONMENT = 0x00000400;
 const STARTF_USESHOWWINDOW = 0x00000001;
 const STARTF_USESTDHANDLES = 0x00000100;
 const SW_HIDE = 0;
 const DUPLICATE_SAME_ACCESS = 0x00000002;
 const STILL_ACTIVE = 259;
 const INFINITE = DWORD(0xFFFFFFFF);
 const WAIT_TIMEOUT = 0x00000102;
 /*
 typedef struct _SECURITY_ATTRIBUTES {
  DWORD  nLength;
  LPVOID lpSecurityDescriptor;
  BOOL   bInheritHandle;
 } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
 */
 const SECURITY_ATTRIBUTES = new ctypes.StructType("SECURITY_ATTRIBUTES", [
     {"nLength": DWORD},
     {"lpSecurityDescriptor": LPVOID},
     {"bInheritHandle": BOOL},
 ]);
 /*
 typedef struct _STARTUPINFO {
   DWORD  cb;
   LPTSTR lpReserved;
   LPTSTR lpDesktop;
   LPTSTR lpTitle;
   DWORD  dwX;
   DWORD  dwY;
   DWORD  dwXSize;
   DWORD  dwYSize;
   DWORD  dwXCountChars;
   DWORD  dwYCountChars;
   DWORD  dwFillAttribute;
   DWORD  dwFlags;
   WORD   wShowWindow;
   WORD   cbReserved2;
   LPBYTE lpReserved2;
   HANDLE hStdInput;
   HANDLE hStdOutput;
   HANDLE hStdError;
 } STARTUPINFO, *LPSTARTUPINFO;
 */
 const STARTUPINFO = new ctypes.StructType("STARTUPINFO", [
     {"cb": DWORD},
     {"lpReserved": LPTSTR},
     {"lpDesktop": LPTSTR},
     {"lpTitle": LPTSTR},
     {"dwX": DWORD},
     {"dwY": DWORD},
     {"dwXSize": DWORD},
     {"dwYSize": DWORD},
     {"dwXCountChars": DWORD},
     {"dwYCountChars": DWORD},
     {"dwFillAttribute": DWORD},
     {"dwFlags": DWORD},
     {"wShowWindow": WORD},
     {"cbReserved2": WORD},
     {"lpReserved2": LPBYTE},
     {"hStdInput": HANDLE},
     {"hStdOutput": HANDLE},
     {"hStdError": HANDLE},
 ]);
 /*
 typedef struct _PROCESS_INFORMATION {
   HANDLE hProcess;
   HANDLE hThread;
   DWORD  dwProcessId;
   DWORD  dwThreadId;
 } PROCESS_INFORMATION, *LPPROCESS_INFORMATION;
 */
 const PROCESS_INFORMATION = new ctypes.StructType("PROCESS_INFORMATION", [
     {"hProcess": HANDLE},
     {"hThread": HANDLE},
     {"dwProcessId": DWORD},
     {"dwThreadId": DWORD},
 ]);
 /*
 typedef struct _OVERLAPPED {
   ULONG_PTR Internal;
   ULONG_PTR InternalHigh;
   union {
     struct {
       DWORD Offset;
       DWORD OffsetHigh;
     };
     PVOID  Pointer;
   };
   HANDLE    hEvent;
 } OVERLAPPED, *LPOVERLAPPED;
 */
 const OVERLAPPED = new ctypes.StructType("OVERLAPPED");
 //UNIX definitions
 const pid_t = ctypes.int32_t;
 const WNOHANG = 1;
 const F_GETFD = 1;
 const F_SETFL = 4;
 const LIBNAME       = 0;
 const O_NONBLOCK    = 1;
 const RLIM_T        = 2;
 const RLIMIT_NOFILE = 3;
 function getPlatformValue(valueType) {
     if (! gXulRuntime)
         gXulRuntime = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime);
     const platformDefaults = {
         // Windows API:
         'winnt':   [ 'kernel32.dll' ],
         // Unix API:
         //            library name   O_NONBLOCK RLIM_T                RLIMIT_NOFILE
         'darwin':  [ 'libc.dylib',   0x04     , ctypes.uint64_t     , 8 ],
         'linux':   [ 'libc.so.6',    2024     , ctypes.unsigned_long, 7 ],
         'freebsd': [ 'libc.so.7',    0x04     , ctypes.int64_t      , 8 ],
         'openbsd': [ 'libc.so.61.0', 0x04     , ctypes.int64_t      , 8 ],
         'sunos':   [ 'libc.so',      0x80     , ctypes.unsigned_long, 5 ]
     }
     return platformDefaults[gXulRuntime.OS.toLowerCase()][valueType];
 }
 var gDebugFunc = null,
     gLogFunc = null,
     gXulRuntime = null;
 function LogError(s) {
     if (gLogFunc)
         gLogFunc(s);
     else
         dump(s);
 }
 function debugLog(s) {
     if (gDebugFunc)
         gDebugFunc(s);
 }
 function setTimeout(callback, timeout) {
     var timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
     timer.initWithCallback(callback, timeout, Ci.nsITimer.TYPE_ONE_SHOT);
 };
 function getBytes(data) {
   var string = '';
   data.forEach(function(x) { string += String.fromCharCode(x < 0 ? x + 256 : x) });
   return string;
 }
 function readString(data, length, charset) {
     var string = '', bytes = [];
     for(var i = 0;i < length; i++) {
         if(data[i] == 0 && charset !== null) // stop on NULL character for non-binary data
            break
         bytes.push(data[i]);
     }
     if (!bytes || bytes.length == 0)
         return string;
     if(charset === null) {
         return bytes;
     }
     return convertBytes(bytes, charset);
 }
 function convertBytes(bytes, charset) {
     var string = '';
     charset = charset || 'UTF-8';
     var unicodeConv = Cc["@mozilla.org/intl/scriptableunicodeconverter"]
                         .getService(Ci.nsIScriptableUnicodeConverter);
     try {
         unicodeConv.charset = charset;
         string = unicodeConv.convertFromByteArray(bytes, bytes.length);
     } catch (ex) {
         LogError("String conversion failed: "+ex.toString()+"\n")
         string = '';
     }
     string += unicodeConv.Finish();
     return string;
 }
 // temporary solution for removal of nsILocalFile
 function getLocalFileApi() {
   if ("nsILocalFile" in Ci) {
     return Ci.nsILocalFile;
   }
   else
     return Ci.nsIFile;
 }
 function getCommandStr(command) {
     let commandStr = null;
     if (typeof(command) == "string") {
         let file = Cc[NS_LOCAL_FILE].createInstance(getLocalFileApi());
         file.initWithPath(command);
         if (! (file.isExecutable() && file.isFile()))
             throw("File '"+command+"' is not an executable file");
         commandStr = command;
     }
     else {
         if (! (command.isExecutable() && command.isFile()))
             throw("File '"+command.path+"' is not an executable file");
         commandStr = command.path;
     }
     return commandStr;
 }
 function getWorkDir(workdir) {
     let workdirStr = null;
     if (typeof(workdir) == "string") {
         let file = Cc[NS_LOCAL_FILE].createInstance(getLocalFileApi());
         file.initWithPath(workdir);
         if (! (file.isDirectory()))
             throw("Directory '"+workdir+"' does not exist");
         workdirStr = workdir;
     }
     else if (workdir) {
         if (! workdir.isDirectory())
             throw("Directory '"+workdir.path+"' does not exist");
         workdirStr = workdir.path;
     }
     return workdirStr;
 }
 var subprocess = {
     call: function(options) {
         options.mergeStderr = options.mergeStderr || false;
         options.workdir = options.workdir ||  null;
         options.environment = options.environment || DEFAULT_ENVIRONMENT;
         if (options.arguments) {
             var args = options.arguments;
             options.arguments = [];
             args.forEach(function(argument) {
                 options.arguments.push(argument);
             });
         } else {
             options.arguments = [];
         }
         options.libc = getPlatformValue(LIBNAME);
         if (gXulRuntime.OS.substring(0, 3) == "WIN") {
             return subprocess_win32(options);
         } else {
             return subprocess_unix(options);
         }
     },
     registerDebugHandler: function(func) {
         gDebugFunc = func;
     },
     registerLogHandler: function(func) {
         gLogFunc = func;
     }
 };
 function subprocess_win32(options) {
     var kernel32dll = ctypes.open(options.libc),
         hChildProcess,
         active = true,
         done = false,
         exitCode = -1,
         child = {},
         stdinWorker = null,
         stdoutWorker = null,
         stderrWorker = null,
         pendingWriteCount = 0,
         readers = options.mergeStderr ? 1 : 2,
         stdinOpenState = 2,
         error = '',
         output = '';
     // stdin pipe states
     const OPEN = 2;
     const CLOSEABLE = 1;
     const CLOSED = 0;
     //api declarations
     /*
     BOOL WINAPI CloseHandle(
       __in  HANDLE hObject
     );
     */
     var CloseHandle = kernel32dll.declare("CloseHandle",
                                             WinABI,
                                             BOOL,
                                             HANDLE
     );
     /*
     BOOL WINAPI CreateProcess(
       __in_opt     LPCTSTR lpApplicationName,
       __inout_opt  LPTSTR lpCommandLine,
       __in_opt     LPSECURITY_ATTRIBUTES lpProcessAttributes,
       __in_opt     LPSECURITY_ATTRIBUTES lpThreadAttributes,
       __in         BOOL bInheritHandles,
       __in         DWORD dwCreationFlags,
       __in_opt     LPVOID lpEnvironment,
       __in_opt     LPCTSTR lpCurrentDirectory,
       __in         LPSTARTUPINFO lpStartupInfo,
       __out        LPPROCESS_INFORMATION lpProcessInformation
     );
      */
     var CreateProcessW = kernel32dll.declare("CreateProcessW",
                                             WinABI,
                                             BOOL,
                                             LPCTSTR,
                                             LPTSTR,
                                             SECURITY_ATTRIBUTES.ptr,
                                             SECURITY_ATTRIBUTES.ptr,
                                             BOOL,
                                             DWORD,
                                             LPVOID,
                                             LPCTSTR,
                                             STARTUPINFO.ptr,
                                             PROCESS_INFORMATION.ptr
                                          );
 //     /*
 //     BOOL WINAPI ReadFile(
 //       __in         HANDLE hFile,
 //       __out        LPVOID ReadFileBuffer,
 //       __in         DWORD nNumberOfBytesToRead,
 //       __out_opt    LPDWORD lpNumberOfBytesRead,
 //       __inout_opt  LPOVERLAPPED lpOverlapped
 //     );
 //     */
 //     var ReadFileBufferSize = 1024,
 //         ReadFileBuffer = ctypes.char.array(ReadFileBufferSize),
 //         ReadFile = kernel32dll.declare("ReadFile",
 //                                         WinABI,
 //                                         BOOL,
 //                                         HANDLE,
 //                                         ReadFileBuffer,
 //                                         DWORD,
 //                                         LPDWORD,
 //                                         OVERLAPPED.ptr
 //     );
 //
 //     /*
 //     BOOL WINAPI PeekNamedPipe(
 //       __in       HANDLE hNamedPipe,
 //       __out_opt  LPVOID lpBuffer,
 //       __in       DWORD nBufferSize,
 //       __out_opt  LPDWORD lpBytesRead,
 //       __out_opt  LPDWORD lpTotalBytesAvail,
 //       __out_opt  LPDWORD lpBytesLeftThisMessage
 //     );
 //     */
 //     var PeekNamedPipe = kernel32dll.declare("PeekNamedPipe",
 //                                         WinABI,
 //                                         BOOL,
 //                                         HANDLE,
 //                                         ReadFileBuffer,
 //                                         DWORD,
 //                                         LPDWORD,
 //                                         LPDWORD,
 //                                         LPDWORD
 //     );
 //
 //     /*
 //     BOOL WINAPI WriteFile(
 //       __in         HANDLE hFile,
 //       __in         LPCVOID lpBuffer,
 //       __in         DWORD nNumberOfBytesToWrite,
 //       __out_opt    LPDWORD lpNumberOfBytesWritten,
 //       __inout_opt  LPOVERLAPPED lpOverlapped
 //     );
 //     */
 //     var WriteFile = kernel32dll.declare("WriteFile",
 //                                         WinABI,
 //                                         BOOL,
 //                                         HANDLE,
 //                                         ctypes.char.ptr,
 //                                         DWORD,
 //                                         LPDWORD,
 //                                         OVERLAPPED.ptr
 //     );
     /*
     BOOL WINAPI CreatePipe(
       __out     PHANDLE hReadPipe,
       __out     PHANDLE hWritePipe,
       __in_opt  LPSECURITY_ATTRIBUTES lpPipeAttributes,
       __in      DWORD nSize
     );
     */
     var CreatePipe = kernel32dll.declare("CreatePipe",
                                         WinABI,
                                         BOOL,
                                         HANDLE.ptr,
                                         HANDLE.ptr,
                                         SECURITY_ATTRIBUTES.ptr,
                                         DWORD
     );
     /*
     HANDLE WINAPI GetCurrentProcess(void);
     */
     var GetCurrentProcess = kernel32dll.declare("GetCurrentProcess",
                                         WinABI,
                                         HANDLE
     );
     /*
     DWORD WINAPI GetLastError(void);
     */
     var GetLastError = kernel32dll.declare("GetLastError",
                                         WinABI,
                                         DWORD
     );
     /*
     BOOL WINAPI DuplicateHandle(
       __in   HANDLE hSourceProcessHandle,
       __in   HANDLE hSourceHandle,
       __in   HANDLE hTargetProcessHandle,
       __out  LPHANDLE lpTargetHandle,
       __in   DWORD dwDesiredAccess,
       __in   BOOL bInheritHandle,
       __in   DWORD dwOptions
     );
     */
     var DuplicateHandle = kernel32dll.declare("DuplicateHandle",
                                         WinABI,
                                         BOOL,
                                         HANDLE,
                                         HANDLE,
                                         HANDLE,
                                         HANDLE.ptr,
                                         DWORD,
                                         BOOL,
                                         DWORD
     );
     /*
     BOOL WINAPI GetExitCodeProcess(
       __in   HANDLE hProcess,
       __out  LPDWORD lpExitCode
     );
     */
     var GetExitCodeProcess = kernel32dll.declare("GetExitCodeProcess",
                                         WinABI,
                                         BOOL,
                                         HANDLE,
                                         LPDWORD
     );
     /*
     DWORD WINAPI WaitForSingleObject(
       __in  HANDLE hHandle,
       __in  DWORD dwMilliseconds
     );
     */
     var WaitForSingleObject = kernel32dll.declare("WaitForSingleObject",
                                         WinABI,
                                         DWORD,
                                         HANDLE,
                                         DWORD
     );
     /*
     BOOL WINAPI TerminateProcess(
       __in  HANDLE hProcess,
       __in  UINT uExitCode
     );
     */
     var TerminateProcess = kernel32dll.declare("TerminateProcess",
                                         WinABI,
                                         BOOL,
                                         HANDLE,
                                         UINT
     );
     //functions
     function popen(command, workdir, args, environment, child) {
         //escape arguments
         args.unshift(command);
         for (var i = 0; i < args.length; i++) {
           if (typeof args[i] != "string") { args[i] = args[i].toString(); }
           /* quote arguments with spaces */
           if (args[i].match(/\s/)) {
             args[i] = "\"" + args[i] + "\"";
           }
           /* If backslash is followed by a quote, double it */
           args[i] = args[i].replace(/\\\"/g, "\\\\\"");
         }
         command = args.join(' ');
         environment = environment || [];
         if(environment.length) {
             //An environment block consists of
             //a null-terminated block of null-terminated strings.
             //Using CREATE_UNICODE_ENVIRONMENT so needs to be jschar
             environment = ctypes.jschar.array()(environment.join('\0') + '\0');
         } else {
             environment = null;
         }
         var hOutputReadTmp = new HANDLE(),
             hOutputRead = new HANDLE(),
             hOutputWrite = new HANDLE();
         var hErrorRead = new HANDLE(),
             hErrorReadTmp = new HANDLE(),
             hErrorWrite = new HANDLE();
         var hInputRead = new HANDLE(),
             hInputWriteTmp = new HANDLE(),
             hInputWrite = new HANDLE();
         // Set up the security attributes struct.
         var sa = new SECURITY_ATTRIBUTES();
         sa.nLength = SECURITY_ATTRIBUTES.size;
         sa.lpSecurityDescriptor = null;
         sa.bInheritHandle = true;
         // Create output pipe.
         if(!CreatePipe(hOutputReadTmp.address(), hOutputWrite.address(), sa.address(), 0))
             LogError('CreatePipe hOutputReadTmp failed');
         if(options.mergeStderr) {
           // Create a duplicate of the output write handle for the std error
           // write handle. This is necessary in case the child application
           // closes one of its std output handles.
           if (!DuplicateHandle(GetCurrentProcess(), hOutputWrite,
                                GetCurrentProcess(), hErrorWrite.address(), 0,
                                true, DUPLICATE_SAME_ACCESS))
              LogError("DuplicateHandle hOutputWrite failed");
         } else {
             // Create error pipe.
             if(!CreatePipe(hErrorReadTmp.address(), hErrorWrite.address(), sa.address(), 0))
                 LogError('CreatePipe hErrorReadTmp failed');
         }
         // Create input pipe.
         if (!CreatePipe(hInputRead.address(),hInputWriteTmp.address(),sa.address(), 0))
             LogError("CreatePipe hInputRead failed");
         // Create new output/error read handle and the input write handles. Set
         // the Properties to FALSE. Otherwise, the child inherits the
         // properties and, as a result, non-closeable handles to the pipes
         // are created.
         if (!DuplicateHandle(GetCurrentProcess(), hOutputReadTmp,
                              GetCurrentProcess(),
                              hOutputRead.address(), // Address of new handle.
 , false, // Make it uninheritable.
                              DUPLICATE_SAME_ACCESS))
              LogError("DupliateHandle hOutputReadTmp failed");
         if(!options.mergeStderr) {
             if (!DuplicateHandle(GetCurrentProcess(), hErrorReadTmp,
                              GetCurrentProcess(),
                              hErrorRead.address(), // Address of new handle.
 , false, // Make it uninheritable.
                              DUPLICATE_SAME_ACCESS))
              LogError("DupliateHandle hErrorReadTmp failed");
         }
         if (!DuplicateHandle(GetCurrentProcess(), hInputWriteTmp,
                              GetCurrentProcess(),
                              hInputWrite.address(), // Address of new handle.
 , false, // Make it uninheritable.
                              DUPLICATE_SAME_ACCESS))
           LogError("DupliateHandle hInputWriteTmp failed");
         // Close inheritable copies of the handles.
         if (!CloseHandle(hOutputReadTmp)) LogError("CloseHandle hOutputReadTmp failed");
         if(!options.mergeStderr)
             if (!CloseHandle(hErrorReadTmp)) LogError("CloseHandle hErrorReadTmp failed");
         if (!CloseHandle(hInputWriteTmp)) LogError("CloseHandle failed");
         var pi = new PROCESS_INFORMATION();
         var si = new STARTUPINFO();
         si.cb = STARTUPINFO.size;
         si.dwFlags = STARTF_USESTDHANDLES;
         si.hStdInput  = hInputRead;
         si.hStdOutput = hOutputWrite;
         si.hStdError  = hErrorWrite;
         // Launch the process
         if(!CreateProcessW(null,            // executable name
                            command,         // command buffer
                            null,            // process security attribute
                            null,            // thread security attribute
                            true,            // inherits system handles
                            CREATE_UNICODE_ENVIRONMENT|CREATE_NO_WINDOW, // process flags
                            environment,     // envrionment block
                            workdir,          // set as current directory
                            si.address(),    // (in) startup information
                            pi.address()     // (out) process information
         ))
             throw("Fatal - Could not launch subprocess '"+command+"'");
         // Close any unnecessary handles.
         if (!CloseHandle(pi.hThread))
             LogError("CloseHandle pi.hThread failed");
         // Close pipe handles (do not continue to modify the parent).
         // You need to make sure that no handles to the write end of the
         // output pipe are maintained in this process or else the pipe will
         // not close when the child process exits and the ReadFile will hang.
         if (!CloseHandle(hInputRead)) LogError("CloseHandle hInputRead failed");
         if (!CloseHandle(hOutputWrite)) LogError("CloseHandle hOutputWrite failed");
         if (!CloseHandle(hErrorWrite)) LogError("CloseHandle hErrorWrite failed");
         //return values
         child.stdin = hInputWrite;
         child.stdout = hOutputRead;
         child.stderr = options.mergeStderr ? undefined : hErrorRead;
         child.process = pi.hProcess;
         return pi.hProcess;
     }
     /*
      * createStdinWriter ()
      *
      * Create a ChromeWorker object for writing data to the subprocess' stdin
      * pipe. The ChromeWorker object lives on a separate thread; this avoids
      * internal deadlocks.
      */
     function createStdinWriter() {
         debugLog("Creating new stdin worker\n");
         stdinWorker = new ChromeWorker(WORKER_URL_WIN);
         stdinWorker.onmessage = function(event) {
             switch(event.data) {
             case "WriteOK":
                 pendingWriteCount--;
                 debugLog("got OK from stdinWorker - remaining count: "+pendingWriteCount+"\n");
                 break;
             case "ClosedOK":
                 stdinOpenState = CLOSED;
                 debugLog("Stdin pipe closed\n");
                 break;
             default:
                 debugLog("got msg from stdinWorker: "+event.data+"\n");
             }
         }
         stdinWorker.onerror = function(error) {
             pendingWriteCount--;
             LogError("got error from stdinWorker: "+error.message+"\n");
         }
         stdinWorker.postMessage({msg: "init", libc: options.libc});
     }
     /*
      * writeStdin()
      * @data: String containing the data to write
      *
      * Write data to the subprocess' stdin (equals to sending a request to the
      * ChromeWorker object to write the data).
      */
     function writeStdin(data) {
         ++pendingWriteCount;
         debugLog("sending "+data.length+" bytes to stdinWorker\n");
         var pipePtr = parseInt(ctypes.cast(child.stdin.address(), ctypes.uintptr_t).value);
         stdinWorker.postMessage({
                 msg: 'write',
                 pipe: pipePtr,
                 data: data
             });
     }
     /*
      * closeStdinHandle()
      *
      * Close the stdin pipe, either directly or by requesting the ChromeWorker to
      * close the pipe. The ChromeWorker will only close the pipe after the last write
      * request process is done.
      */
     function closeStdinHandle() {
         debugLog("trying to close stdin\n");
         if (stdinOpenState != OPEN) return;
         stdinOpenState = CLOSEABLE;
         if (stdinWorker) {
             debugLog("sending close stdin to worker\n");
             var pipePtr = parseInt(ctypes.cast(child.stdin.address(), ctypes.uintptr_t).value);
             stdinWorker.postMessage({
                 msg: 'close',
                 pipe: pipePtr
             });
         }
         else {
             stdinOpenState = CLOSED;
             debugLog("Closing Stdin\n");
             CloseHandle(child.stdin) || LogError("CloseHandle hInputWrite failed");
         }
     }
     /*
      * createReader(pipe, name)
      *
      * @pipe: handle to the pipe
      * @name: String containing the pipe name (stdout or stderr)
      *
      * Create a ChromeWorker object for reading data asynchronously from
      * the pipe (i.e. on a separate thread), and passing the result back to
      * the caller.
      */
     function createReader(pipe, name, callbackFunc) {
         var worker = new ChromeWorker(WORKER_URL_WIN);
         worker.onmessage = function(event) {
             switch(event.data.msg) {
             case "data":
                 debugLog("got "+event.data.count+" bytes from "+name+"\n");
                 var data = '';
                 if (options.charset === null) {
                     data = getBytes(event.data.data);
                 }
                 else {
                     try {
                         data = convertBytes(event.data.data, options.charset);
                     }
                     catch(ex) {
                         console.warn("error decoding output: " + ex);
                         data = getBytes(event.data.data);
                     }
                 }
                 callbackFunc(data);
                 break;
             case "done":
                 debugLog("Pipe "+name+" closed\n");
                 --readers;
                 if (readers == 0) cleanup();
                 break;
             default:
                 debugLog("Got msg from "+name+": "+event.data.data+"\n");
             }
         }
         worker.onerror = function(errorMsg) {
             LogError("Got error from "+name+": "+errorMsg.message);
         }
         var pipePtr = parseInt(ctypes.cast(pipe.address(), ctypes.uintptr_t).value);
         worker.postMessage({
                 msg: 'read',
                 pipe: pipePtr,
                 libc: options.libc,
                 charset: options.charset === null ? "null" : options.charset,
                 name: name
             });
         return worker;
     }
     /*
      * readPipes()
      *
      * Open the pipes for reading from stdout and stderr
      */
     function readPipes() {
         stdoutWorker = createReader(child.stdout, "stdout", function (data) {
             if(options.stdout) {
                 setTimeout(function() {
                     options.stdout(data);
                 }, 0);
             } else {
                 output += data;
             }
         });
         if (!options.mergeStderr) stderrWorker = createReader(child.stderr, "stderr", function (data) {
             if(options.stderr) {
                 setTimeout(function() {
                     options.stderr(data);
                 }, 0);
             } else {
                 error += data;
             }
         });
     }
     /*
      * cleanup()
      *
      * close stdin if needed, get the exit code from the subprocess and invoke
      * the caller's done() function.
      *
      * Note: because stdout() and stderr() are called using setTimeout, we need to
      * do the same here in order to guarantee the message sequence.
      */
     function cleanup() {
         debugLog("Cleanup called\n");
         if(active) {
             active = false;
             closeStdinHandle(); // should only be required in case of errors
             var exit = new DWORD();
             GetExitCodeProcess(child.process, exit.address());
             exitCode = exit.value;
             if (stdinWorker)
                 stdinWorker.postMessage({msg: 'stop'})
             setTimeout(function _done() {
                 if (options.done) {
                     try {
                         options.done({
                             exitCode: exitCode,
                             stdout: output,
                             stderr: error,
                         });
                     }
                     catch (ex) {
                         // prevent from blocking if options.done() throws an error
                         done = true;
                         throw ex;
                     }
                 }
                 done = true;
             }, 0);
             kernel32dll.close();
         }
     }
     var cmdStr = getCommandStr(options.command);
     var workDir = getWorkDir(options.workdir);
     //main
     hChildProcess = popen(cmdStr, workDir, options.arguments, options.environment, child);
     readPipes();
     if (options.stdin) {
        createStdinWriter();
         if(typeof(options.stdin) == 'function') {
             try {
                 options.stdin({
                     write: function(data) {
                         writeStdin(data);
                     },
                     close: function() {
                         closeStdinHandle();
                     }
                 });
             }
             catch (ex) {
                 // prevent from failing if options.stdin() throws an exception
                 closeStdinHandle();
                 throw ex;
             }
         } else {
             writeStdin(options.stdin);
             closeStdinHandle();
         }
     }
     else
         closeStdinHandle();
     return {
         kill: function(hardKill) {
             // hardKill is currently ignored on Windows
             var r = !!TerminateProcess(child.process, 255);
             cleanup(-1);
             return r;
         },
         wait: function() {
             // wait for async operations to complete
             var thread = Cc['@mozilla.org/thread-manager;1'].getService(Ci.nsIThreadManager).currentThread;
             while (!done) thread.processNextEvent(true);
             return exitCode;
         }
     }
 }
 function subprocess_unix(options) {
     // stdin pipe states
     const OPEN = 2;
     const CLOSEABLE = 1;
     const CLOSED = 0;
     var libc = ctypes.open(options.libc),
         active = true,
         done = false,
         exitCode = -1,
         workerExitCode = 0,
         child = {},
         pid = -1,
         stdinWorker = null,
         stdoutWorker = null,
         stderrWorker = null,
         pendingWriteCount = 0,
         readers = options.mergeStderr ? 1 : 2,
         stdinOpenState = OPEN,
         error = '',
         output = '';
     //api declarations
     //pid_t fork(void);
     var fork = libc.declare("fork",
                          ctypes.default_abi,
                          pid_t
     );
     //NULL terminated array of strings, argv[0] will be command >> + 2
     var argv = ctypes.char.ptr.array(options.arguments.length + 2);
     var envp = ctypes.char.ptr.array(options.environment.length + 1);
     // posix_spawn_file_actions_t is a complex struct that may be different on
     // each platform. We do not care about its attributes, we don't need to
     // get access to them, but we do need to allocate the right amount
     // of memory for it.
     // At 2013/10/28, its size was 80 on linux, but better be safe (and larger),
     // than crash when posix_spawn_file_actions_init fill `action` with zeros.
     // Use `gcc sizeof_fileaction.c && ./a.out` to check that size.
     var posix_spawn_file_actions_t = ctypes.uint8_t.array(100);
     //int posix_spawn(pid_t *restrict pid, const char *restrict path,
     //   const posix_spawn_file_actions_t *file_actions,
     //   const posix_spawnattr_t *restrict attrp,
     //   char *const argv[restrict], char *const envp[restrict]);
     var posix_spawn = libc.declare("posix_spawn",
                          ctypes.default_abi,
                          ctypes.int,
                          pid_t.ptr,
                          ctypes.char.ptr,
                          posix_spawn_file_actions_t.ptr,
                          ctypes.voidptr_t,
                          argv,
                          envp
     );
     //int posix_spawn_file_actions_init(posix_spawn_file_actions_t *file_actions);
     var posix_spawn_file_actions_init = libc.declare("posix_spawn_file_actions_init",
                          ctypes.default_abi,
                          ctypes.int,
                          posix_spawn_file_actions_t.ptr
     );
     //int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *file_actions);
     var posix_spawn_file_actions_destroy = libc.declare("posix_spawn_file_actions_destroy",
                          ctypes.default_abi,
                          ctypes.int,
                          posix_spawn_file_actions_t.ptr
     );
     // int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *
     //                                      file_actions, int fildes, int newfildes);
     var posix_spawn_file_actions_adddup2 = libc.declare("posix_spawn_file_actions_adddup2",
                          ctypes.default_abi,
                          ctypes.int,
                          posix_spawn_file_actions_t.ptr,
                          ctypes.int,
                          ctypes.int
     );
     // int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *
     //                                       file_actions, int fildes);
     var posix_spawn_file_actions_addclose = libc.declare("posix_spawn_file_actions_addclose",
                          ctypes.default_abi,
                          ctypes.int,
                          posix_spawn_file_actions_t.ptr,
                          ctypes.int
     );
     //int pipe(int pipefd[2]);
     var pipefd = ctypes.int.array(2);
     var pipe = libc.declare("pipe",
                          ctypes.default_abi,
                          ctypes.int,
                          pipefd
     );
     //int close(int fd);
     var close = libc.declare("close",
                           ctypes.default_abi,
                           ctypes.int,
                           ctypes.int
     );
     //pid_t waitpid(pid_t pid, int *status, int options);
     var waitpid = libc.declare("waitpid",
                           ctypes.default_abi,
                           pid_t,
                           pid_t,
                           ctypes.int.ptr,
                           ctypes.int
     );
     //int kill(pid_t pid, int sig);
     var kill = libc.declare("kill",
                           ctypes.default_abi,
                           ctypes.int,
                           pid_t,
                           ctypes.int
     );
     //int read(int fd, void *buf, size_t count);
     var bufferSize = 1024;
     var buffer = ctypes.char.array(bufferSize);
     var read = libc.declare("read",
                           ctypes.default_abi,
                           ctypes.int,
                           ctypes.int,
                           buffer,
                           ctypes.int
     );
     //ssize_t write(int fd, const void *buf, size_t count);
     var write = libc.declare("write",
                           ctypes.default_abi,
                           ctypes.int,
                           ctypes.int,
                           ctypes.char.ptr,
                           ctypes.int
     );
     //int chdir(const char *path);
     var chdir = libc.declare("chdir",
                           ctypes.default_abi,
                           ctypes.int,
                           ctypes.char.ptr
     );
     //int fcntl(int fd, int cmd, ... /* arg */ );
     var fcntl = libc.declare("fcntl",
                           ctypes.default_abi,
                           ctypes.int,
                           ctypes.int,
                           ctypes.int,
                           ctypes.int
     );
     function popen(command, workdir, args, environment, child) {
         var _in,
             _out,
             _err,
             pid,
             rc;
         _in = new pipefd();
         _out = new pipefd();
         if(!options.mergeStderr)
             _err = new pipefd();
         var _args = argv();
         args.unshift(command);
         for(var i=0;i<args.length;i++) {
             _args[i] = ctypes.char.array()(args[i]);
         }
         var _envp = envp();
         for(var i=0;i<environment.length;i++) {
             _envp[i] = ctypes.char.array()(environment[i]);
             // LogError(_envp);
         }
         rc = pipe(_in);
         if (rc < 0) {
             return -1;
         }
         rc = pipe(_out);
         fcntl(_out[0], F_SETFL, getPlatformValue(O_NONBLOCK));
         if (rc < 0) {
             close(_in[0]);
             close(_in[1]);
             return -1
         }
         if(!options.mergeStderr) {
             rc = pipe(_err);
             fcntl(_err[0], F_SETFL, getPlatformValue(O_NONBLOCK));
             if (rc < 0) {
                 close(_in[0]);
                 close(_in[1]);
                 close(_out[0]);
                 close(_out[1]);
                 return -1
             }
         }
         let STDIN_FILENO = 0;
         let STDOUT_FILENO = 1;
         let STDERR_FILENO = 2;
         let action = posix_spawn_file_actions_t();
         posix_spawn_file_actions_init(action.address());
         posix_spawn_file_actions_adddup2(action.address(), _in[0], STDIN_FILENO);
         posix_spawn_file_actions_addclose(action.address(), _in[1]);
         posix_spawn_file_actions_addclose(action.address(), _in[0]);
         posix_spawn_file_actions_adddup2(action.address(), _out[1], STDOUT_FILENO);
         posix_spawn_file_actions_addclose(action.address(), _out[1]);
         posix_spawn_file_actions_addclose(action.address(), _out[0]);
         if (!options.mergeStderr) {
           posix_spawn_file_actions_adddup2(action.address(), _err[1], STDERR_FILENO);
           posix_spawn_file_actions_addclose(action.address(), _err[1]);
           posix_spawn_file_actions_addclose(action.address(), _err[0]);
         }
         // posix_spawn doesn't support setting a custom workdir for the child,
         // so change the cwd in the parent process before launching the child process.
         if (workdir) {
           if (chdir(workdir) < 0) {
             throw new Error("Unable to change workdir before launching child process");
           }
         }
         closeOtherFds(action, _in[1], _out[0], options.mergeStderr ? undefined : _err[0]);
         let id = pid_t(0);
         let rv = posix_spawn(id.address(), command, action.address(), null, _args, _envp);
         posix_spawn_file_actions_destroy(action.address());
         if (rv != 0) {
           // we should not really end up here
           if(!options.mergeStderr) {
             close(_err[0]);
             close(_err[1]);
           }
           close(_out[0]);
           close(_out[1]);
           close(_in[0]);
           close(_in[1]);
           throw new Error("Fatal - failed to create subprocess '"+command+"'");
         }
         pid = id.value;
         close(_in[0]);
         close(_out[1]);
         if (!options.mergeStderr)
           close(_err[1]);
         child.stdin  = _in[1];
         child.stdout = _out[0];
         child.stderr = options.mergeStderr ? undefined : _err[0];
         child.pid = pid;
         return pid;
     }
     // close any file descriptors that are not required for the process
     function closeOtherFds(action, fdIn, fdOut, fdErr) {
         // Unfortunately on mac, any fd registered in posix_spawn_file_actions_addclose
         // that can't be closed correctly will make posix_spawn fail...
         // Even if we ensure registering only still opened fds.
         if (gXulRuntime.OS == "Darwin")
             return;
         var maxFD = 256; // arbitrary max
         var rlim_t = getPlatformValue(RLIM_T);
         const RLIMITS = new ctypes.StructType("RLIMITS", [
             {"rlim_cur": rlim_t},
             {"rlim_max": rlim_t}
         ]);
         try {
             var getrlimit = libc.declare("getrlimit",
                                   ctypes.default_abi,
                                   ctypes.int,
                                   ctypes.int,
                                   RLIMITS.ptr
             );
             var rl = new RLIMITS();
             if (getrlimit(getPlatformValue(RLIMIT_NOFILE), rl.address()) == 0) {
                 maxFD = rl.rlim_cur;
             }
             debugLog("getlimit: maxFD="+maxFD+"\n");
         }
         catch(ex) {
             debugLog("getrlimit: no such function on this OS\n");
             debugLog(ex.toString());
         }
         // close any file descriptors
         // fd's 0-2 are already closed
         for (var i = 3; i < maxFD; i++) {
             if (i != fdIn && i != fdOut && i != fdErr && fcntl(i, F_GETFD, -1) >= 0) {
                 posix_spawn_file_actions_addclose(action.address(), i);
             }
         }
     }
     /*
      * createStdinWriter ()
      *
      * Create a ChromeWorker object for writing data to the subprocess' stdin
      * pipe. The ChromeWorker object lives on a separate thread; this avoids
      * internal deadlocks.
      */
     function createStdinWriter() {
         debugLog("Creating new stdin worker\n");
         stdinWorker = new ChromeWorker(WORKER_URL_UNIX);
         stdinWorker.onmessage = function(event) {
             switch (event.data.msg) {
             case "info":
                 switch(event.data.data) {
                 case "WriteOK":
                     pendingWriteCount--;
                     debugLog("got OK from stdinWorker - remaining count: "+pendingWriteCount+"\n");
                     break;
                 case "ClosedOK":
                     stdinOpenState = CLOSED;
                     debugLog("Stdin pipe closed\n");
                     break;
                 default:
                     debugLog("got msg from stdinWorker: "+event.data.data+"\n");
                 }
                 break;
             case "debug":
                 debugLog("stdinWorker: "+event.data.data+"\n");
                 break;
             case "error":
                 LogError("got error from stdinWorker: "+event.data.data+"\n");
                 pendingWriteCount = 0;
                 stdinOpenState = CLOSED;
             }
         }
         stdinWorker.onerror = function(error) {
             pendingWriteCount = 0;
             closeStdinHandle();
             LogError("got error from stdinWorker: "+error.message+"\n");
         }
         stdinWorker.postMessage({msg: "init", libc: options.libc});
     }
     /*
      * writeStdin()
      * @data: String containing the data to write
      *
      * Write data to the subprocess' stdin (equals to sending a request to the
      * ChromeWorker object to write the data).
      */
     function writeStdin(data) {
         if (stdinOpenState == CLOSED) return; // do not write to closed pipes
         ++pendingWriteCount;
         debugLog("sending "+data.length+" bytes to stdinWorker\n");
         var pipe = parseInt(child.stdin);
         stdinWorker.postMessage({
             msg: 'write',
             pipe: pipe,
             data: data
         });
     }
     /*
      * closeStdinHandle()
      *
      * Close the stdin pipe, either directly or by requesting the ChromeWorker to
      * close the pipe. The ChromeWorker will only close the pipe after the last write
      * request process is done.
      */
     function closeStdinHandle() {
         debugLog("trying to close stdin\n");
         if (stdinOpenState != OPEN) return;
         stdinOpenState = CLOSEABLE;
         if (stdinWorker) {
             debugLog("sending close stdin to worker\n");
             var pipePtr = parseInt(child.stdin);
             stdinWorker.postMessage({
                 msg: 'close',
                 pipe: pipePtr
             });
         }
         else {
             stdinOpenState = CLOSED;
             debugLog("Closing Stdin\n");
             close(child.stdin) && LogError("CloseHandle stdin failed");
         }
     }
     /*
      * createReader(pipe, name)
      *
      * @pipe: handle to the pipe
      * @name: String containing the pipe name (stdout or stderr)
      * @callbackFunc: function to be called with the read data
      *
      * Create a ChromeWorker object for reading data asynchronously from
      * the pipe (i.e. on a separate thread), and passing the result back to
      * the caller.
      *
      */
     function createReader(pipe, name, callbackFunc) {
         var worker = new ChromeWorker(WORKER_URL_UNIX);
         worker.onmessage = function(event) {
             switch(event.data.msg) {
             case "data":
                 debugLog("got "+event.data.count+" bytes from "+name+"\n");
                 var data = '';
                 if (options.charset === null) {
                     data = getBytes(event.data.data);
                 }
                 else {
                     try {
                         data = convertBytes(event.data.data, options.charset);
                     }
                     catch(ex) {
                         console.warn("error decoding output: " + ex);
                         data = getBytes(event.data.data);
                     }
                 }
                 callbackFunc(data);
                 break;
             case "done":
                 debugLog("Pipe "+name+" closed\n");
                 if (event.data.data > 0) workerExitCode = event.data.data;
                 --readers;
                 if (readers == 0) cleanup();
                 break;
             default:
                 debugLog("Got msg from "+name+": "+event.data.data+"\n");
             }
         }
         worker.onerror = function(error) {
             LogError("Got error from "+name+": "+error.message);
         }
         worker.postMessage({
                 msg: 'read',
                 pipe: pipe,
                 pid: pid,
                 libc: options.libc,
                 charset: options.charset === null ? "null" : options.charset,
                 name: name
             });
         return worker;
     }
     /*
      * readPipes()
      *
      * Open the pipes for reading from stdout and stderr
      */
     function readPipes() {
         stdoutWorker = createReader(child.stdout, "stdout", function (data) {
             if(options.stdout) {
                 setTimeout(function() {
                     options.stdout(data);
                 }, 0);
             } else {
                 output += data;
             }
         });
         if (!options.mergeStderr) stderrWorker = createReader(child.stderr, "stderr", function (data) {
             if(options.stderr) {
                 setTimeout(function() {
                     options.stderr(data);
                  }, 0);
             } else {
                 error += data;
             }
         });
     }
     function cleanup() {
         debugLog("Cleanup called\n");
         if(active) {
             active = false;
             closeStdinHandle(); // should only be required in case of errors
             var result, status = ctypes.int();
             result = waitpid(child.pid, status.address(), 0);
             if (result > 0)
                 exitCode = status.value
             else
                 if (workerExitCode >= 0)
                     exitCode = workerExitCode
                 else
                     exitCode = status.value;
             if (stdinWorker)
                 stdinWorker.postMessage({msg: 'stop'})
             setTimeout(function _done() {
                 if (options.done) {
                     try {
                         options.done({
                             exitCode: exitCode,
                             stdout: output,
                             stderr: error,
                         });
                     }
                     catch(ex) {
                         // prevent from blocking if options.done() throws an error
                         done = true;
                         throw ex;
                     }
                 }
                 done = true;
             }, 0);
             libc.close();
         }
     }
     //main
     var cmdStr = getCommandStr(options.command);
     var workDir = getWorkDir(options.workdir);
     child = {};
     pid = popen(cmdStr, workDir, options.arguments, options.environment, child);
     debugLog("subprocess started; got PID "+pid+"\n");
     readPipes();
     if (options.stdin) {
         createStdinWriter();
         if(typeof(options.stdin) == 'function') {
             try {
                 options.stdin({
                     write: function(data) {
                         writeStdin(data);
                     },
                     close: function() {
                         closeStdinHandle();
                     }
                 });
             }
             catch(ex) {
                 // prevent from failing if options.stdin() throws an exception
                 closeStdinHandle();
                 throw ex;
             }
         } else {
             writeStdin(options.stdin);
             closeStdinHandle();
         }
     }
     return {
         wait: function() {
             // wait for async operations to complete
             var thread = Cc['@mozilla.org/thread-manager;1'].getService(Ci.nsIThreadManager).currentThread;
             while (! done) thread.processNextEvent(true)
             return exitCode;
         },
         kill: function(hardKill) {
             var rv = kill(pid, (hardKill ? 9: 15));
             cleanup(-1);
             return rv;
         },
         pid: pid
     }
 }
 module.exports = subprocess;