tls: allow reading data into a static buffer

Refs: #25436
PR-URL: #35753
Refs: #25436
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Minwoo Jung <nodecorelab@gmail.com>

Author: puzpuzpuz

benchmark/tls/throughput.js benchmark/tls/throughput-c2s.jsbenchmark/tls/throughput.js renamed to benchmark/tls/throughput-c2s.js

@@ -0,0 +1,104 @@
+'use strict';
+constcommon=require('../common.js');
+constbench=common.createBenchmark(main,{
+dur: [5],
+type: ['buf','asc','utf'],
+sendchunklen: [256,32*1024,128*1024,16*1024*1024],
+recvbuflen: [0,64*1024,1024*1024],
+recvbufgenfn: ['true','false']
+});
+
+constfixtures=require('../../test/common/fixtures');
+letoptions;
+letrecvbuf;
+letreceived=0;
+consttls=require('tls');
+
+functionmain({ dur, type, sendchunklen, recvbuflen, recvbufgenfn }){
+if(isFinite(recvbuflen)&&recvbuflen>0)
+recvbuf=Buffer.alloc(recvbuflen);
+
+letencoding;
+letchunk;
+switch(type){
+case'buf':
+chunk=Buffer.alloc(sendchunklen,'b');
+break;
+case'asc':
+chunk='a'.repeat(sendchunklen);
+encoding='ascii';
+break;
+case'utf':
+chunk='ü'.repeat(sendchunklen/2);
+encoding='utf8';
+break;
+default:
+thrownewError('invalid type');
+}
+
+options={
+key: fixtures.readKey('rsa_private.pem'),
+cert: fixtures.readKey('rsa_cert.crt'),
+ca: fixtures.readKey('rsa_ca.crt'),
+ciphers: 'AES256-GCM-SHA384'
+};
+
+letsocketOpts;
+if(recvbuf===undefined){
+socketOpts={port: common.PORT,rejectUnauthorized: false};
+}else{
+letbuffer=recvbuf;
+if(recvbufgenfn==='true'){
+letbufidx=-1;
+constbufpool=[
+recvbuf,
+Buffer.from(recvbuf),
+Buffer.from(recvbuf),
+];
+buffer=()=>{
+bufidx=(bufidx+1)%bufpool.length;
+returnbufpool[bufidx];
+};
+}
+socketOpts={
+port: common.PORT,
+rejectUnauthorized: false,
+onread: {
+ buffer,
+callback: function(nread,buf){
+received+=nread;
+}
+}
+};
+}
+
+constserver=tls.createServer(options,(socket)=>{
+socket.on('data',(buf)=>{
+socket.on('drain',write);
+write();
+});
+
+functionwrite(){
+while(false!==socket.write(chunk,encoding));
+}
+});
+
+letconn;
+server.listen(common.PORT,()=>{
+conn=tls.connect(socketOpts,()=>{
+setTimeout(done,dur*1000);
+bench.start();
+conn.write('hello');
+});
+
+conn.on('data',(chunk)=>{
+received+=chunk.length;
+});
+});
+
+functiondone(){
+constmbits=(received*8)/(1024*1024);
+bench.end(mbits);
+process.exit(0);
+}
+}

benchmark/tls/throughput-s2c.js

@@ -1343,6 +1343,9 @@ being issued by trusted CA (`options.ca`).
 <!-- YAML
 added: v0.11.3
 changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/35753
+ description: Added `onread` option.
  - version:
  - v14.1.0
  - v13.14.0
@@ -1456,6 +1459,10 @@ changes:
 [`tls.createSecureContext()`][]. If a `secureContext` is _not_ provided, one
  will be created by passing the entire `options` object to
 `tls.createSecureContext()`.
+*`onread` {Object} If the `socket` option is missing, incoming data is
+ stored in a single `buffer` and passed to the supplied `callback` when
+ data arrives on the socket, otherwise the option is ignored. See the
+`onread` option of [`net.Socket`][] for details.
 * ...: [`tls.createSecureContext()`][] options that are used if the
 `secureContext` option is missing, otherwise they are ignored.
 * ...: Any [`socket.connect()`][] option not already listed.

doc/api/tls.md

@@ -502,6 +502,7 @@ function TLSSocket(socket, opts) {
 pauseOnCreate: tlsOptions.pauseOnConnect,
 manualStart: true,
 highWaterMark: tlsOptions.highWaterMark,
+onread: !socket ? tlsOptions.onread : null,
 });
 
 // Proxy for API compatibility
@@ -1592,6 +1593,7 @@ exports.connect = function connect(...args) {
 enableTrace: options.enableTrace,
 pskCallback: options.pskCallback,
 highWaterMark: options.highWaterMark,
+onread: options.onread,
 });
 
 tlssock[kConnectOptions]=options;

lib/_tls_wrap.js

@@ -304,55 +304,54 @@ function Socket(options) {
 if(options.handle){
 this._handle=options.handle;// private
 this[async_id_symbol]=getNewAsyncId(this._handle);
-}else{
-constonread=options.onread;
-if(onread!==null&&typeofonread==='object'&&
-(isUint8Array(onread.buffer)||typeofonread.buffer==='function')&&
-typeofonread.callback==='function'){
-if(typeofonread.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;
-leterr;
+}elseif(options.fd!==undefined){
+const{ fd }=options;
+leterr;
 
-// createHandle will throw ERR_INVALID_FD_TYPE if `fd` is not
-// a valid `PIPE` or `TCP` descriptor
-this._handle=createHandle(fd,false);
+// 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)
+throwerrnoException(err,'open');
 
-err=this._handle.open(fd);
+this[async_id_symbol]=this._handle.getAsyncId();
 
-// 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((fd===1||fd===2)&&
+(this._handleinstanceofPipe)&&isWindows){
+// Make stdout and stderr blocking on Windows
+err=this._handle.setBlocking(true);
 if(err)
-throwerrnoException(err,'open');
-
-this[async_id_symbol]=this._handle.getAsyncId();
-
-if((fd===1||fd===2)&&
-(this._handleinstanceofPipe)&&isWindows){
-// Make stdout and stderr blocking on Windows
-err=this._handle.setBlocking(true);
-if(err)
-throwerrnoException(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
-});
-}
+throwerrnoException(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
+});
+}
+}
+
+constonread=options.onread;
+if(onread!==null&&typeofonread==='object'&&
+(isUint8Array(onread.buffer)||typeofonread.buffer==='function')&&
+typeofonread.callback==='function'){
+if(typeofonread.buffer==='function'){
+this[kBuffer]=true;
+this[kBufferGen]=onread.buffer;
+}else{
+this[kBuffer]=onread.buffer;
 }
+this[kBufferCb]=onread.callback;
 }
 
 // Shut down the socket when we're finished with it.