'use strict';

const net = require('net');

const dgram = require('dgram');

const util = require('util');

const assert = require('assert');

const uv = process.binding('uv');

const { Process } = process.binding('process_wrap');

const { WriteWrap } = process.binding('stream_wrap');

const { TTY } = process.binding('tty_wrap');

const { TCP } = process.binding('tcp_wrap');

const { UDP } = process.binding('udp_wrap');

const MAX_HANDLE_RETRANSMISSIONS = 3;

// this object contain function to convert TCP objects to native handle objects

// and back again.

const handleConversion = {

'net.Native': {

simultaneousAccepts: true,

return handle;

},

got: function(message, handle, emit) {

emit(handle);

}

},

'net.Server': {

simultaneousAccepts: true,

return server._handle;

},

got: function(message, handle, emit) {

var server = new net.Server();

server.listen(handle, function() {

emit(server);

});

}

},

'net.Socket': {

if (!socket._handle)

return;

// if the socket was created by net.Server

if (socket.server) {

// the slave should keep track of the socket

message.key = socket.server._connectionKey;

var socketList = getSocketList('send', this, message.key);

// the server should no longer expose a .connection property

// and when asked to close it should query the socket status from

// the slaves

if (firstTime) socket.server._setupSlave(socketList);

// Act like socket is detached

if (!options.keepOpen)

socket.server._connections--;

}

var handle = socket._handle;

// remove handle from socket object, it will be closed when the socket

// will be sent

socket._handle = null;

}

return handle;

},

// Store the handle after successfully sending it, so it can be closed

// when the NODE_HANDLE_ACK is received. If the handle could not be sent,

// just close it.

if (handle && !options.keepOpen) {

if (target) {

// processed one at a time: handles are stored in _handleQueue while

// waiting for the NODE_HANDLE_ACK of the current passing handle.

assert(!target._pendingMessage);

target._pendingMessage =

{ callback, message, handle, options, retransmissions: 0 };

} else {

handle.close();

}

}

},

got: function(message, handle, emit) {

socket.readable = socket.writable = true;

// if the socket was created by net.Server we will track the socket

if (message.key) {

// add socket to connections list

var socketList = getSocketList('got', this, message.key);

socketList.add({

socket: socket

});

}

emit(socket);

}

},

'dgram.Native': {

simultaneousAccepts: false,

return handle;

},

got: function(message, handle, emit) {

emit(handle);

}

},

'dgram.Socket': {

simultaneousAccepts: false,

message.dgramType = socket.type;

return socket._handle;

},

got: function(message, handle, emit) {

var socket = new dgram.Socket(message.dgramType);

socket.bind(handle, function() {

emit(socket);

});

}

}

};

function ChildProcess() {

EventEmitter.call(this);

this._closesNeeded = 1;

this._closesGot = 0;

this.connected = false;

this.signalCode = null;

this.exitCode = null;

this.killed = false;

this.spawnfile = null;

this._handle = new Process();

this._handle.owner = this;

}

if (this.stdin) {

this.stdin.destroy();

}

this._handle.close();

this._handle = null;

if (exitCode < 0) {

var syscall = this.spawnfile ? 'spawn ' + this.spawnfile : 'spawn';

const err = errnoException(exitCode, syscall);

if (this.spawnfile)

err.path = this.spawnfile;

err.spawnargs = this.spawnargs.slice(1);

this.emit('error', err);

}

// if any of the stdio streams have not been touched,

// then pull all the data through so that it can get the

// eof and emit a 'close' event.

// Do it on nextTick so that the user has one last chance

// to consume the output, if for example they only want to

// start reading the data once the process exits.

};

}

util.inherits(ChildProcess, EventEmitter);

