// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

'use strict';

const {

ArrayIsArray,

Boolean,

Error,

Number,

NumberIsNaN,

ObjectDefineProperty,

ObjectSetPrototypeOf,

Symbol,

} = primordials;

const EventEmitter = require('events');

const stream = require('stream');

const { inspect } = require('internal/util/inspect');

const debug = require('internal/util/debuglog').debuglog('net');

const { deprecate } = require('internal/util');

const {

isIP,

isIPv4,

isIPv6,

normalizedArgsSymbol,

makeSyncWrite

} = require('internal/net');

const assert = require('internal/assert');

const {

UV_EADDRINUSE,

UV_EINVAL,

UV_ENOTCONN

} = internalBinding('uv');

const { Buffer } = require('buffer');

const { guessHandleType } = internalBinding('util');

const { ShutdownWrap } = internalBinding('stream_wrap');

const {

TCP,

TCPConnectWrap,

constants: TCPConstants

} = internalBinding('tcp_wrap');

const {

Pipe,

PipeConnectWrap,

constants: PipeConstants

} = internalBinding('pipe_wrap');

const {

newAsyncId,

defaultTriggerAsyncIdScope,

symbols: { async_id_symbol, owner_symbol }

} = require('internal/async_hooks');

const {

writevGeneric,

writeGeneric,

onStreamRead,

kAfterAsyncWrite,

kHandle,

kUpdateTimer,

setStreamTimeout,

kBuffer,

kBufferCb,

kBufferGen

} = require('internal/stream_base_commons');

const {

codes: {

ERR_INVALID_ADDRESS_FAMILY,

ERR_INVALID_ARG_TYPE,

ERR_INVALID_ARG_VALUE,

ERR_INVALID_FD_TYPE,

ERR_INVALID_IP_ADDRESS,

ERR_INVALID_OPT_VALUE,

ERR_SERVER_ALREADY_LISTEN,

ERR_SERVER_NOT_RUNNING,

ERR_SOCKET_CLOSED

},

errnoException,

exceptionWithHostPort,

uvExceptionWithHostPort

} = require('internal/errors');

const { isUint8Array } = require('internal/util/types');

const {

validateInt32,

validatePort,

validateString

} = require('internal/validators');

const kLastWriteQueueSize = Symbol('lastWriteQueueSize');

const {

DTRACE_NET_SERVER_CONNECTION,

DTRACE_NET_STREAM_END

} = require('internal/dtrace');

// Lazy loaded to improve startup performance.

let cluster;

let dns;

const { clearTimeout } = require('timers');

const { kTimeout } = require('internal/timers');

const DEFAULT_IPV4_ADDR = '0.0.0.0';

const DEFAULT_IPV6_ADDR = '::';

const isWindows = process.platform === 'win32';

function noop() {}

function getFlags(ipv6Only) {

return ipv6Only === true ? TCPConstants.UV_TCP_IPV6ONLY : 0;

}

function createHandle(fd, is_server) {

validateInt32(fd, 'fd', 0);

const type = guessHandleType(fd);

if (type === 'PIPE') {

return new Pipe(

is_server ? PipeConstants.SERVER : PipeConstants.SOCKET

);

}

if (type === 'TCP') {

return new TCP(

is_server ? TCPConstants.SERVER : TCPConstants.SOCKET

);

}

throw new ERR_INVALID_FD_TYPE(type);

}

function getNewAsyncId(handle) {

return (!handle || typeof handle.getAsyncId !== 'function') ?

newAsyncId() : handle.getAsyncId();

}

function isPipeName(s) {

return typeof s === 'string' && toNumber(s) === false;

}

function createServer(options, connectionListener) {

return new Server(options, connectionListener);

}

// Target API:

//

// let s = net.connect({port: 80, host: 'google.com'}, function() {

// ...

// });

//

// There are various forms:

//

// connect(options, [cb])

// connect(port, [host], [cb])

// connect(path, [cb]);

//

function connect(...args) {

const normalized = normalizeArgs(args);

const options = normalized[0];

debug('createConnection', normalized);

const socket = new Socket(options);

if (options.timeout) {

socket.setTimeout(options.timeout);

}

return socket.connect(normalized);

}

