tls: properly track writeQueueSize during writes

Make writeQueueSize represent the actual size of the write queue
within the TLS socket. Add tls test to confirm that bufferSize
works as expected.
Backport-PR-URL: #16420
PR-URL: #15791Fixes: #15005
Refs: #15006
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Fedor Indutny <fedor.indutny@gmail.com>

Author: apapirovski

lib/_tls_wrap.js

@@ -401,9 +401,8 @@ TLSSocket.prototype._init = function(socket, wrap) {
 varssl=this._handle;
 
 // lib/net.js expect this value to be non-zero if write hasn't been flushed
-// immediately
-// TODO(indutny): revise this solution, it might be 1 before handshake and
-// represent real writeQueueSize during regular writes.
+// immediately. After the handshake is done this will represent the actual
+// write queue size
 ssl.writeQueueSize=1;
 
 this.server=options.server;

src/tls_wrap.cc

@@ -21,6 +21,7 @@ using v8::Exception;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
+using v8::Integer;
 using v8::Local;
 using v8::Object;
 using v8::String;
@@ -276,6 +277,7 @@ void TLSWrap::EncOut() {
 
 // No data to write
 if (BIO_pending(enc_out_) == 0) {
+UpdateWriteQueueSize();
 if (clear_in_->Length() == 0)
 InvokeQueued(0);
 return;
@@ -530,6 +532,18 @@ bool TLSWrap::IsClosing() {
 }
 
 
+uint32_tTLSWrap::UpdateWriteQueueSize(uint32_t write_queue_size) {
+ HandleScope scope(env()->isolate());
+if (write_queue_size == 0)
+ write_queue_size = BIO_pending(enc_out_);
+object()->Set(env()->context(),
+env()->write_queue_size_string(),
+Integer::NewFromUnsigned(env()->isolate(),
+ write_queue_size)).FromJust();
+return write_queue_size;
+}
+
+
 intTLSWrap::ReadStart() {
 return stream_->ReadStart();
 }
@@ -570,8 +584,12 @@ int TLSWrap::DoWrite(WriteWrap* w,
 ClearOut();
 // However, if there is any data that should be written to the socket,
 // the callback should not be invoked immediately
-if (BIO_pending(enc_out_) == 0)
+if (BIO_pending(enc_out_) == 0) {
+// net.js expects writeQueueSize to be > 0 if the write isn't
+// immediately flushed
+UpdateWriteQueueSize(1);
 return stream_->DoWrite(w, bufs, count, send_handle);
+ }
  }
 
 // Queue callback to execute it on next tick
@@ -621,13 +639,15 @@ int TLSWrap::DoWrite(WriteWrap* w,
 
 // Try writing data immediately
 EncOut();
+UpdateWriteQueueSize();
 
 return0;
 }
 
 
 voidTLSWrap::OnAfterWriteImpl(WriteWrap* w, void* ctx) {
-// Intentionally empty
+ TLSWrap* wrap = static_cast<TLSWrap*>(ctx);
+ wrap->UpdateWriteQueueSize();
 }
 
 

src/tls_wrap.h

@@ -111,6 +111,7 @@ class TLSWrap : public AsyncWrap,
 
  AsyncWrap* GetAsyncWrap() override;
 boolIsIPCPipe() override;
+uint32_tUpdateWriteQueueSize(uint32_t write_queue_size = 0);
 
 // Resource implementation
 staticvoidOnAfterWriteImpl(WriteWrap* w, void* ctx);

test/parallel/test-tls-buffersize.js

@@ -0,0 +1,43 @@
+'use strict';
+constcommon=require('../common');
+if(!common.hasCrypto)
+common.skip('missing crypto');
+constassert=require('assert');
+constfixtures=require('../common/fixtures');
+consttls=require('tls');
+
+constiter=10;
+constoverhead=30;
+
+constserver=tls.createServer({
+key: fixtures.readKey('agent2-key.pem'),
+cert: fixtures.readKey('agent2-cert.pem')
+},common.mustCall((socket)=>{
+socket.on('readable',common.mustCallAtLeast(()=>{
+socket.read();
+},1));
+
+socket.on('end',common.mustCall(()=>{
+server.close();
+}));
+}));
+
+server.listen(0,common.mustCall(()=>{
+constclient=tls.connect({
+port: server.address().port,
+rejectUnauthorized: false
+},common.mustCall(()=>{
+assert.strictEqual(client.bufferSize,0);
+
+for(leti=1;i<iter;i++){
+client.write('a');
+assert.strictEqual(client.bufferSize,i+overhead);
+}
+
+client.on('finish',common.mustCall(()=>{
+assert.strictEqual(client.bufferSize,0);
+}));
+
+client.end();
+}));
+}));