function flushStdio(subprocess) {

const stdio = subprocess.stdio;

if (stdio == null) return;

for (var i = 0; i < stdio.length; i++) {

const stream = stdio[i];

}

function createSocket(pipe, readable) {

}

function getHandleWrapType(stream) {

if (stream instanceof Pipe) return 'pipe';

if (stream instanceof TTY) return 'tty';

if (stream instanceof TCP) return 'tcp';

if (stream instanceof UDP) return 'udp';

return false;

}

function closePendingHandle(target) {

target._pendingMessage.handle.close();

target._pendingMessage = null;

}

ChildProcess.prototype.spawn = function(options) {

var ipc;

var ipcFd;

if (options === null || typeof options !== 'object')

throw new TypeError('"options" must be an object');

// If no `stdio` option was given - use default

var stdio = options.stdio || 'pipe';

stdio = _validateStdio(stdio, false);

ipc = stdio.ipc;

ipcFd = stdio.ipcFd;

stdio = options.stdio = stdio.stdio;

if (ipc !== undefined) {

// Let child process know about opened IPC channel

if (options.envPairs === undefined)

options.envPairs = [];

else if (!Array.isArray(options.envPairs))

throw new TypeError('"envPairs" must be an array');

options.envPairs.push('NODE_CHANNEL_FD=' + ipcFd);

}

if (typeof options.file === 'string')

this.spawnfile = options.file;

else

throw new TypeError('"file" must be a string');

if (Array.isArray(options.args))

this.spawnargs = options.args;

else if (options.args === undefined)

this.spawnargs = [];

else

throw new TypeError('"args" must be an array');

var err = this._handle.spawn(options);

// Run-time errors should emit an error, not throw an exception.

if (err === uv.UV_EAGAIN ||

err === uv.UV_EMFILE ||

err === uv.UV_ENFILE ||

err === uv.UV_ENOENT) {

// There is no point in continuing when we've hit EMFILE or ENFILE

// because we won't be able to set up the stdio file descriptors.

// It's kind of silly that the de facto spec for ENOENT (the test suite)

// mandates that stdio _is_ set up, even if there is no process on the

// receiving end, but it is what it is.

if (err !== uv.UV_ENOENT) return err;

} else if (err) {

// Close all opened fds on error

for (i = 0; i < stdio.length; i++) {

const stream = stdio[i];

if (stream.type === 'pipe') {

stream.handle.close();

this._handle.close();

this._handle = null;

throw errnoException(err, 'spawn');

}

this.pid = this._handle.pid;

for (i = 0; i < stdio.length; i++) {

const stream = stdio[i];

if (stream.type === 'ignore') continue;

}

// when i === 0 - we're dealing with stdin

// (which is the only one writable pipe)

if (i > 0 && this.pid !== 0) {

this._closesNeeded++;

stream.socket.on('close', () => {

maybeClose(this);

});

}

}

this.stdin = stdio.length >= 1 && stdio[0].socket !== undefined ?

this.stdio = [];

for (i = 0; i < stdio.length; i++)

this.stdio.push(stdio[i].socket === undefined ? null : stdio[i].socket);

// Add .send() method and start listening for IPC data

if (ipc !== undefined) setupChannel(this, ipc);

return err;

};

function onErrorNT(self, err) {

self._handle.onexit(err);

}

ChildProcess.prototype.kill = function(sig) {

const signal = sig === 0 ? sig :

convertToValidSignal(sig === undefined ? 'SIGTERM' : sig);

if (this._handle) {

var err = this._handle.kill(signal);

if (err === 0) {

/* Success. */

this.killed = true;

return true;

}

if (err === uv.UV_ESRCH) {

/* Already dead. */

} else if (err === uv.UV_EINVAL || err === uv.UV_ENOSYS) {

/* The underlying platform doesn't support this signal. */

throw errnoException(err, 'kill');

} else {

/* Other error, almost certainly EPERM. */

this.emit('error', errnoException(err, 'kill'));

}

}

/* Kill didn't succeed. */

return false;

};

ChildProcess.prototype.ref = function() {

if (this._handle) this._handle.ref();

};

ChildProcess.prototype.unref = function() {

if (this._handle) this._handle.unref();

};

class Control extends EventEmitter {

constructor(channel) {

super();

this.channel = channel;

this.refs = 0;

}

ref() {

if (++this.refs === 1) {

this.channel.ref();

}

}

unref() {

if (--this.refs === 0) {

this.channel.unref();

this.emit('unref');

}

}

}

function setupChannel(target, channel) {

target.channel = channel;

// _channel can be deprecated in version 8

Object.defineProperty(target, '_channel', {

get() { return target.channel; },

set(val) { target.channel = val; },

enumerable: true

});

var decoder = new StringDecoder('utf8');

var jsonBuffer = '';

channel.buffering = false;

channel.onread = function(nread, pool, recvHandle) {

// TODO(bnoordhuis) Check that nread > 0.

if (pool) {

if (recvHandle)

pendingHandle = recvHandle;

// Linebreak is used as a message end sign

var chunks = decoder.write(pool).split('\n');

var numCompleteChunks = chunks.length - 1;

// Last line does not have trailing linebreak

var incompleteChunk = chunks[numCompleteChunks];

if (numCompleteChunks === 0) {

jsonBuffer += incompleteChunk;

this.buffering = jsonBuffer.length !== 0;

return;

}

chunks[0] = jsonBuffer + chunks[0];

for (var i = 0; i < numCompleteChunks; i++) {

var message = JSON.parse(chunks[i]);

// There will be at most one NODE_HANDLE message in every chunk we

// read because SCM_RIGHTS messages don't get coalesced. Make sure

// that we deliver the handle with the right message however.

if (message.cmd === 'NODE_HANDLE') {

handleMessage(message, pendingHandle, true);

pendingHandle = null;

} else {

this.buffering = jsonBuffer.length !== 0;

} else {

this.buffering = false;

target.disconnect();

channel.onread = nop;

channel.close();

maybeClose(target);

}

};

// object where socket lists will live

channel.sockets = { got: {}, send: {} };

// handlers will go through this

target.on('internalMessage', function(message, handle) {

// Once acknowledged - continue sending handles.

if (message.cmd === 'NODE_HANDLE_ACK' ||

message.cmd === 'NODE_HANDLE_NACK') {

if (target._pendingMessage) {

if (message.cmd === 'NODE_HANDLE_ACK') {

closePendingHandle(target);

} else if (target._pendingMessage.retransmissions++ ===

MAX_HANDLE_RETRANSMISSIONS) {

closePendingHandle(target);

process.emitWarning('Handle did not reach the receiving process ' +

'correctly', 'SentHandleNotReceivedWarning');

}

}

assert(Array.isArray(target._handleQueue));

var queue = target._handleQueue;

target._handleQueue = null;

if (target._pendingMessage) {

target._send(target._pendingMessage.message,

target._pendingMessage.handle,

target._pendingMessage.options,

target._pendingMessage.callback);

}

for (var i = 0; i < queue.length; i++) {

var args = queue[i];

// Process a pending disconnect (if any).

target._disconnect();

return;

}

if (message.cmd !== 'NODE_HANDLE') return;

// It is possible that the handle is not received because of some error on

// ancillary data reception such as MSG_CTRUNC. In this case, report the

// sender about it by sending a NODE_HANDLE_NACK message.

if (!handle)

return target._send({ cmd: 'NODE_HANDLE_NACK' }, null, true);

// Acknowledge handle receival. Don't emit error events (for example if

// the other side has disconnected) because this call to send() is not

// initiated by the user and it shouldn't be fatal to be unable to ACK

// a message.

target._send({ cmd: 'NODE_HANDLE_ACK' }, null, true);

var obj = handleConversion[message.type];

// Update simultaneous accepts on Windows

if (process.platform === 'win32') {

handle._simultaneousAccepts = false;

net._setSimultaneousAccepts(handle);

}

// Convert handle object

obj.got.call(this, message, handle, function(handle) {

});

});

if (typeof handle === 'function') {

callback = handle;

handle = undefined;

options = undefined;

} else if (typeof options === 'function') {

callback = options;

options = undefined;

} else if (options !== undefined &&

(options === null || typeof options !== 'object')) {

if (typeof callback === 'function') {

process.nextTick(callback, ex);

} else {

this.emit('error', ex); // FIXME(bnoordhuis) Defer to next tick.

}

};