// Returns an array [options, cb], where options is an object,

// cb is either a function or null.

// Used to normalize arguments of Socket.prototype.connect() and

// Server.prototype.listen(). Possible combinations of parameters:

// (options[...][, cb])

// (path[...][, cb])

// ([port][, host][...][, cb])

// For Socket.prototype.connect(), the [...] part is ignored

// For Server.prototype.listen(), the [...] part is [, backlog]

// but will not be handled here (handled in listen())

function normalizeArgs(args) {

let arr;

if (args.length === 0) {

arr = [{}, null];

arr[normalizedArgsSymbol] = true;

return arr;

}

const arg0 = args[0];

let options = {};

if (typeof arg0 === 'object' && arg0 !== null) {

// (options[...][, cb])

options = arg0;

} else if (isPipeName(arg0)) {

// (path[...][, cb])

options.path = arg0;

} else {

// ([port][, host][...][, cb])

options.port = arg0;

if (args.length > 1 && typeof args[1] === 'string') {

options.host = args[1];

}

}

const cb = args[args.length - 1];

if (typeof cb !== 'function')

arr = [options, null];

else

arr = [options, cb];

arr[normalizedArgsSymbol] = true;

return arr;

}

// Called when creating new Socket, or when re-using a closed Socket

function initSocketHandle(self) {

self._undestroy();

self._sockname = null;

// Handle creation may be deferred to bind() or connect() time.

if (self._handle) {

self._handle[owner_symbol] = self;

self._handle.onread = onStreamRead;

self[async_id_symbol] = getNewAsyncId(self._handle);

let userBuf = self[kBuffer];

if (userBuf) {

const bufGen = self[kBufferGen];

if (bufGen !== null) {

userBuf = bufGen();

if (!isUint8Array(userBuf))

return;

self[kBuffer] = userBuf;

}

self._handle.useUserBuffer(userBuf);

}

}

}

const kBytesRead = Symbol('kBytesRead');

const kBytesWritten = Symbol('kBytesWritten');

const kSetNoDelay = Symbol('kSetNoDelay');

function Socket(options) {

if (!(this instanceof Socket)) return new Socket(options);

this.connecting = false;

// Problem with this is that users can supply their own handle, that may not

// have _handle.getAsyncId(). In this case an[async_id_symbol] should

// probably be supplied by async_hooks.

this[async_id_symbol] = -1;

this._hadError = false;

this[kHandle] = null;

this._parent = null;

this._host = null;

this[kSetNoDelay] = false;

this[kLastWriteQueueSize] = 0;

this[kTimeout] = null;

this[kBuffer] = null;

this[kBufferCb] = null;

this[kBufferGen] = null;

if (typeof options === 'number')

options = { fd: options }; // Legacy interface.

else

options = { ...options };

// Default to *not* allowing half open sockets.

options.allowHalfOpen = Boolean(options.allowHalfOpen);

// For backwards compat do not emit close on destroy.

options.emitClose = false;

options.autoDestroy = true;

// Handle strings directly.

options.decodeStrings = false;

stream.Duplex.call(this, options);

if (options.handle) {

this._handle = options.handle; // private

this[async_id_symbol] = getNewAsyncId(this._handle);

} else {

const onread = options.onread;

if (onread !== null && typeof onread === 'object' &&

(isUint8Array(onread.buffer) || typeof onread.buffer === 'function') &&

typeof onread.callback === 'function') {

if (typeof onread.buffer === 'function') {

this[kBuffer] = true;

this[kBufferGen] = onread.buffer;

} else {

this[kBuffer] = onread.buffer;

}

this[kBufferCb] = onread.callback;

}

if (options.fd !== undefined) {

const { fd } = options;

let err;

// createHandle will throw ERR_INVALID_FD_TYPE if `fd` is not

// a valid `PIPE` or `TCP` descriptor

this._handle = createHandle(fd, false);

err = this._handle.open(fd);

// While difficult to fabricate, in some architectures

// `open` may return an error code for valid file descriptors

// which cannot be opened. This is difficult to test as most

// un-openable fds will throw on `createHandle`

if (err)

throw errnoException(err, 'open');

this[async_id_symbol] = this._handle.getAsyncId();

if ((fd === 1 || fd === 2) &&

(this._handle instanceof Pipe) && isWindows) {

// Make stdout and stderr blocking on Windows

err = this._handle.setBlocking(true);

if (err)

throw errnoException(err, 'setBlocking');

this._writev = null;

this._write = makeSyncWrite(fd);

// makeSyncWrite adjusts this value like the original handle would, so

// we need to let it do that by turning it into a writable, own

// property.

ObjectDefineProperty(this._handle, 'bytesWritten', {

value: 0, writable: true

});

}

}

}

// Shut down the socket when we're finished with it.

this.on('end', onReadableStreamEnd);

initSocketHandle(this);

this._pendingData = null;

this._pendingEncoding = '';

// If we have a handle, then start the flow of data into the

// buffer. if not, then this will happen when we connect

if (this._handle && options.readable !== false) {

if (options.pauseOnCreate) {

// Stop the handle from reading and pause the stream

this._handle.reading = false;

this._handle.readStop();

this.readableFlowing = false;

} else if (!options.manualStart) {

this.read(0);

}

}

// Reserve properties

this.server = null;

this._server = null;

// Used after `.destroy()`

this[kBytesRead] = 0;

this[kBytesWritten] = 0;

}

