Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

net: do not inherit the no-half-open enforcer #18974

Closed
wants to merge 2 commits into from
Closed
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 4 additions & 22 deletions lib/_stream_duplex.js
Original file line number Diff line number Diff line change
@@ -29,33 +29,15 @@
module.exports = Duplex;

const util = require('util');
const Readable = require('_stream_readable');
const Writable = require('_stream_writable');

util.inherits(Duplex, Readable);

{
// avoid scope creep, the keys array can then be collected
const keys = Object.keys(Writable.prototype);
for (var v = 0; v < keys.length; v++) {
const method = keys[v];
if (!Duplex.prototype[method])
Duplex.prototype[method] = Writable.prototype[method];
}
}
const DuplexBase = require('internal/streams/duplex_base');

util.inherits(Duplex, DuplexBase);

function Duplex(options) {
if (!(this instanceof Duplex))
return new Duplex(options);

Readable.call(this, options);
Writable.call(this, options);

if (options && options.readable === false)
this.readable = false;

if (options && options.writable === false)
this.writable = false;
DuplexBase.call(this, options);

this.allowHalfOpen = true;
if (options && options.allowHalfOpen === false) {
30 changes: 30 additions & 0 deletions lib/internal/streams/duplex_base.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,30 @@
'use strict';

const util = require('util');
const Readable = require('_stream_readable');
const Writable = require('_stream_writable');

function DuplexBase(options) {
Readable.call(this, options);
Writable.call(this, options);

if (options && options.readable === false)
this.readable = false;

if (options && options.writable === false)
this.writable = false;
}

util.inherits(DuplexBase, Readable);

{
// Avoid scope creep, the keys array can then be collected.
const keys = Object.keys(Writable.prototype);
for (var v = 0; v < keys.length; v++) {
const method = keys[v];
if (!DuplexBase.prototype[method])
DuplexBase.prototype[method] = Writable.prototype[method];
}
}

module.exports = DuplexBase;
11 changes: 7 additions & 4 deletions lib/net.js
Original file line number Diff line number Diff line change
@@ -64,6 +64,7 @@ const {
ERR_SOCKET_BAD_PORT,
ERR_SOCKET_CLOSED
} = errors.codes;
const DuplexBase = require('internal/streams/duplex_base');
const dns = require('dns');

const kLastWriteQueueSize = Symbol('lastWriteQueueSize');
@@ -238,7 +239,11 @@ function Socket(options) {
// For backwards compat do not emit close on destroy.
options.emitClose = false;

stream.Duplex.call(this, options);
// `DuplexBase` is just a slimmed down constructor for `Duplex` which allow
// us to not inherit the "no-half-open enforcer" as there is already one in
// place. Instances of `Socket` are still instances of `Duplex`, that is,
// `socket instanceof Duplex === true`.
DuplexBase.call(this, options);

if (options.handle) {
this._handle = options.handle; // private
@@ -263,8 +268,6 @@ function Socket(options) {
this._writev = null;
this._write = makeSyncWrite(fd);
}
this.readable = options.readable !== false;
this.writable = options.writable !== false;
} else {
// these will be set once there is a connection
this.readable = this.writable = false;
@@ -282,7 +285,7 @@ function Socket(options) {
this._writableState.decodeStrings = false;

// default to *not* allowing half open sockets
this.allowHalfOpen = options && options.allowHalfOpen || false;
this.allowHalfOpen = options.allowHalfOpen || false;
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

… and, as I understand it, would allow us to get rid of this, if we just transform allowHalfOpen correctly to begin with?

Also, I don’t know what the motivation for this was, but I don’t get why the default is not allowing half-open connections.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This is unrelated but options is always an object so there is no reason to see if it's truthy.


// if we have a handle, then start the flow of data into the
// buffer. if not, then this will happen when we connect
1 change: 1 addition & 0 deletions node.gyp
Original file line number Diff line number Diff line change
@@ -146,6 +146,7 @@
'lib/internal/streams/lazy_transform.js',
'lib/internal/streams/async_iterator.js',
'lib/internal/streams/BufferList.js',
'lib/internal/streams/duplex_base.js',
'lib/internal/streams/duplexpair.js',
'lib/internal/streams/legacy.js',
'lib/internal/streams/destroy.js',
7 changes: 1 addition & 6 deletions test/parallel/test-http-connect.js
Original file line number Diff line number Diff line change
@@ -75,12 +75,7 @@ server.listen(0, common.mustCall(() => {
assert.strictEqual(socket.listeners('connect').length, 0);
assert.strictEqual(socket.listeners('data').length, 0);
assert.strictEqual(socket.listeners('drain').length, 0);

// the stream.Duplex onend listener
// allow 0 here, so that i can run the same test on streams1 impl
assert(socket.listenerCount('end') <= 2,
`Found ${socket.listenerCount('end')} end listeners`);

assert.strictEqual(socket.listeners('end').length, 1);
assert.strictEqual(socket.listeners('free').length, 0);
assert.strictEqual(socket.listeners('close').length, 0);
assert.strictEqual(socket.listeners('error').length, 0);
11 changes: 11 additions & 0 deletions test/parallel/test-net-socket-no-halfopen-enforcer.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,11 @@
'use strict';
require('../common');

// This test ensures that `net.Socket` does not inherit the no-half-open
// enforcer from `stream.Duplex`.

const { Socket } = require('net');
const { strictEqual } = require('assert');

const socket = new Socket({ allowHalfOpen: false });
strictEqual(socket.listenerCount('end'), 1);