GeezerVison

The numeric representation of the remote port. For example, `80` or `21`.

* Returns: {net.Socket}

Close the TCP connection by sending an RST packet and destroy the stream.

If this TCP socket is in connecting status, it will send an RST packet and destroy this TCP socket once it is connected.

Otherwise, it will call `socket.destroy` with an `ERR_SOCKET_CLOSED` Error.

If this is not a TCP socket (for example, a pipe), calling this method will immediately throw an `ERR_INVALID_HANDLE_TYPE` Error.

* Returns: {net.Socket} The socket itself.

ERR_INVALID_ARG_VALUE,

ERR_INVALID_FD_TYPE,

ERR_INVALID_IP_ADDRESS,

ERR_INVALID_HANDLE_TYPE,

ERR_SERVER_ALREADY_LISTEN,

ERR_SERVER_NOT_RUNNING,

ERR_SOCKET_CLOSED,

return this;

Socket.prototype.resetAndDestroy = function() {

if (this._handle) {

if (!(this._handle instanceof TCP))

throw new ERR_INVALID_HANDLE_TYPE();

if (this.connecting) {

debug('reset wait for connection');

this.once('connect', () => this._reset());

} else {

this._reset();

}

} else {

this.destroy(new ERR_SOCKET_CLOSED());

}

return this;

Socket.prototype.pause = function() {

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

this[kBytesRead] = this._handle.bytesRead;

this[kBytesWritten] = this._handle.bytesWritten;

this._handle.close(() => {

debug('emit close');

this.emit('close', isException);

});

if (this.resetAndClosing) {

this.resetAndClosing = false;

const err = this._handle.reset(() => {

debug('emit close');

this.emit('close', isException);

});

if (err)

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

} else {

this._handle.close(() => {

debug('emit close');

this.emit('close', isException);

});

}

this._handle.onread = noop;

this._handle = null;

this._sockname = null;

}

Socket.prototype._reset = function() {

debug('reset connection');

this.resetAndClosing = true;

return this.destroy();

Socket.prototype._getpeername = function() {

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

return this._peername || {};

}

static void OnClose(uv_handle_t* handle);

enum { kInitialized, kClosing, kClosed } state_;

private:

friend class Environment;

// refer to `doc/contributing/node-postmortem-support.md`

friend int GenDebugSymbols();

ListNode<HandleWrap> handle_wrap_queue_;

enum { kInitialized, kClosing, kClosed } state_;

uv_handle_t* const handle_;

};

GetSockOrPeerName<TCPWrap, uv_tcp_getpeername>);

env->SetProtoMethod(t, "setNoDelay", SetNoDelay);

env->SetProtoMethod(t, "setKeepAlive", SetKeepAlive);

env->SetProtoMethod(t, "reset", Reset);

#ifdef _WIN32

env->SetProtoMethod(t, "setSimultaneousAccepts", SetSimultaneousAccepts);

registry->Register(GetSockOrPeerName<TCPWrap, uv_tcp_getpeername>);

registry->Register(SetNoDelay);

registry->Register(SetKeepAlive);

registry->Register(Reset);

#ifdef _WIN32

registry->Register(SetSimultaneousAccepts);

#endif

args.GetReturnValue().Set(err);

}

void TCPWrap::Reset(const FunctionCallbackInfo<Value>& args) {

TCPWrap* wrap;

ASSIGN_OR_RETURN_UNWRAP(

&wrap, args.Holder(), args.GetReturnValue().Set(UV_EBADF));

int err = wrap->Reset(args[0]);

args.GetReturnValue().Set(err);

}

int TCPWrap::Reset(Local<Value> close_callback) {

if (state_ != kInitialized) return 0;

int err = uv_tcp_close_reset(&handle_, OnClose);

state_ = kClosing;

if (!err & !close_callback.IsEmpty() && close_callback->IsFunction() &&

!persistent().IsEmpty()) {

object()

->Set(env()->context(), env()->handle_onclose_symbol(), close_callback)

.Check();

}

return err;

}

MaybeLocal<Object> AddressToJS(Environment* env,

const v8::FunctionCallbackInfo<v8::Value>& args,

int family,

std::function<int(const char* ip_address, int port, T* addr)> uv_ip_addr);

static void Reset(const v8::FunctionCallbackInfo<v8::Value>& args);

int Reset(v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());

#ifdef _WIN32

static void SetSimultaneousAccepts(

const common = require('../common');

const net = require('net');

const assert = require('assert');

const server = net.createServer();

server.listen(0, common.mustCall(function() {

const port = server.address().port;

const conn = net.createConnection(port);

server.on('connection', (socket) => {

socket.on('error', common.expectsError({

code: 'ECONNRESET',

message: 'read ECONNRESET',

name: 'Error'

}));

});

conn.on('connect', common.mustCall(function() {

assert.strictEqual(conn, conn.resetAndDestroy().destroy());

conn.on('error', common.mustNotCall());

conn.write(Buffer.from('fzfzfzfzfz'), common.expectsError({

code: 'ERR_STREAM_DESTROYED',

message: 'Cannot call write after a stream was destroyed',

name: 'Error'

}));

server.close();

}));

const common = require('../common');

const net = require('net');

const server = net.createServer();

const port = server.address().port;

const socket = net.connect(port, common.localhostIPv4, common.mustNotCall());

socket.on('error', common.mustNotCall());

const common = require('../common');

const net = require('net');

const server = net.createServer();

server.listen(0, common.mustCall(function() {

const port = server.address().port;

const conn = net.createConnection(port);

conn.on('close', common.mustCall());

server.on('connection', (socket) => {

socket.on('error', common.expectsError({

code: 'ECONNRESET',

message: 'read ECONNRESET',

name: 'Error'

}));

server.close();

});

conn.resetAndDestroy();

const common = require('../common');

const net = require('net');

const socket = new net.Socket();

socket.on('error', common.mustCall(

common.expectsError({

code: 'ERR_SOCKET_CLOSED',

name: 'Error'

}))

const common = require('../common');

const assert = require('assert');

const net = require('net');

const sockets = [];

const server = net.createServer(function(c) {

c.on('close', common.mustCall());

sockets.push(c);

if (sockets.length === 2) {

assert.strictEqual(server.close(), server);

sockets.forEach((c) => c.resetAndDestroy());

}

server.on('close', common.mustCall());

assert.strictEqual(server, server.listen(0, () => {

net.createConnection(server.address().port)

.on('error', common.mustCall(

common.expectsError({

code: 'ECONNRESET',

name: 'Error'

}))

);

net.createConnection(server.address().port)

.on('error', common.mustCall(

common.expectsError({

code: 'ECONNRESET',

name: 'Error'

}))

);