ObjectSetPrototypeOf(Socket.prototype, stream.Duplex.prototype);

ObjectSetPrototypeOf(Socket, stream.Duplex);

// Refresh existing timeouts.

Socket.prototype._unrefTimer = function _unrefTimer() {

for (let s = this; s !== null; s = s._parent) {

if (s[kTimeout])

s[kTimeout].refresh();

}

};

// The user has called .end(), and all the bytes have been

// sent out to the other side.

Socket.prototype._final = function(cb) {

// If still connecting - defer handling `_final` until 'connect' will happen

if (this.pending) {

debug('_final: not yet connected');

return this.once('connect', () => this._final(cb));

}

if (!this._handle)

return cb();

debug('_final: not ended, call shutdown()');

const req = new ShutdownWrap();

req.oncomplete = afterShutdown;

req.handle = this._handle;

req.callback = cb;

const err = this._handle.shutdown(req);

if (err === 1 || err === UV_ENOTCONN) // synchronous finish

return cb();

else if (err !== 0)

return cb(errnoException(err, 'shutdown'));

};

function afterShutdown() {

const self = this.handle[owner_symbol];

debug('afterShutdown destroyed=%j', self.destroyed,

self._readableState);

this.callback();

}

// Provide a better error message when we call end() as a result

// of the other side sending a FIN. The standard 'write after end'

// is overly vague, and makes it seem like the user's code is to blame.

function writeAfterFIN(chunk, encoding, cb) {

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

cb = encoding;

encoding = null;

}

// eslint-disable-next-line no-restricted-syntax

const er = new Error('This socket has been ended by the other party');

er.code = 'EPIPE';

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

defaultTriggerAsyncIdScope(this[async_id_symbol], process.nextTick, cb, er);

}

this.destroy(er);

return false;

}

Socket.prototype.setTimeout = setStreamTimeout;

Socket.prototype._onTimeout = function() {

const handle = this._handle;

const lastWriteQueueSize = this[kLastWriteQueueSize];

if (lastWriteQueueSize > 0 && handle) {

// `lastWriteQueueSize !== writeQueueSize` means there is

// an active write in progress, so we suppress the timeout.

const { writeQueueSize } = handle;

if (lastWriteQueueSize !== writeQueueSize) {

this[kLastWriteQueueSize] = writeQueueSize;

this._unrefTimer();

return;

}

}

debug('_onTimeout');

this.emit('timeout');

};

Socket.prototype.setNoDelay = function(enable) {

if (!this._handle) {

this.once('connect',

enable ? this.setNoDelay : () => this.setNoDelay(enable));

return this;

}

// Backwards compatibility: assume true when `enable` is omitted

const newValue = enable === undefined ? true : !!enable;

if (this._handle.setNoDelay && newValue !== this[kSetNoDelay]) {

this[kSetNoDelay] = newValue;

this._handle.setNoDelay(newValue);

}

return this;

};

Socket.prototype.setKeepAlive = function(setting, msecs) {

if (!this._handle) {

this.once('connect', () => this.setKeepAlive(setting, msecs));

return this;

}

if (this._handle.setKeepAlive)

this._handle.setKeepAlive(setting, ~~(msecs / 1000));

return this;

};

Socket.prototype.address = function() {

return this._getsockname();

};

ObjectDefineProperty(Socket.prototype, '_connecting', {

get: function() {

return this.connecting;

}

});

ObjectDefineProperty(Socket.prototype, 'pending', {

get() {

return !this._handle || this.connecting;

},

configurable: true

});

ObjectDefineProperty(Socket.prototype, 'readyState', {

get: function() {

if (this.connecting) {

return 'opening';

} else if (this.readable && this.writable) {

return 'open';

} else if (this.readable && !this.writable) {

return 'readOnly';

} else if (!this.readable && this.writable) {

return 'writeOnly';

}

return 'closed';

}

});

ObjectDefineProperty(Socket.prototype, 'bufferSize', {

get: function() {

if (this._handle) {

return this[kLastWriteQueueSize] + this.writableLength;

}

}

});

ObjectDefineProperty(Socket.prototype, kUpdateTimer, {

get: function() {

return this._unrefTimer;

}

});

function tryReadStart(socket) {

// Not already reading, start the flow

debug('Socket._handle.readStart');

socket._handle.reading = true;

const err = socket._handle.readStart();

if (err)

socket.destroy(errnoException(err, 'read'));

}

// Just call handle.readStart until we have enough in the buffer

Socket.prototype._read = function(n) {

debug('_read');

if (this.connecting || !this._handle) {

debug('_read wait for connection');

this.once('connect', () => this._read(n));

} else if (!this._handle.reading) {

tryReadStart(this);

}

};

Socket.prototype.end = function(data, encoding, callback) {

stream.Duplex.prototype.end.call(this, data, encoding, callback);

DTRACE_NET_STREAM_END(this);

return this;

};

Socket.prototype.pause = function() {

if (this[kBuffer] && !this.connecting && this._handle &&

this._handle.reading) {

this._handle.reading = false;

if (!this.destroyed) {

const err = this._handle.readStop();

if (err)

this.destroy(errnoException(err, 'read'));

}

}

return stream.Duplex.prototype.pause.call(this);

};

Socket.prototype.resume = function() {

if (this[kBuffer] && !this.connecting && this._handle &&

!this._handle.reading) {

tryReadStart(this);

}

return stream.Duplex.prototype.resume.call(this);

};

Socket.prototype.read = function(n) {

if (this[kBuffer] && !this.connecting && this._handle &&

!this._handle.reading) {

tryReadStart(this);

}

return stream.Duplex.prototype.read.call(this, n);

};

// Called when the 'end' event is emitted.

function onReadableStreamEnd() {

if (!this.allowHalfOpen) {

this.write = writeAfterFIN;

}

}

Socket.prototype.destroySoon = function() {

if (this.writable)

this.end();

if (this.writableFinished)

this.destroy();

else

this.once('finish', this.destroy);

};

Socket.prototype._destroy = function(exception, cb) {

debug('destroy');

this.connecting = false;

for (let s = this; s !== null; s = s._parent) {

clearTimeout(s[kTimeout]);

}

debug('close');

if (this._handle) {

if (this !== process.stderr)

debug('close handle');

const isException = exception ? true : false;

// `bytesRead` and `kBytesWritten` should be accessible after `.destroy()`

this[kBytesRead] = this._handle.bytesRead;

this[kBytesWritten] = this._handle.bytesWritten;

this._handle.close(() => {

debug('emit close');

this.emit('close', isException);

});

this._handle.onread = noop;

this._handle = null;

this._sockname = null;

cb(exception);

} else {

cb(exception);

process.nextTick(emitCloseNT, this);

}

if (this._server) {

debug('has server');

this._server._connections--;

if (this._server._emitCloseIfDrained) {

this._server._emitCloseIfDrained();

}

}

};

Socket.prototype._getpeername = function() {

if (!this._peername) {

if (!this._handle || !this._handle.getpeername) {

return {};

}

const out = {};

const err = this._handle.getpeername(out);

if (err) return {}; // FIXME(bnoordhuis) Throw?

this._peername = out;

}

return this._peername;

};

function protoGetter(name, callback) {

ObjectDefineProperty(Socket.prototype, name, {

configurable: false,

enumerable: true,

get: callback

});

}

protoGetter('bytesRead', function bytesRead() {

return this._handle ? this._handle.bytesRead : this[kBytesRead];

});

protoGetter('remoteAddress', function remoteAddress() {

return this._getpeername().address;

});

protoGetter('remoteFamily', function remoteFamily() {

return this._getpeername().family;

});

protoGetter('remotePort', function remotePort() {

return this._getpeername().port;

});

Socket.prototype._getsockname = function() {

if (!this._handle || !this._handle.getsockname) {

return {};

}

if (!this._sockname) {

const out = {};

const err = this._handle.getsockname(out);

if (err) return {}; // FIXME(bnoordhuis) Throw?

this._sockname = out;

}

return this._sockname;

};

protoGetter('localAddress', function localAddress() {

return this._getsockname().address;

});

protoGetter('localPort', function localPort() {

return this._getsockname().port;

});

Socket.prototype[kAfterAsyncWrite] = function() {

this[kLastWriteQueueSize] = 0;

};

Socket.prototype._writeGeneric = function(writev, data, encoding, cb) {

// If we are still connecting, then buffer this for later.

// The Writable logic will buffer up any more writes while

// waiting for this one to be done.

if (this.connecting) {

this._pendingData = data;

this._pendingEncoding = encoding;

this.once('connect', function connect() {

this._writeGeneric(writev, data, encoding, cb);

});

return;

}

this._pendingData = null;

this._pendingEncoding = '';

if (!this._handle) {

cb(new ERR_SOCKET_CLOSED());

return false;

}

this._unrefTimer();

let req;

if (writev)

req = writevGeneric(this, data, cb);

else

req = writeGeneric(this, data, encoding, cb);

if (req.async)

this[kLastWriteQueueSize] = req.bytes;

};

Socket.prototype._writev = function(chunks, cb) {

this._writeGeneric(true, chunks, '', cb);

};

Socket.prototype._write = function(data, encoding, cb) {

this._writeGeneric(false, data, encoding, cb);

};

// Legacy alias. Having this is probably being overly cautious, but it doesn't

// really hurt anyone either. This can probably be removed safely if desired.

protoGetter('_bytesDispatched', function _bytesDispatched() {

return this._handle ? this._handle.bytesWritten : this[kBytesWritten];

});

protoGetter('bytesWritten', function bytesWritten() {

let bytes = this._bytesDispatched;

const state = this._writableState;

const data = this._pendingData;

const encoding = this._pendingEncoding;

if (!state)

return undefined;

this.writableBuffer.forEach(function(el) {

if (el.chunk instanceof Buffer)

bytes += el.chunk.length;

else

bytes += Buffer.byteLength(el.chunk, el.encoding);

});

if (ArrayIsArray(data)) {

// Was a writev, iterate over chunks to get total length

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

const chunk = data[i];

if (data.allBuffers || chunk instanceof Buffer)

bytes += chunk.length;

else

bytes += Buffer.byteLength(chunk.chunk, chunk.encoding);

}

} else if (data) {

// Writes are either a string or a Buffer.

if (typeof data !== 'string')

bytes += data.length;

else

bytes += Buffer.byteLength(data, encoding);

}

return bytes;

});

function checkBindError(err, port, handle) {

// EADDRINUSE may not be reported until we call listen() or connect().

// To complicate matters, a failed bind() followed by listen() or connect()

// will implicitly bind to a random port. Ergo, check that the socket is

// bound to the expected port before calling listen() or connect().

//

// FIXME(bnoordhuis) Doesn't work for pipe handles, they don't have a

// getsockname() method. Non-issue for now, the cluster module doesn't

// really support pipes anyway.

if (err === 0 && port > 0 && handle.getsockname) {

const out = {};

err = handle.getsockname(out);

if (err === 0 && port !== out.port) {

debug(`checkBindError, bound to ${out.port} instead of ${port}`);

err = UV_EADDRINUSE;

}

}

return err;

}

function internalConnect(

self, address, port, addressType, localAddress, localPort, flags) {

// TODO return promise from Socket.prototype.connect which

// wraps _connectReq.

assert(self.connecting);

let err;

if (localAddress || localPort) {

if (addressType === 4) {

localAddress = localAddress || DEFAULT_IPV4_ADDR;

err = self._handle.bind(localAddress, localPort);

} else { // addressType === 6

localAddress = localAddress || DEFAULT_IPV6_ADDR;

err = self._handle.bind6(localAddress, localPort, flags);

}

debug('binding to localAddress: %s and localPort: %d (addressType: %d)',

localAddress, localPort, addressType);

err = checkBindError(err, localPort, self._handle);

if (err) {

const ex = exceptionWithHostPort(err, 'bind', localAddress, localPort);

self.destroy(ex);

return;

}

}

if (addressType === 6 || addressType === 4) {

const req = new TCPConnectWrap();

req.oncomplete = afterConnect;

req.address = address;

req.port = port;

req.localAddress = localAddress;

req.localPort = localPort;

if (addressType === 4)

err = self._handle.connect(req, address, port);

else

err = self._handle.connect6(req, address, port);

} else {

const req = new PipeConnectWrap();

req.address = address;

req.oncomplete = afterConnect;

err = self._handle.connect(req, address, afterConnect);

}

if (err) {

const sockname = self._getsockname();

let details;

if (sockname) {

details = sockname.address + ':' + sockname.port;

}

const ex = exceptionWithHostPort(err, 'connect', address, port, details);

self.destroy(ex);

}

}

Socket.prototype.connect = function(...args) {

let normalized;

// If passed an array, it's treated as an array of arguments that have

// already been normalized (so we don't normalize more than once). This has

// been solved before in https://github.com/nodejs/node/pull/12342, but was

// reverted as it had unintended side effects.

if (ArrayIsArray(args[0]) && args[0][normalizedArgsSymbol]) {

normalized = args[0];

} else {

normalized = normalizeArgs(args);

}

const options = normalized[0];

const cb = normalized[1];

if (this.write !== Socket.prototype.write)

this.write = Socket.prototype.write;

if (this.destroyed) {

this._handle = null;

this._peername = null;

this._sockname = null;

}

const { path } = options;

const pipe = !!path;

debug('pipe', pipe, path);

if (!this._handle) {

this._handle = pipe ?

new Pipe(PipeConstants.SOCKET) :

new TCP(TCPConstants.SOCKET);

initSocketHandle(this);

}

if (cb !== null) {

this.once('connect', cb);

}

this._unrefTimer();

this.connecting = true;

this.writable = true;

if (pipe) {

validateString(path, 'options.path');

defaultTriggerAsyncIdScope(

this[async_id_symbol], internalConnect, this, path

);

} else {

lookupAndConnect(this, options);

}

return this;

};

function lookupAndConnect(self, options) {

const { localAddress, localPort } = options;

const host = options.host || 'localhost';

let { port } = options;

if (localAddress && !isIP(localAddress)) {

throw new ERR_INVALID_IP_ADDRESS(localAddress);

}

if (localPort && typeof localPort !== 'number') {

throw new ERR_INVALID_ARG_TYPE('options.localPort', 'number', localPort);

}

if (typeof port !== 'undefined') {

if (typeof port !== 'number' && typeof port !== 'string') {

throw new ERR_INVALID_ARG_TYPE('options.port',

['number', 'string'], port);

}

validatePort(port);

}

port |= 0;

// If host is an IP, skip performing a lookup

const addressType = isIP(host);

if (addressType) {

defaultTriggerAsyncIdScope(self[async_id_symbol], process.nextTick, () => {

if (self.connecting)

defaultTriggerAsyncIdScope(

self[async_id_symbol],

internalConnect,

self, host, port, addressType, localAddress, localPort

);

});

return;

}

if (options.lookup && typeof options.lookup !== 'function')

throw new ERR_INVALID_ARG_TYPE('options.lookup',

'Function', options.lookup);