src: shave about 20 bytes off each TLSWrap instance

By shifting from individual bool fields to a packed struct
we can save 20 bytes per TLSWrap instance
Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: #65144
Reviewed-By: Tim Perry <pimterry@gmail.com>
Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>

Author: jasnell

src/crypto/crypto_tls.cc

@@ -240,7 +240,7 @@ int SelectALPNCallback(
 unsignedint inlen,
 void* arg) {
  TLSWrap* w = static_cast<TLSWrap*>(SSL_get_app_data(s));
-if (w->alpn_callback_enabled_) {
+if (w->get_alpn_callback_enabled()) {
  Environment* env = w->env();
  HandleScope handle_scope(env->isolate());
 
@@ -275,7 +275,7 @@ int SelectALPNCallback(
 returnSSL_TLSEXT_ERR_OK;
  }
 
-const std::vector<unsignedchar>& alpn_protos = w->alpn_protos_;
+auto& alpn_protos = w->get_alpn_protos();
 
 if (alpn_protos.empty()) returnSSL_TLSEXT_ERR_NOACK;
 
@@ -403,9 +403,9 @@ TLSWrap::TLSWrap(Environment* env,
 StreamBase(env),
  env_(env),
  kind_(kind),
- sc_(sc),
- has_active_write_issued_by_prev_listener_(
-under_stream_ws == UnderlyingStreamWriteStatus::kHasActive) {
+ sc_(sc) {
+flags_.has_active_write_issued_by_prev_listener =
+ under_stream_ws == UnderlyingStreamWriteStatus::kHasActive;
 MakeWeak();
 CHECK(sc_);
  ssl_ = sc_->CreateSSL();
@@ -444,8 +444,7 @@ SSL_SESSION* TLSWrap::ReleaseSession() {
 
 voidTLSWrap::InvokeQueued(int status, constchar* error_str) {
 Debug(this, "Invoking queued write callbacks (%d, %s)", status, error_str);
-if (!write_callback_scheduled_)
-return;
+if (!flags_.write_callback_scheduled) return;
 
 if (current_write_) {
  BaseObjectPtr<AsyncWrap> current_write = std::move(current_write_);
@@ -465,8 +464,8 @@ void TLSWrap::NewSessionDoneCb() {
 boolTLSWrap::OnEarlyClientHello(constunsignedchar* session_id,
 size_t session_id_len,
 bool has_ticket) {
-if (!hello_emitted_) {
-hello_emitted_ = true;
+if (!flags_.hello_emitted) {
+flags_.hello_emitted = true;
 Debug(this, "Scheduling onclienthello");
 
 // The hello data is only valid inside the library callback, and JS must
@@ -480,7 +479,7 @@ bool TLSWrap::OnEarlyClientHello(const unsigned char* session_id,
 if (ssl_) EmitClientHello(id, has_ticket);
  });
  }
-returnhello_answered_;
+returnflags_.hello_answered;
 }
 
 voidTLSWrap::EmitClientHello(const std::vector<unsignedchar>& session_id,
@@ -658,8 +657,8 @@ void TLSWrap::Start(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
 
-CHECK(!wrap->started_);
- wrap->started_ = true;
+CHECK(!wrap->flags_.started);
+ wrap->flags_.started = true;
 
 // Send ClientHello handshake
 CHECK(wrap->is_client());
@@ -703,7 +702,7 @@ void TLSWrap::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
 CHECK(!SSL_renegotiate_pending(ssl));
  Local<Value> callback;
 
- c->established_ = true;
+ c->flags_.established = true;
 
 if (object->Get(env->context(), env->onhandshakedone_string())
  .ToLocal(&callback) && callback->IsFunction()) {
@@ -727,17 +726,17 @@ void TLSWrap::EncOut() {
 return;
  }
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this,
 "Returning from EncOut(), "
 "has_active_write_issued_by_prev_listener_ is true");
 return;
  }
 
 // Split-off queue
-if (established_ && current_write_) {
+if (flags_.established && current_write_) {
 Debug(this, "EncOut() write is scheduled");
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
  }
 
 if (ssl_ == nullptr) {
@@ -750,7 +749,7 @@ void TLSWrap::EncOut() {
 Debug(this, "No pending encrypted output");
 if (!pending_cleartext_input_ ||
  pending_cleartext_input_->ByteLength() == 0) {
-if (!in_dowrite_) {
+if (!flags_.in_dowrite) {
 Debug(this, "No pending cleartext input, not inside DoWrite()");
 InvokeQueued(0);
  } else {
@@ -805,7 +804,7 @@ void TLSWrap::EncOut() {
 voidTLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 Debug(this, "OnStreamAfterWrite(status = %d)", status);
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this, "Notify write finish to the previous_listener_");
 CHECK_EQ(write_size_, 0); // we must have restrained writes
 
@@ -830,7 +829,7 @@ void TLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 
 // Handle error
 if (status) {
-if (shutdown_) {
+if (flags_.shutdown) {
 Debug(this, "Ignoring error after shutdown");
 return;
  }
@@ -855,7 +854,7 @@ void TLSWrap::ClearOut() {
 Debug(this, "Trying to read cleartext output");
 
 // No reads after EOF
-if (eof_) {
+if (flags_.eof) {
 Debug(this, "Returning from ClearOut(), EOF reached");
 return;
  }
@@ -911,8 +910,8 @@ void TLSWrap::ClearOut() {
 int err = SSL_get_error(ssl_.get(), read);
 switch (err) {
 caseSSL_ERROR_ZERO_RETURN:
-if (!eof_) {
-eof_ = true;
+if (!flags_.eof) {
+flags_.eof = true;
 EmitRead(UV_EOF);
  }
 return;
@@ -1005,7 +1004,7 @@ void TLSWrap::ClearIn() {
 int err = SSL_get_error(ssl_.get(), written);
 if (err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL) {
 Debug(this, "Got SSL error (%d)", err);
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 // TODO(@sam-github) Should forward an error object with
 // .code/.function/.etc, if possible.
 InvokeQueued(UV_EPROTO, GetBIOError().c_str());
@@ -1049,7 +1048,7 @@ bool TLSWrap::IsClosing() {
 
 intTLSWrap::ReadStart() {
 Debug(this, "ReadStart()");
-if (underlying_stream() != nullptr && !eof_)
+if (underlying_stream() != nullptr && !flags_.eof)
 returnunderlying_stream()->ReadStart();
 return0;
 }
@@ -1197,9 +1196,9 @@ int TLSWrap::DoWrite(WriteWrap* w,
 
 // Write any encrypted/handshake output that may be ready.
 // Guard against sync call of current_write_->Done(), its unsupported.
-in_dowrite_ = true;
+flags_.in_dowrite = true;
 EncOut();
-in_dowrite_ = false;
+flags_.in_dowrite = false;
 
 return0;
 }
@@ -1216,16 +1215,15 @@ void TLSWrap::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
 Debug(this, "Read %zd bytes from underlying stream", nread);
 
 // Ignore everything after close_notify (rfc5246#section-7.2.1)
-if (eof_)
-return;
+if (flags_.eof) return;
 
 if (nread < 0) {
 // Error should be emitted only after all data was read
 ClearOut();
 
 if (nread == UV_EOF) {
 // underlying stream already should have also called ReadStop on itself
-eof_ = true;
+flags_.eof = true;
  }
 
 EmitRead(nread);
@@ -1256,7 +1254,7 @@ int TLSWrap::DoShutdown(ShutdownWrap* req_wrap) {
 if (ssl_ && SSL_shutdown(ssl_.get()) == 0)
 SSL_shutdown(ssl_.get());
 
-shutdown_ = true;
+flags_.shutdown = true;
 EncOut();
 returnunderlying_stream()->DoShutdown(req_wrap);
 }
@@ -1352,7 +1350,7 @@ void TLSWrap::Destroy() {
 return;
 
 // If there is a write happening, mark it as finished.
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 
 // And destroy
 InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
@@ -1389,7 +1387,7 @@ void TLSWrap::ResumeAfterCertCb(void* arg) {
 voidTLSWrap::EnableALPNCb(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
- wrap->alpn_callback_enabled_ = true;
+ wrap->flags_.alpn_callback_enabled = true;
 
 SSL* ssl = wrap->ssl_.get();
 SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(ssl);
@@ -1418,7 +1416,7 @@ void TLSWrap::SetServername(const FunctionCallbackInfo<Value>& args) {
 
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsString());
-CHECK(!wrap->started_);
+CHECK(!wrap->flags_.started);
 CHECK(wrap->is_client());
 
 CHECK(wrap->ssl_);
@@ -1633,7 +1631,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
-CHECK(w->is_waiting_cert_cb() && w->cert_cb_running_);
+CHECK(w->is_waiting_cert_cb() && w->flags_.cert_cb_running);
 
  Local<Object> object = w->object();
  Local<Value> ctx = object->Get(env->context(), env->sni_context_string())
@@ -1685,7 +1683,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  cb = w->cert_cb_;
  arg = w->cert_cb_arg_;
 
- w->cert_cb_running_ = false;
+ w->flags_.cert_cb_running = false;
  w->cert_cb_ = nullptr;
  w->cert_cb_arg_ = nullptr;
 
@@ -2072,7 +2070,7 @@ void TLSWrap::ExportKeyingMaterial(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::ClientHelloDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->hello_answered_ = true;
+ w->flags_.hello_answered = true;
  w->Cycle();
 }
 
@@ -2107,7 +2105,7 @@ void TLSWrap::GetTLSTicket(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::NewSessionDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->awaiting_new_session_ = false;
+ w->flags_.awaiting_new_session = false;
  w->NewSessionDoneCb();
 }
 
@@ -2188,7 +2186,7 @@ void TLSWrap::WritesIssuedByPrevListenerDone(
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
 Debug(w, "WritesIssuedByPrevListenerDone is called");
- w->has_active_write_issued_by_prev_listener_ = false;
+ w->flags_.has_active_write_issued_by_prev_listener = false;
  w->EncOut(); // resume all of our restrained writes
 }
 

src/crypto/crypto_tls.h

@@ -62,22 +62,26 @@ class TLSWrap : public AsyncWrap,
 
 ~TLSWrap() override;
 
-inlineboolis_cert_cb_running() const { returncert_cb_running_; }
+inlineboolis_cert_cb_running() const { returnflags_.cert_cb_running; }
 inlineboolis_waiting_cert_cb() const { return cert_cb_ != nullptr; }
-inlineboolhas_session_callbacks() const { returnsession_callbacks_; }
+inlineboolhas_session_callbacks() const { returnflags_.session_callbacks; }
 // We need to suspend the ClientHello only for server session id
 // callbacks, and only on the first pass.
 inlineboolshould_suspend_for_client_hello() const {
-returnis_server() && session_callbacks_ && !hello_answered_;
+returnis_server() && flags_.session_callbacks && !flags_.hello_answered;
+ }
+inlinevoidset_cert_cb_running(bool on = true) {
+ flags_.cert_cb_running = on;
  }
-inlinevoidset_cert_cb_running(bool on = true) { cert_cb_running_ = on; }
 inlinevoidset_awaiting_new_session(bool on = true) {
-awaiting_new_session_ = on;
+flags_.awaiting_new_session = on;
  }
-inlinevoidenable_session_callbacks() { session_callbacks_ = true; }
+inlinevoidenable_session_callbacks() { flags_.session_callbacks = true; }
 inlineboolis_server() const { return kind_ == Kind::kServer; }
 inlineboolis_client() const { return kind_ == Kind::kClient; }
-inlineboolis_awaiting_new_session() const { return awaiting_new_session_; }
+inlineboolis_awaiting_new_session() const {
+return flags_.awaiting_new_session;
+ }
 
 // Implement StreamBase:
 boolIsAlive() override;
@@ -125,6 +129,14 @@ class TLSWrap : public AsyncWrap,
 
  std::string diagnostic_name() constoverride;
 
+boolget_alpn_callback_enabled() const {
+return flags_.alpn_callback_enabled;
+ }
+
+const std::vector<unsignedchar>& get_alpn_protos() const {
+return alpn_protos_;
+ }
+
 private:
 // OpenSSL structures are opaque. Estimate SSL memory size for OpenSSL 1.1.1b:
 // SSL: 6224
@@ -284,26 +296,30 @@ class TLSWrap : public AsyncWrap,
  BaseObjectPtr<AsyncWrap> current_empty_write_;
  std::string error_;
 
-bool session_callbacks_ = false;
-bool awaiting_new_session_ = false;
-// 'onclienthello' has been emitted for this connection.
-bool hello_emitted_ = false;
-// JS has answered it by calling clientHelloDone().
-bool hello_answered_ = false;
-bool in_dowrite_ = false;
-bool started_ = false;
-bool shutdown_ = false;
-bool cert_cb_running_ = false;
-bool eof_ = false;
-
 // TODO(@jasnell): These state flags should be revisited.
 // The established_ flag indicates that the handshake is
 // completed. The write_callback_scheduled_ flag is less
 // clear -- once it is set to true, it is never set to
 // false and it is only set to true after established_
 // is set to true, so it's likely redundant.
-bool established_ = false;
-bool write_callback_scheduled_ = false;
+structFlags {
+bool session_callbacks : 1;
+bool awaiting_new_session : 1;
+// 'onclienthello' has been emitted for this connection.
+bool hello_emitted : 1;
+// JS has answered it by calling clientHelloDone().
+bool hello_answered : 1;
+bool in_dowrite : 1;
+bool started : 1;
+bool shutdown : 1;
+bool cert_cb_running : 1;
+bool eof : 1;
+bool established : 1;
+bool write_callback_scheduled : 1;
+bool has_active_write_issued_by_prev_listener : 1;
+bool alpn_callback_enabled : 1;
+ };
+ Flags flags_{};
 
 int cycle_depth_ = 0;
 
@@ -313,11 +329,7 @@ class TLSWrap : public AsyncWrap,
 
  ncrypto::BIOPointer bio_trace_;
 
-bool has_active_write_issued_by_prev_listener_ = false;
-
-public:
  std::vector<unsignedchar> alpn_protos_; // Accessed by SelectALPNCallback.
-bool alpn_callback_enabled_ = false; // Accessed by SelectALPNCallback.
 };
 
 } // namespace crypto

src/crypto/crypto_tls.cc

@@ -240,7 +240,7 @@ int SelectALPNCallback(
 unsignedint inlen,
 void* arg) {
  TLSWrap* w = static_cast<TLSWrap*>(SSL_get_app_data(s));
-if (w->alpn_callback_enabled_) {
+if (w->get_alpn_callback_enabled()) {
  Environment* env = w->env();
  HandleScope handle_scope(env->isolate());
 
@@ -275,7 +275,7 @@ int SelectALPNCallback(
 returnSSL_TLSEXT_ERR_OK;
  }
 
-const std::vector<unsignedchar>& alpn_protos = w->alpn_protos_;
+auto& alpn_protos = w->get_alpn_protos();
 
 if (alpn_protos.empty()) returnSSL_TLSEXT_ERR_NOACK;
 
@@ -403,9 +403,9 @@ TLSWrap::TLSWrap(Environment* env,
 StreamBase(env),
  env_(env),
  kind_(kind),
- sc_(sc),
- has_active_write_issued_by_prev_listener_(
-under_stream_ws == UnderlyingStreamWriteStatus::kHasActive) {
+ sc_(sc) {
+flags_.has_active_write_issued_by_prev_listener =
+ under_stream_ws == UnderlyingStreamWriteStatus::kHasActive;
 MakeWeak();
 CHECK(sc_);
  ssl_ = sc_->CreateSSL();
@@ -444,8 +444,7 @@ SSL_SESSION* TLSWrap::ReleaseSession() {
 
 voidTLSWrap::InvokeQueued(int status, constchar* error_str) {
 Debug(this, "Invoking queued write callbacks (%d, %s)", status, error_str);
-if (!write_callback_scheduled_)
-return;
+if (!flags_.write_callback_scheduled) return;
 
 if (current_write_) {
  BaseObjectPtr<AsyncWrap> current_write = std::move(current_write_);
@@ -465,8 +464,8 @@ void TLSWrap::NewSessionDoneCb() {
 boolTLSWrap::OnEarlyClientHello(constunsignedchar* session_id,
 size_t session_id_len,
 bool has_ticket) {
-if (!hello_emitted_) {
-hello_emitted_ = true;
+if (!flags_.hello_emitted) {
+flags_.hello_emitted = true;
 Debug(this, "Scheduling onclienthello");
 
 // The hello data is only valid inside the library callback, and JS must
@@ -480,7 +479,7 @@ bool TLSWrap::OnEarlyClientHello(const unsigned char* session_id,
 if (ssl_) EmitClientHello(id, has_ticket);
  });
  }
-returnhello_answered_;
+returnflags_.hello_answered;
 }
 
 voidTLSWrap::EmitClientHello(const std::vector<unsignedchar>& session_id,
@@ -658,8 +657,8 @@ void TLSWrap::Start(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
 
-CHECK(!wrap->started_);
- wrap->started_ = true;
+CHECK(!wrap->flags_.started);
+ wrap->flags_.started = true;
 
 // Send ClientHello handshake
 CHECK(wrap->is_client());
@@ -703,7 +702,7 @@ void TLSWrap::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
 CHECK(!SSL_renegotiate_pending(ssl));
  Local<Value> callback;
 
- c->established_ = true;
+ c->flags_.established = true;
 
 if (object->Get(env->context(), env->onhandshakedone_string())
  .ToLocal(&callback) && callback->IsFunction()) {
@@ -727,17 +726,17 @@ void TLSWrap::EncOut() {
 return;
  }
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this,
 "Returning from EncOut(), "
 "has_active_write_issued_by_prev_listener_ is true");
 return;
  }
 
 // Split-off queue
-if (established_ && current_write_) {
+if (flags_.established && current_write_) {
 Debug(this, "EncOut() write is scheduled");
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
  }
 
 if (ssl_ == nullptr) {
@@ -750,7 +749,7 @@ void TLSWrap::EncOut() {
 Debug(this, "No pending encrypted output");
 if (!pending_cleartext_input_ ||
  pending_cleartext_input_->ByteLength() == 0) {
-if (!in_dowrite_) {
+if (!flags_.in_dowrite) {
 Debug(this, "No pending cleartext input, not inside DoWrite()");
 InvokeQueued(0);
  } else {
@@ -805,7 +804,7 @@ void TLSWrap::EncOut() {
 voidTLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 Debug(this, "OnStreamAfterWrite(status = %d)", status);
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this, "Notify write finish to the previous_listener_");
 CHECK_EQ(write_size_, 0); // we must have restrained writes
 
@@ -830,7 +829,7 @@ void TLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 
 // Handle error
 if (status) {
-if (shutdown_) {
+if (flags_.shutdown) {
 Debug(this, "Ignoring error after shutdown");
 return;
  }
@@ -855,7 +854,7 @@ void TLSWrap::ClearOut() {
 Debug(this, "Trying to read cleartext output");
 
 // No reads after EOF
-if (eof_) {
+if (flags_.eof) {
 Debug(this, "Returning from ClearOut(), EOF reached");
 return;
  }
@@ -911,8 +910,8 @@ void TLSWrap::ClearOut() {
 int err = SSL_get_error(ssl_.get(), read);
 switch (err) {
 caseSSL_ERROR_ZERO_RETURN:
-if (!eof_) {
-eof_ = true;
+if (!flags_.eof) {
+flags_.eof = true;
 EmitRead(UV_EOF);
  }
 return;
@@ -1005,7 +1004,7 @@ void TLSWrap::ClearIn() {
 int err = SSL_get_error(ssl_.get(), written);
 if (err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL) {
 Debug(this, "Got SSL error (%d)", err);
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 // TODO(@sam-github) Should forward an error object with
 // .code/.function/.etc, if possible.
 InvokeQueued(UV_EPROTO, GetBIOError().c_str());
@@ -1049,7 +1048,7 @@ bool TLSWrap::IsClosing() {
 
 intTLSWrap::ReadStart() {
 Debug(this, "ReadStart()");
-if (underlying_stream() != nullptr && !eof_)
+if (underlying_stream() != nullptr && !flags_.eof)
 returnunderlying_stream()->ReadStart();
 return0;
 }
@@ -1197,9 +1196,9 @@ int TLSWrap::DoWrite(WriteWrap* w,
 
 // Write any encrypted/handshake output that may be ready.
 // Guard against sync call of current_write_->Done(), its unsupported.
-in_dowrite_ = true;
+flags_.in_dowrite = true;
 EncOut();
-in_dowrite_ = false;
+flags_.in_dowrite = false;
 
 return0;
 }
@@ -1216,16 +1215,15 @@ void TLSWrap::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
 Debug(this, "Read %zd bytes from underlying stream", nread);
 
 // Ignore everything after close_notify (rfc5246#section-7.2.1)
-if (eof_)
-return;
+if (flags_.eof) return;
 
 if (nread < 0) {
 // Error should be emitted only after all data was read
 ClearOut();
 
 if (nread == UV_EOF) {
 // underlying stream already should have also called ReadStop on itself
-eof_ = true;
+flags_.eof = true;
  }
 
 EmitRead(nread);
@@ -1256,7 +1254,7 @@ int TLSWrap::DoShutdown(ShutdownWrap* req_wrap) {
 if (ssl_ && SSL_shutdown(ssl_.get()) == 0)
 SSL_shutdown(ssl_.get());
 
-shutdown_ = true;
+flags_.shutdown = true;
 EncOut();
 returnunderlying_stream()->DoShutdown(req_wrap);
 }
@@ -1352,7 +1350,7 @@ void TLSWrap::Destroy() {
 return;
 
 // If there is a write happening, mark it as finished.
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 
 // And destroy
 InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
@@ -1389,7 +1387,7 @@ void TLSWrap::ResumeAfterCertCb(void* arg) {
 voidTLSWrap::EnableALPNCb(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
- wrap->alpn_callback_enabled_ = true;
+ wrap->flags_.alpn_callback_enabled = true;
 
 SSL* ssl = wrap->ssl_.get();
 SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(ssl);
@@ -1418,7 +1416,7 @@ void TLSWrap::SetServername(const FunctionCallbackInfo<Value>& args) {
 
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsString());
-CHECK(!wrap->started_);
+CHECK(!wrap->flags_.started);
 CHECK(wrap->is_client());
 
 CHECK(wrap->ssl_);
@@ -1633,7 +1631,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
-CHECK(w->is_waiting_cert_cb() && w->cert_cb_running_);
+CHECK(w->is_waiting_cert_cb() && w->flags_.cert_cb_running);
 
  Local<Object> object = w->object();
  Local<Value> ctx = object->Get(env->context(), env->sni_context_string())
@@ -1685,7 +1683,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  cb = w->cert_cb_;
  arg = w->cert_cb_arg_;
 
- w->cert_cb_running_ = false;
+ w->flags_.cert_cb_running = false;
  w->cert_cb_ = nullptr;
  w->cert_cb_arg_ = nullptr;
 
@@ -2072,7 +2070,7 @@ void TLSWrap::ExportKeyingMaterial(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::ClientHelloDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->hello_answered_ = true;
+ w->flags_.hello_answered = true;
  w->Cycle();
 }
 
@@ -2107,7 +2105,7 @@ void TLSWrap::GetTLSTicket(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::NewSessionDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->awaiting_new_session_ = false;
+ w->flags_.awaiting_new_session = false;
  w->NewSessionDoneCb();
 }
 
@@ -2188,7 +2186,7 @@ void TLSWrap::WritesIssuedByPrevListenerDone(
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
 Debug(w, "WritesIssuedByPrevListenerDone is called");
- w->has_active_write_issued_by_prev_listener_ = false;
+ w->flags_.has_active_write_issued_by_prev_listener = false;
  w->EncOut(); // resume all of our restrained writes
 }
 

src/crypto/crypto_tls.h

@@ -62,22 +62,26 @@ class TLSWrap : public AsyncWrap,
 
 ~TLSWrap() override;
 
-inlineboolis_cert_cb_running() const { returncert_cb_running_; }
+inlineboolis_cert_cb_running() const { returnflags_.cert_cb_running; }
 inlineboolis_waiting_cert_cb() const { return cert_cb_ != nullptr; }
-inlineboolhas_session_callbacks() const { returnsession_callbacks_; }
+inlineboolhas_session_callbacks() const { returnflags_.session_callbacks; }
 // We need to suspend the ClientHello only for server session id
 // callbacks, and only on the first pass.
 inlineboolshould_suspend_for_client_hello() const {
-returnis_server() && session_callbacks_ && !hello_answered_;
+returnis_server() && flags_.session_callbacks && !flags_.hello_answered;
+ }
+inlinevoidset_cert_cb_running(bool on = true) {
+ flags_.cert_cb_running = on;
  }
-inlinevoidset_cert_cb_running(bool on = true) { cert_cb_running_ = on; }
 inlinevoidset_awaiting_new_session(bool on = true) {
-awaiting_new_session_ = on;
+flags_.awaiting_new_session = on;
  }
-inlinevoidenable_session_callbacks() { session_callbacks_ = true; }
+inlinevoidenable_session_callbacks() { flags_.session_callbacks = true; }
 inlineboolis_server() const { return kind_ == Kind::kServer; }
 inlineboolis_client() const { return kind_ == Kind::kClient; }
-inlineboolis_awaiting_new_session() const { return awaiting_new_session_; }
+inlineboolis_awaiting_new_session() const {
+return flags_.awaiting_new_session;
+ }
 
 // Implement StreamBase:
 boolIsAlive() override;
@@ -125,6 +129,14 @@ class TLSWrap : public AsyncWrap,
 
  std::string diagnostic_name() constoverride;
 
+boolget_alpn_callback_enabled() const {
+return flags_.alpn_callback_enabled;
+ }
+
+const std::vector<unsignedchar>& get_alpn_protos() const {
+return alpn_protos_;
+ }
+
 private:
 // OpenSSL structures are opaque. Estimate SSL memory size for OpenSSL 1.1.1b:
 // SSL: 6224
@@ -284,26 +296,30 @@ class TLSWrap : public AsyncWrap,
  BaseObjectPtr<AsyncWrap> current_empty_write_;
  std::string error_;
 
-bool session_callbacks_ = false;
-bool awaiting_new_session_ = false;
-// 'onclienthello' has been emitted for this connection.
-bool hello_emitted_ = false;
-// JS has answered it by calling clientHelloDone().
-bool hello_answered_ = false;
-bool in_dowrite_ = false;
-bool started_ = false;
-bool shutdown_ = false;
-bool cert_cb_running_ = false;
-bool eof_ = false;
-
 // TODO(@jasnell): These state flags should be revisited.
 // The established_ flag indicates that the handshake is
 // completed. The write_callback_scheduled_ flag is less
 // clear -- once it is set to true, it is never set to
 // false and it is only set to true after established_
 // is set to true, so it's likely redundant.
-bool established_ = false;
-bool write_callback_scheduled_ = false;
+structFlags {
+bool session_callbacks : 1;
+bool awaiting_new_session : 1;
+// 'onclienthello' has been emitted for this connection.
+bool hello_emitted : 1;
+// JS has answered it by calling clientHelloDone().
+bool hello_answered : 1;
+bool in_dowrite : 1;
+bool started : 1;
+bool shutdown : 1;
+bool cert_cb_running : 1;
+bool eof : 1;
+bool established : 1;
+bool write_callback_scheduled : 1;
+bool has_active_write_issued_by_prev_listener : 1;
+bool alpn_callback_enabled : 1;
+ };
+ Flags flags_{};
 
 int cycle_depth_ = 0;
 
@@ -313,11 +329,7 @@ class TLSWrap : public AsyncWrap,
 
  ncrypto::BIOPointer bio_trace_;
 
-bool has_active_write_issued_by_prev_listener_ = false;
-
-public:
  std::vector<unsignedchar> alpn_protos_; // Accessed by SelectALPNCallback.
-bool alpn_callback_enabled_ = false; // Accessed by SelectALPNCallback.
 };
 
 } // namespace crypto

src/crypto/crypto_tls.cc

@@ -240,7 +240,7 @@ int SelectALPNCallback(
 unsignedint inlen,
 void* arg) {
  TLSWrap* w = static_cast<TLSWrap*>(SSL_get_app_data(s));
-if (w->alpn_callback_enabled_) {
+if (w->get_alpn_callback_enabled()) {
  Environment* env = w->env();
  HandleScope handle_scope(env->isolate());
 
@@ -275,7 +275,7 @@ int SelectALPNCallback(
 returnSSL_TLSEXT_ERR_OK;
  }
 
-const std::vector<unsignedchar>& alpn_protos = w->alpn_protos_;
+auto& alpn_protos = w->get_alpn_protos();
 
 if (alpn_protos.empty()) returnSSL_TLSEXT_ERR_NOACK;
 
@@ -403,9 +403,9 @@ TLSWrap::TLSWrap(Environment* env,
 StreamBase(env),
  env_(env),
  kind_(kind),
- sc_(sc),
- has_active_write_issued_by_prev_listener_(
-under_stream_ws == UnderlyingStreamWriteStatus::kHasActive) {
+ sc_(sc) {
+flags_.has_active_write_issued_by_prev_listener =
+ under_stream_ws == UnderlyingStreamWriteStatus::kHasActive;
 MakeWeak();
 CHECK(sc_);
  ssl_ = sc_->CreateSSL();
@@ -444,8 +444,7 @@ SSL_SESSION* TLSWrap::ReleaseSession() {
 
 voidTLSWrap::InvokeQueued(int status, constchar* error_str) {
 Debug(this, "Invoking queued write callbacks (%d, %s)", status, error_str);
-if (!write_callback_scheduled_)
-return;
+if (!flags_.write_callback_scheduled) return;
 
 if (current_write_) {
  BaseObjectPtr<AsyncWrap> current_write = std::move(current_write_);
@@ -465,8 +464,8 @@ void TLSWrap::NewSessionDoneCb() {
 boolTLSWrap::OnEarlyClientHello(constunsignedchar* session_id,
 size_t session_id_len,
 bool has_ticket) {
-if (!hello_emitted_) {
-hello_emitted_ = true;
+if (!flags_.hello_emitted) {
+flags_.hello_emitted = true;
 Debug(this, "Scheduling onclienthello");
 
 // The hello data is only valid inside the library callback, and JS must
@@ -480,7 +479,7 @@ bool TLSWrap::OnEarlyClientHello(const unsigned char* session_id,
 if (ssl_) EmitClientHello(id, has_ticket);
  });
  }
-returnhello_answered_;
+returnflags_.hello_answered;
 }
 
 voidTLSWrap::EmitClientHello(const std::vector<unsignedchar>& session_id,
@@ -658,8 +657,8 @@ void TLSWrap::Start(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
 
-CHECK(!wrap->started_);
- wrap->started_ = true;
+CHECK(!wrap->flags_.started);
+ wrap->flags_.started = true;
 
 // Send ClientHello handshake
 CHECK(wrap->is_client());
@@ -703,7 +702,7 @@ void TLSWrap::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
 CHECK(!SSL_renegotiate_pending(ssl));
  Local<Value> callback;
 
- c->established_ = true;
+ c->flags_.established = true;
 
 if (object->Get(env->context(), env->onhandshakedone_string())
  .ToLocal(&callback) && callback->IsFunction()) {
@@ -727,17 +726,17 @@ void TLSWrap::EncOut() {
 return;
  }
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this,
 "Returning from EncOut(), "
 "has_active_write_issued_by_prev_listener_ is true");
 return;
  }
 
 // Split-off queue
-if (established_ && current_write_) {
+if (flags_.established && current_write_) {
 Debug(this, "EncOut() write is scheduled");
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
  }
 
 if (ssl_ == nullptr) {
@@ -750,7 +749,7 @@ void TLSWrap::EncOut() {
 Debug(this, "No pending encrypted output");
 if (!pending_cleartext_input_ ||
  pending_cleartext_input_->ByteLength() == 0) {
-if (!in_dowrite_) {
+if (!flags_.in_dowrite) {
 Debug(this, "No pending cleartext input, not inside DoWrite()");
 InvokeQueued(0);
  } else {
@@ -805,7 +804,7 @@ void TLSWrap::EncOut() {
 voidTLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 Debug(this, "OnStreamAfterWrite(status = %d)", status);
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this, "Notify write finish to the previous_listener_");
 CHECK_EQ(write_size_, 0); // we must have restrained writes
 
@@ -830,7 +829,7 @@ void TLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 
 // Handle error
 if (status) {
-if (shutdown_) {
+if (flags_.shutdown) {
 Debug(this, "Ignoring error after shutdown");
 return;
  }
@@ -855,7 +854,7 @@ void TLSWrap::ClearOut() {
 Debug(this, "Trying to read cleartext output");
 
 // No reads after EOF
-if (eof_) {
+if (flags_.eof) {
 Debug(this, "Returning from ClearOut(), EOF reached");
 return;
  }
@@ -911,8 +910,8 @@ void TLSWrap::ClearOut() {
 int err = SSL_get_error(ssl_.get(), read);
 switch (err) {
 caseSSL_ERROR_ZERO_RETURN:
-if (!eof_) {
-eof_ = true;
+if (!flags_.eof) {
+flags_.eof = true;
 EmitRead(UV_EOF);
  }
 return;
@@ -1005,7 +1004,7 @@ void TLSWrap::ClearIn() {
 int err = SSL_get_error(ssl_.get(), written);
 if (err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL) {
 Debug(this, "Got SSL error (%d)", err);
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 // TODO(@sam-github) Should forward an error object with
 // .code/.function/.etc, if possible.
 InvokeQueued(UV_EPROTO, GetBIOError().c_str());
@@ -1049,7 +1048,7 @@ bool TLSWrap::IsClosing() {
 
 intTLSWrap::ReadStart() {
 Debug(this, "ReadStart()");
-if (underlying_stream() != nullptr && !eof_)
+if (underlying_stream() != nullptr && !flags_.eof)
 returnunderlying_stream()->ReadStart();
 return0;
 }
@@ -1197,9 +1196,9 @@ int TLSWrap::DoWrite(WriteWrap* w,
 
 // Write any encrypted/handshake output that may be ready.
 // Guard against sync call of current_write_->Done(), its unsupported.
-in_dowrite_ = true;
+flags_.in_dowrite = true;
 EncOut();
-in_dowrite_ = false;
+flags_.in_dowrite = false;
 
 return0;
 }
@@ -1216,16 +1215,15 @@ void TLSWrap::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
 Debug(this, "Read %zd bytes from underlying stream", nread);
 
 // Ignore everything after close_notify (rfc5246#section-7.2.1)
-if (eof_)
-return;
+if (flags_.eof) return;
 
 if (nread < 0) {
 // Error should be emitted only after all data was read
 ClearOut();
 
 if (nread == UV_EOF) {
 // underlying stream already should have also called ReadStop on itself
-eof_ = true;
+flags_.eof = true;
  }
 
 EmitRead(nread);
@@ -1256,7 +1254,7 @@ int TLSWrap::DoShutdown(ShutdownWrap* req_wrap) {
 if (ssl_ && SSL_shutdown(ssl_.get()) == 0)
 SSL_shutdown(ssl_.get());
 
-shutdown_ = true;
+flags_.shutdown = true;
 EncOut();
 returnunderlying_stream()->DoShutdown(req_wrap);
 }
@@ -1352,7 +1350,7 @@ void TLSWrap::Destroy() {
 return;
 
 // If there is a write happening, mark it as finished.
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 
 // And destroy
 InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
@@ -1389,7 +1387,7 @@ void TLSWrap::ResumeAfterCertCb(void* arg) {
 voidTLSWrap::EnableALPNCb(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
- wrap->alpn_callback_enabled_ = true;
+ wrap->flags_.alpn_callback_enabled = true;
 
 SSL* ssl = wrap->ssl_.get();
 SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(ssl);
@@ -1418,7 +1416,7 @@ void TLSWrap::SetServername(const FunctionCallbackInfo<Value>& args) {
 
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsString());
-CHECK(!wrap->started_);
+CHECK(!wrap->flags_.started);
 CHECK(wrap->is_client());
 
 CHECK(wrap->ssl_);
@@ -1633,7 +1631,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
-CHECK(w->is_waiting_cert_cb() && w->cert_cb_running_);
+CHECK(w->is_waiting_cert_cb() && w->flags_.cert_cb_running);
 
  Local<Object> object = w->object();
  Local<Value> ctx = object->Get(env->context(), env->sni_context_string())
@@ -1685,7 +1683,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  cb = w->cert_cb_;
  arg = w->cert_cb_arg_;
 
- w->cert_cb_running_ = false;
+ w->flags_.cert_cb_running = false;
  w->cert_cb_ = nullptr;
  w->cert_cb_arg_ = nullptr;
 
@@ -2072,7 +2070,7 @@ void TLSWrap::ExportKeyingMaterial(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::ClientHelloDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->hello_answered_ = true;
+ w->flags_.hello_answered = true;
  w->Cycle();
 }
 
@@ -2107,7 +2105,7 @@ void TLSWrap::GetTLSTicket(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::NewSessionDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->awaiting_new_session_ = false;
+ w->flags_.awaiting_new_session = false;
  w->NewSessionDoneCb();
 }
 
@@ -2188,7 +2186,7 @@ void TLSWrap::WritesIssuedByPrevListenerDone(
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
 Debug(w, "WritesIssuedByPrevListenerDone is called");
- w->has_active_write_issued_by_prev_listener_ = false;
+ w->flags_.has_active_write_issued_by_prev_listener = false;
  w->EncOut(); // resume all of our restrained writes
 }
 

src/crypto/crypto_tls.h

@@ -62,22 +62,26 @@ class TLSWrap : public AsyncWrap,
 
 ~TLSWrap() override;
 
-inlineboolis_cert_cb_running() const { returncert_cb_running_; }
+inlineboolis_cert_cb_running() const { returnflags_.cert_cb_running; }
 inlineboolis_waiting_cert_cb() const { return cert_cb_ != nullptr; }
-inlineboolhas_session_callbacks() const { returnsession_callbacks_; }
+inlineboolhas_session_callbacks() const { returnflags_.session_callbacks; }
 // We need to suspend the ClientHello only for server session id
 // callbacks, and only on the first pass.
 inlineboolshould_suspend_for_client_hello() const {
-returnis_server() && session_callbacks_ && !hello_answered_;
+returnis_server() && flags_.session_callbacks && !flags_.hello_answered;
+ }
+inlinevoidset_cert_cb_running(bool on = true) {
+ flags_.cert_cb_running = on;
  }
-inlinevoidset_cert_cb_running(bool on = true) { cert_cb_running_ = on; }
 inlinevoidset_awaiting_new_session(bool on = true) {
-awaiting_new_session_ = on;
+flags_.awaiting_new_session = on;
  }
-inlinevoidenable_session_callbacks() { session_callbacks_ = true; }
+inlinevoidenable_session_callbacks() { flags_.session_callbacks = true; }
 inlineboolis_server() const { return kind_ == Kind::kServer; }
 inlineboolis_client() const { return kind_ == Kind::kClient; }
-inlineboolis_awaiting_new_session() const { return awaiting_new_session_; }
+inlineboolis_awaiting_new_session() const {
+return flags_.awaiting_new_session;
+ }
 
 // Implement StreamBase:
 boolIsAlive() override;
@@ -125,6 +129,14 @@ class TLSWrap : public AsyncWrap,
 
  std::string diagnostic_name() constoverride;
 
+boolget_alpn_callback_enabled() const {
+return flags_.alpn_callback_enabled;
+ }
+
+const std::vector<unsignedchar>& get_alpn_protos() const {
+return alpn_protos_;
+ }
+
 private:
 // OpenSSL structures are opaque. Estimate SSL memory size for OpenSSL 1.1.1b:
 // SSL: 6224
@@ -284,26 +296,30 @@ class TLSWrap : public AsyncWrap,
  BaseObjectPtr<AsyncWrap> current_empty_write_;
  std::string error_;
 
-bool session_callbacks_ = false;
-bool awaiting_new_session_ = false;
-// 'onclienthello' has been emitted for this connection.
-bool hello_emitted_ = false;
-// JS has answered it by calling clientHelloDone().
-bool hello_answered_ = false;
-bool in_dowrite_ = false;
-bool started_ = false;
-bool shutdown_ = false;
-bool cert_cb_running_ = false;
-bool eof_ = false;
-
 // TODO(@jasnell): These state flags should be revisited.
 // The established_ flag indicates that the handshake is
 // completed. The write_callback_scheduled_ flag is less
 // clear -- once it is set to true, it is never set to
 // false and it is only set to true after established_
 // is set to true, so it's likely redundant.
-bool established_ = false;
-bool write_callback_scheduled_ = false;
+structFlags {
+bool session_callbacks : 1;
+bool awaiting_new_session : 1;
+// 'onclienthello' has been emitted for this connection.
+bool hello_emitted : 1;
+// JS has answered it by calling clientHelloDone().
+bool hello_answered : 1;
+bool in_dowrite : 1;
+bool started : 1;
+bool shutdown : 1;
+bool cert_cb_running : 1;
+bool eof : 1;
+bool established : 1;
+bool write_callback_scheduled : 1;
+bool has_active_write_issued_by_prev_listener : 1;
+bool alpn_callback_enabled : 1;
+ };
+ Flags flags_{};
 
 int cycle_depth_ = 0;
 
@@ -313,11 +329,7 @@ class TLSWrap : public AsyncWrap,
 
  ncrypto::BIOPointer bio_trace_;
 
-bool has_active_write_issued_by_prev_listener_ = false;
-
-public:
  std::vector<unsignedchar> alpn_protos_; // Accessed by SelectALPNCallback.
-bool alpn_callback_enabled_ = false; // Accessed by SelectALPNCallback.
 };
 
 } // namespace crypto

src/crypto/crypto_tls.cc

@@ -240,7 +240,7 @@ int SelectALPNCallback(
 unsignedint inlen,
 void* arg) {
  TLSWrap* w = static_cast<TLSWrap*>(SSL_get_app_data(s));
-if (w->alpn_callback_enabled_) {
+if (w->get_alpn_callback_enabled()) {
  Environment* env = w->env();
  HandleScope handle_scope(env->isolate());
 
@@ -275,7 +275,7 @@ int SelectALPNCallback(
 returnSSL_TLSEXT_ERR_OK;
  }
 
-const std::vector<unsignedchar>& alpn_protos = w->alpn_protos_;
+auto& alpn_protos = w->get_alpn_protos();
 
 if (alpn_protos.empty()) returnSSL_TLSEXT_ERR_NOACK;
 
@@ -403,9 +403,9 @@ TLSWrap::TLSWrap(Environment* env,
 StreamBase(env),
  env_(env),
  kind_(kind),
- sc_(sc),
- has_active_write_issued_by_prev_listener_(
-under_stream_ws == UnderlyingStreamWriteStatus::kHasActive) {
+ sc_(sc) {
+flags_.has_active_write_issued_by_prev_listener =
+ under_stream_ws == UnderlyingStreamWriteStatus::kHasActive;
 MakeWeak();
 CHECK(sc_);
  ssl_ = sc_->CreateSSL();
@@ -444,8 +444,7 @@ SSL_SESSION* TLSWrap::ReleaseSession() {
 
 voidTLSWrap::InvokeQueued(int status, constchar* error_str) {
 Debug(this, "Invoking queued write callbacks (%d, %s)", status, error_str);
-if (!write_callback_scheduled_)
-return;
+if (!flags_.write_callback_scheduled) return;
 
 if (current_write_) {
  BaseObjectPtr<AsyncWrap> current_write = std::move(current_write_);
@@ -465,8 +464,8 @@ void TLSWrap::NewSessionDoneCb() {
 boolTLSWrap::OnEarlyClientHello(constunsignedchar* session_id,
 size_t session_id_len,
 bool has_ticket) {
-if (!hello_emitted_) {
-hello_emitted_ = true;
+if (!flags_.hello_emitted) {
+flags_.hello_emitted = true;
 Debug(this, "Scheduling onclienthello");
 
 // The hello data is only valid inside the library callback, and JS must
@@ -480,7 +479,7 @@ bool TLSWrap::OnEarlyClientHello(const unsigned char* session_id,
 if (ssl_) EmitClientHello(id, has_ticket);
  });
  }
-returnhello_answered_;
+returnflags_.hello_answered;
 }
 
 voidTLSWrap::EmitClientHello(const std::vector<unsignedchar>& session_id,
@@ -658,8 +657,8 @@ void TLSWrap::Start(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
 
-CHECK(!wrap->started_);
- wrap->started_ = true;
+CHECK(!wrap->flags_.started);
+ wrap->flags_.started = true;
 
 // Send ClientHello handshake
 CHECK(wrap->is_client());
@@ -703,7 +702,7 @@ void TLSWrap::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
 CHECK(!SSL_renegotiate_pending(ssl));
  Local<Value> callback;
 
- c->established_ = true;
+ c->flags_.established = true;
 
 if (object->Get(env->context(), env->onhandshakedone_string())
  .ToLocal(&callback) && callback->IsFunction()) {
@@ -727,17 +726,17 @@ void TLSWrap::EncOut() {
 return;
  }
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this,
 "Returning from EncOut(), "
 "has_active_write_issued_by_prev_listener_ is true");
 return;
  }
 
 // Split-off queue
-if (established_ && current_write_) {
+if (flags_.established && current_write_) {
 Debug(this, "EncOut() write is scheduled");
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
  }
 
 if (ssl_ == nullptr) {
@@ -750,7 +749,7 @@ void TLSWrap::EncOut() {
 Debug(this, "No pending encrypted output");
 if (!pending_cleartext_input_ ||
  pending_cleartext_input_->ByteLength() == 0) {
-if (!in_dowrite_) {
+if (!flags_.in_dowrite) {
 Debug(this, "No pending cleartext input, not inside DoWrite()");
 InvokeQueued(0);
  } else {
@@ -805,7 +804,7 @@ void TLSWrap::EncOut() {
 voidTLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 Debug(this, "OnStreamAfterWrite(status = %d)", status);
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this, "Notify write finish to the previous_listener_");
 CHECK_EQ(write_size_, 0); // we must have restrained writes
 
@@ -830,7 +829,7 @@ void TLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 
 // Handle error
 if (status) {
-if (shutdown_) {
+if (flags_.shutdown) {
 Debug(this, "Ignoring error after shutdown");
 return;
  }
@@ -855,7 +854,7 @@ void TLSWrap::ClearOut() {
 Debug(this, "Trying to read cleartext output");
 
 // No reads after EOF
-if (eof_) {
+if (flags_.eof) {
 Debug(this, "Returning from ClearOut(), EOF reached");
 return;
  }
@@ -911,8 +910,8 @@ void TLSWrap::ClearOut() {
 int err = SSL_get_error(ssl_.get(), read);
 switch (err) {
 caseSSL_ERROR_ZERO_RETURN:
-if (!eof_) {
-eof_ = true;
+if (!flags_.eof) {
+flags_.eof = true;
 EmitRead(UV_EOF);
  }
 return;
@@ -1005,7 +1004,7 @@ void TLSWrap::ClearIn() {
 int err = SSL_get_error(ssl_.get(), written);
 if (err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL) {
 Debug(this, "Got SSL error (%d)", err);
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 // TODO(@sam-github) Should forward an error object with
 // .code/.function/.etc, if possible.
 InvokeQueued(UV_EPROTO, GetBIOError().c_str());
@@ -1049,7 +1048,7 @@ bool TLSWrap::IsClosing() {
 
 intTLSWrap::ReadStart() {
 Debug(this, "ReadStart()");
-if (underlying_stream() != nullptr && !eof_)
+if (underlying_stream() != nullptr && !flags_.eof)
 returnunderlying_stream()->ReadStart();
 return0;
 }
@@ -1197,9 +1196,9 @@ int TLSWrap::DoWrite(WriteWrap* w,
 
 // Write any encrypted/handshake output that may be ready.
 // Guard against sync call of current_write_->Done(), its unsupported.
-in_dowrite_ = true;
+flags_.in_dowrite = true;
 EncOut();
-in_dowrite_ = false;
+flags_.in_dowrite = false;
 
 return0;
 }
@@ -1216,16 +1215,15 @@ void TLSWrap::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
 Debug(this, "Read %zd bytes from underlying stream", nread);
 
 // Ignore everything after close_notify (rfc5246#section-7.2.1)
-if (eof_)
-return;
+if (flags_.eof) return;
 
 if (nread < 0) {
 // Error should be emitted only after all data was read
 ClearOut();
 
 if (nread == UV_EOF) {
 // underlying stream already should have also called ReadStop on itself
-eof_ = true;
+flags_.eof = true;
  }
 
 EmitRead(nread);
@@ -1256,7 +1254,7 @@ int TLSWrap::DoShutdown(ShutdownWrap* req_wrap) {
 if (ssl_ && SSL_shutdown(ssl_.get()) == 0)
 SSL_shutdown(ssl_.get());
 
-shutdown_ = true;
+flags_.shutdown = true;
 EncOut();
 returnunderlying_stream()->DoShutdown(req_wrap);
 }
@@ -1352,7 +1350,7 @@ void TLSWrap::Destroy() {
 return;
 
 // If there is a write happening, mark it as finished.
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 
 // And destroy
 InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
@@ -1389,7 +1387,7 @@ void TLSWrap::ResumeAfterCertCb(void* arg) {
 voidTLSWrap::EnableALPNCb(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
- wrap->alpn_callback_enabled_ = true;
+ wrap->flags_.alpn_callback_enabled = true;
 
 SSL* ssl = wrap->ssl_.get();
 SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(ssl);
@@ -1418,7 +1416,7 @@ void TLSWrap::SetServername(const FunctionCallbackInfo<Value>& args) {
 
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsString());
-CHECK(!wrap->started_);
+CHECK(!wrap->flags_.started);
 CHECK(wrap->is_client());
 
 CHECK(wrap->ssl_);
@@ -1633,7 +1631,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
-CHECK(w->is_waiting_cert_cb() && w->cert_cb_running_);
+CHECK(w->is_waiting_cert_cb() && w->flags_.cert_cb_running);
 
  Local<Object> object = w->object();
  Local<Value> ctx = object->Get(env->context(), env->sni_context_string())
@@ -1685,7 +1683,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  cb = w->cert_cb_;
  arg = w->cert_cb_arg_;
 
- w->cert_cb_running_ = false;
+ w->flags_.cert_cb_running = false;
  w->cert_cb_ = nullptr;
  w->cert_cb_arg_ = nullptr;
 
@@ -2072,7 +2070,7 @@ void TLSWrap::ExportKeyingMaterial(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::ClientHelloDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->hello_answered_ = true;
+ w->flags_.hello_answered = true;
  w->Cycle();
 }
 
@@ -2107,7 +2105,7 @@ void TLSWrap::GetTLSTicket(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::NewSessionDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->awaiting_new_session_ = false;
+ w->flags_.awaiting_new_session = false;
  w->NewSessionDoneCb();
 }
 
@@ -2188,7 +2186,7 @@ void TLSWrap::WritesIssuedByPrevListenerDone(
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
 Debug(w, "WritesIssuedByPrevListenerDone is called");
- w->has_active_write_issued_by_prev_listener_ = false;
+ w->flags_.has_active_write_issued_by_prev_listener = false;
  w->EncOut(); // resume all of our restrained writes
 }
 

src/crypto/crypto_tls.h

@@ -62,22 +62,26 @@ class TLSWrap : public AsyncWrap,
 
 ~TLSWrap() override;
 
-inlineboolis_cert_cb_running() const { returncert_cb_running_; }
+inlineboolis_cert_cb_running() const { returnflags_.cert_cb_running; }
 inlineboolis_waiting_cert_cb() const { return cert_cb_ != nullptr; }
-inlineboolhas_session_callbacks() const { returnsession_callbacks_; }
+inlineboolhas_session_callbacks() const { returnflags_.session_callbacks; }
 // We need to suspend the ClientHello only for server session id
 // callbacks, and only on the first pass.
 inlineboolshould_suspend_for_client_hello() const {
-returnis_server() && session_callbacks_ && !hello_answered_;
+returnis_server() && flags_.session_callbacks && !flags_.hello_answered;
+ }
+inlinevoidset_cert_cb_running(bool on = true) {
+ flags_.cert_cb_running = on;
  }
-inlinevoidset_cert_cb_running(bool on = true) { cert_cb_running_ = on; }
 inlinevoidset_awaiting_new_session(bool on = true) {
-awaiting_new_session_ = on;
+flags_.awaiting_new_session = on;
  }
-inlinevoidenable_session_callbacks() { session_callbacks_ = true; }
+inlinevoidenable_session_callbacks() { flags_.session_callbacks = true; }
 inlineboolis_server() const { return kind_ == Kind::kServer; }
 inlineboolis_client() const { return kind_ == Kind::kClient; }
-inlineboolis_awaiting_new_session() const { return awaiting_new_session_; }
+inlineboolis_awaiting_new_session() const {
+return flags_.awaiting_new_session;
+ }
 
 // Implement StreamBase:
 boolIsAlive() override;
@@ -125,6 +129,14 @@ class TLSWrap : public AsyncWrap,
 
  std::string diagnostic_name() constoverride;
 
+boolget_alpn_callback_enabled() const {
+return flags_.alpn_callback_enabled;
+ }
+
+const std::vector<unsignedchar>& get_alpn_protos() const {
+return alpn_protos_;
+ }
+
 private:
 // OpenSSL structures are opaque. Estimate SSL memory size for OpenSSL 1.1.1b:
 // SSL: 6224
@@ -284,26 +296,30 @@ class TLSWrap : public AsyncWrap,
  BaseObjectPtr<AsyncWrap> current_empty_write_;
  std::string error_;
 
-bool session_callbacks_ = false;
-bool awaiting_new_session_ = false;
-// 'onclienthello' has been emitted for this connection.
-bool hello_emitted_ = false;
-// JS has answered it by calling clientHelloDone().
-bool hello_answered_ = false;
-bool in_dowrite_ = false;
-bool started_ = false;
-bool shutdown_ = false;
-bool cert_cb_running_ = false;
-bool eof_ = false;
-
 // TODO(@jasnell): These state flags should be revisited.
 // The established_ flag indicates that the handshake is
 // completed. The write_callback_scheduled_ flag is less
 // clear -- once it is set to true, it is never set to
 // false and it is only set to true after established_
 // is set to true, so it's likely redundant.
-bool established_ = false;
-bool write_callback_scheduled_ = false;
+structFlags {
+bool session_callbacks : 1;
+bool awaiting_new_session : 1;
+// 'onclienthello' has been emitted for this connection.
+bool hello_emitted : 1;
+// JS has answered it by calling clientHelloDone().
+bool hello_answered : 1;
+bool in_dowrite : 1;
+bool started : 1;
+bool shutdown : 1;
+bool cert_cb_running : 1;
+bool eof : 1;
+bool established : 1;
+bool write_callback_scheduled : 1;
+bool has_active_write_issued_by_prev_listener : 1;
+bool alpn_callback_enabled : 1;
+ };
+ Flags flags_{};
 
 int cycle_depth_ = 0;
 
@@ -313,11 +329,7 @@ class TLSWrap : public AsyncWrap,
 
  ncrypto::BIOPointer bio_trace_;
 
-bool has_active_write_issued_by_prev_listener_ = false;
-
-public:
  std::vector<unsignedchar> alpn_protos_; // Accessed by SelectALPNCallback.
-bool alpn_callback_enabled_ = false; // Accessed by SelectALPNCallback.
 };
 
 } // namespace crypto

src/crypto/crypto_tls.cc

@@ -240,7 +240,7 @@ int SelectALPNCallback(
 unsignedint inlen,
 void* arg) {
  TLSWrap* w = static_cast<TLSWrap*>(SSL_get_app_data(s));
-if (w->alpn_callback_enabled_) {
+if (w->get_alpn_callback_enabled()) {
  Environment* env = w->env();
  HandleScope handle_scope(env->isolate());
 
@@ -275,7 +275,7 @@ int SelectALPNCallback(
 returnSSL_TLSEXT_ERR_OK;
  }
 
-const std::vector<unsignedchar>& alpn_protos = w->alpn_protos_;
+auto& alpn_protos = w->get_alpn_protos();
 
 if (alpn_protos.empty()) returnSSL_TLSEXT_ERR_NOACK;
 
@@ -403,9 +403,9 @@ TLSWrap::TLSWrap(Environment* env,
 StreamBase(env),
  env_(env),
  kind_(kind),
- sc_(sc),
- has_active_write_issued_by_prev_listener_(
-under_stream_ws == UnderlyingStreamWriteStatus::kHasActive) {
+ sc_(sc) {
+flags_.has_active_write_issued_by_prev_listener =
+ under_stream_ws == UnderlyingStreamWriteStatus::kHasActive;
 MakeWeak();
 CHECK(sc_);
  ssl_ = sc_->CreateSSL();
@@ -444,8 +444,7 @@ SSL_SESSION* TLSWrap::ReleaseSession() {
 
 voidTLSWrap::InvokeQueued(int status, constchar* error_str) {
 Debug(this, "Invoking queued write callbacks (%d, %s)", status, error_str);
-if (!write_callback_scheduled_)
-return;
+if (!flags_.write_callback_scheduled) return;
 
 if (current_write_) {
  BaseObjectPtr<AsyncWrap> current_write = std::move(current_write_);
@@ -465,8 +464,8 @@ void TLSWrap::NewSessionDoneCb() {
 boolTLSWrap::OnEarlyClientHello(constunsignedchar* session_id,
 size_t session_id_len,
 bool has_ticket) {
-if (!hello_emitted_) {
-hello_emitted_ = true;
+if (!flags_.hello_emitted) {
+flags_.hello_emitted = true;
 Debug(this, "Scheduling onclienthello");
 
 // The hello data is only valid inside the library callback, and JS must
@@ -480,7 +479,7 @@ bool TLSWrap::OnEarlyClientHello(const unsigned char* session_id,
 if (ssl_) EmitClientHello(id, has_ticket);
  });
  }
-returnhello_answered_;
+returnflags_.hello_answered;
 }
 
 voidTLSWrap::EmitClientHello(const std::vector<unsignedchar>& session_id,
@@ -658,8 +657,8 @@ void TLSWrap::Start(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
 
-CHECK(!wrap->started_);
- wrap->started_ = true;
+CHECK(!wrap->flags_.started);
+ wrap->flags_.started = true;
 
 // Send ClientHello handshake
 CHECK(wrap->is_client());
@@ -703,7 +702,7 @@ void TLSWrap::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
 CHECK(!SSL_renegotiate_pending(ssl));
  Local<Value> callback;
 
- c->established_ = true;
+ c->flags_.established = true;
 
 if (object->Get(env->context(), env->onhandshakedone_string())
  .ToLocal(&callback) && callback->IsFunction()) {
@@ -727,17 +726,17 @@ void TLSWrap::EncOut() {
 return;
  }
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this,
 "Returning from EncOut(), "
 "has_active_write_issued_by_prev_listener_ is true");
 return;
  }
 
 // Split-off queue
-if (established_ && current_write_) {
+if (flags_.established && current_write_) {
 Debug(this, "EncOut() write is scheduled");
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
  }
 
 if (ssl_ == nullptr) {
@@ -750,7 +749,7 @@ void TLSWrap::EncOut() {
 Debug(this, "No pending encrypted output");
 if (!pending_cleartext_input_ ||
  pending_cleartext_input_->ByteLength() == 0) {
-if (!in_dowrite_) {
+if (!flags_.in_dowrite) {
 Debug(this, "No pending cleartext input, not inside DoWrite()");
 InvokeQueued(0);
  } else {
@@ -805,7 +804,7 @@ void TLSWrap::EncOut() {
 voidTLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 Debug(this, "OnStreamAfterWrite(status = %d)", status);
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this, "Notify write finish to the previous_listener_");
 CHECK_EQ(write_size_, 0); // we must have restrained writes
 
@@ -830,7 +829,7 @@ void TLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 
 // Handle error
 if (status) {
-if (shutdown_) {
+if (flags_.shutdown) {
 Debug(this, "Ignoring error after shutdown");
 return;
  }
@@ -855,7 +854,7 @@ void TLSWrap::ClearOut() {
 Debug(this, "Trying to read cleartext output");
 
 // No reads after EOF
-if (eof_) {
+if (flags_.eof) {
 Debug(this, "Returning from ClearOut(), EOF reached");
 return;
  }
@@ -911,8 +910,8 @@ void TLSWrap::ClearOut() {
 int err = SSL_get_error(ssl_.get(), read);
 switch (err) {
 caseSSL_ERROR_ZERO_RETURN:
-if (!eof_) {
-eof_ = true;
+if (!flags_.eof) {
+flags_.eof = true;
 EmitRead(UV_EOF);
  }
 return;
@@ -1005,7 +1004,7 @@ void TLSWrap::ClearIn() {
 int err = SSL_get_error(ssl_.get(), written);
 if (err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL) {
 Debug(this, "Got SSL error (%d)", err);
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 // TODO(@sam-github) Should forward an error object with
 // .code/.function/.etc, if possible.
 InvokeQueued(UV_EPROTO, GetBIOError().c_str());
@@ -1049,7 +1048,7 @@ bool TLSWrap::IsClosing() {
 
 intTLSWrap::ReadStart() {
 Debug(this, "ReadStart()");
-if (underlying_stream() != nullptr && !eof_)
+if (underlying_stream() != nullptr && !flags_.eof)
 returnunderlying_stream()->ReadStart();
 return0;
 }
@@ -1197,9 +1196,9 @@ int TLSWrap::DoWrite(WriteWrap* w,
 
 // Write any encrypted/handshake output that may be ready.
 // Guard against sync call of current_write_->Done(), its unsupported.
-in_dowrite_ = true;
+flags_.in_dowrite = true;
 EncOut();
-in_dowrite_ = false;
+flags_.in_dowrite = false;
 
 return0;
 }
@@ -1216,16 +1215,15 @@ void TLSWrap::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
 Debug(this, "Read %zd bytes from underlying stream", nread);
 
 // Ignore everything after close_notify (rfc5246#section-7.2.1)
-if (eof_)
-return;
+if (flags_.eof) return;
 
 if (nread < 0) {
 // Error should be emitted only after all data was read
 ClearOut();
 
 if (nread == UV_EOF) {
 // underlying stream already should have also called ReadStop on itself
-eof_ = true;
+flags_.eof = true;
  }
 
 EmitRead(nread);
@@ -1256,7 +1254,7 @@ int TLSWrap::DoShutdown(ShutdownWrap* req_wrap) {
 if (ssl_ && SSL_shutdown(ssl_.get()) == 0)
 SSL_shutdown(ssl_.get());
 
-shutdown_ = true;
+flags_.shutdown = true;
 EncOut();
 returnunderlying_stream()->DoShutdown(req_wrap);
 }
@@ -1352,7 +1350,7 @@ void TLSWrap::Destroy() {
 return;
 
 // If there is a write happening, mark it as finished.
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 
 // And destroy
 InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
@@ -1389,7 +1387,7 @@ void TLSWrap::ResumeAfterCertCb(void* arg) {
 voidTLSWrap::EnableALPNCb(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
- wrap->alpn_callback_enabled_ = true;
+ wrap->flags_.alpn_callback_enabled = true;
 
 SSL* ssl = wrap->ssl_.get();
 SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(ssl);
@@ -1418,7 +1416,7 @@ void TLSWrap::SetServername(const FunctionCallbackInfo<Value>& args) {
 
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsString());
-CHECK(!wrap->started_);
+CHECK(!wrap->flags_.started);
 CHECK(wrap->is_client());
 
 CHECK(wrap->ssl_);
@@ -1633,7 +1631,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
-CHECK(w->is_waiting_cert_cb() && w->cert_cb_running_);
+CHECK(w->is_waiting_cert_cb() && w->flags_.cert_cb_running);
 
  Local<Object> object = w->object();
  Local<Value> ctx = object->Get(env->context(), env->sni_context_string())
@@ -1685,7 +1683,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  cb = w->cert_cb_;
  arg = w->cert_cb_arg_;
 
- w->cert_cb_running_ = false;
+ w->flags_.cert_cb_running = false;
  w->cert_cb_ = nullptr;
  w->cert_cb_arg_ = nullptr;
 
@@ -2072,7 +2070,7 @@ void TLSWrap::ExportKeyingMaterial(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::ClientHelloDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->hello_answered_ = true;
+ w->flags_.hello_answered = true;
  w->Cycle();
 }
 
@@ -2107,7 +2105,7 @@ void TLSWrap::GetTLSTicket(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::NewSessionDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->awaiting_new_session_ = false;
+ w->flags_.awaiting_new_session = false;
  w->NewSessionDoneCb();
 }
 
@@ -2188,7 +2186,7 @@ void TLSWrap::WritesIssuedByPrevListenerDone(
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
 Debug(w, "WritesIssuedByPrevListenerDone is called");
- w->has_active_write_issued_by_prev_listener_ = false;
+ w->flags_.has_active_write_issued_by_prev_listener = false;
  w->EncOut(); // resume all of our restrained writes
 }
 

src/crypto/crypto_tls.h

@@ -62,22 +62,26 @@ class TLSWrap : public AsyncWrap,
 
 ~TLSWrap() override;
 
-inlineboolis_cert_cb_running() const { returncert_cb_running_; }
+inlineboolis_cert_cb_running() const { returnflags_.cert_cb_running; }
 inlineboolis_waiting_cert_cb() const { return cert_cb_ != nullptr; }
-inlineboolhas_session_callbacks() const { returnsession_callbacks_; }
+inlineboolhas_session_callbacks() const { returnflags_.session_callbacks; }
 // We need to suspend the ClientHello only for server session id
 // callbacks, and only on the first pass.
 inlineboolshould_suspend_for_client_hello() const {
-returnis_server() && session_callbacks_ && !hello_answered_;
+returnis_server() && flags_.session_callbacks && !flags_.hello_answered;
+ }
+inlinevoidset_cert_cb_running(bool on = true) {
+ flags_.cert_cb_running = on;
  }
-inlinevoidset_cert_cb_running(bool on = true) { cert_cb_running_ = on; }
 inlinevoidset_awaiting_new_session(bool on = true) {
-awaiting_new_session_ = on;
+flags_.awaiting_new_session = on;
  }
-inlinevoidenable_session_callbacks() { session_callbacks_ = true; }
+inlinevoidenable_session_callbacks() { flags_.session_callbacks = true; }
 inlineboolis_server() const { return kind_ == Kind::kServer; }
 inlineboolis_client() const { return kind_ == Kind::kClient; }
-inlineboolis_awaiting_new_session() const { return awaiting_new_session_; }
+inlineboolis_awaiting_new_session() const {
+return flags_.awaiting_new_session;
+ }
 
 // Implement StreamBase:
 boolIsAlive() override;
@@ -125,6 +129,14 @@ class TLSWrap : public AsyncWrap,
 
  std::string diagnostic_name() constoverride;
 
+boolget_alpn_callback_enabled() const {
+return flags_.alpn_callback_enabled;
+ }
+
+const std::vector<unsignedchar>& get_alpn_protos() const {
+return alpn_protos_;
+ }
+
 private:
 // OpenSSL structures are opaque. Estimate SSL memory size for OpenSSL 1.1.1b:
 // SSL: 6224
@@ -284,26 +296,30 @@ class TLSWrap : public AsyncWrap,
  BaseObjectPtr<AsyncWrap> current_empty_write_;
  std::string error_;
 
-bool session_callbacks_ = false;
-bool awaiting_new_session_ = false;
-// 'onclienthello' has been emitted for this connection.
-bool hello_emitted_ = false;
-// JS has answered it by calling clientHelloDone().
-bool hello_answered_ = false;
-bool in_dowrite_ = false;
-bool started_ = false;
-bool shutdown_ = false;
-bool cert_cb_running_ = false;
-bool eof_ = false;
-
 // TODO(@jasnell): These state flags should be revisited.
 // The established_ flag indicates that the handshake is
 // completed. The write_callback_scheduled_ flag is less
 // clear -- once it is set to true, it is never set to
 // false and it is only set to true after established_
 // is set to true, so it's likely redundant.
-bool established_ = false;
-bool write_callback_scheduled_ = false;
+structFlags {
+bool session_callbacks : 1;
+bool awaiting_new_session : 1;
+// 'onclienthello' has been emitted for this connection.
+bool hello_emitted : 1;
+// JS has answered it by calling clientHelloDone().
+bool hello_answered : 1;
+bool in_dowrite : 1;
+bool started : 1;
+bool shutdown : 1;
+bool cert_cb_running : 1;
+bool eof : 1;
+bool established : 1;
+bool write_callback_scheduled : 1;
+bool has_active_write_issued_by_prev_listener : 1;
+bool alpn_callback_enabled : 1;
+ };
+ Flags flags_{};
 
 int cycle_depth_ = 0;
 
@@ -313,11 +329,7 @@ class TLSWrap : public AsyncWrap,
 
  ncrypto::BIOPointer bio_trace_;
 
-bool has_active_write_issued_by_prev_listener_ = false;
-
-public:
  std::vector<unsignedchar> alpn_protos_; // Accessed by SelectALPNCallback.
-bool alpn_callback_enabled_ = false; // Accessed by SelectALPNCallback.
 };
 
 } // namespace crypto

src/crypto/crypto_tls.cc

@@ -240,7 +240,7 @@ int SelectALPNCallback(
 unsignedint inlen,
 void* arg) {
  TLSWrap* w = static_cast<TLSWrap*>(SSL_get_app_data(s));
-if (w->alpn_callback_enabled_) {
+if (w->get_alpn_callback_enabled()) {
  Environment* env = w->env();
  HandleScope handle_scope(env->isolate());
 
@@ -275,7 +275,7 @@ int SelectALPNCallback(
 returnSSL_TLSEXT_ERR_OK;
  }
 
-const std::vector<unsignedchar>& alpn_protos = w->alpn_protos_;
+auto& alpn_protos = w->get_alpn_protos();
 
 if (alpn_protos.empty()) returnSSL_TLSEXT_ERR_NOACK;
 
@@ -403,9 +403,9 @@ TLSWrap::TLSWrap(Environment* env,
 StreamBase(env),
  env_(env),
  kind_(kind),
- sc_(sc),
- has_active_write_issued_by_prev_listener_(
-under_stream_ws == UnderlyingStreamWriteStatus::kHasActive) {
+ sc_(sc) {
+flags_.has_active_write_issued_by_prev_listener =
+ under_stream_ws == UnderlyingStreamWriteStatus::kHasActive;
 MakeWeak();
 CHECK(sc_);
  ssl_ = sc_->CreateSSL();
@@ -444,8 +444,7 @@ SSL_SESSION* TLSWrap::ReleaseSession() {
 
 voidTLSWrap::InvokeQueued(int status, constchar* error_str) {
 Debug(this, "Invoking queued write callbacks (%d, %s)", status, error_str);
-if (!write_callback_scheduled_)
-return;
+if (!flags_.write_callback_scheduled) return;
 
 if (current_write_) {
  BaseObjectPtr<AsyncWrap> current_write = std::move(current_write_);
@@ -465,8 +464,8 @@ void TLSWrap::NewSessionDoneCb() {
 boolTLSWrap::OnEarlyClientHello(constunsignedchar* session_id,
 size_t session_id_len,
 bool has_ticket) {
-if (!hello_emitted_) {
-hello_emitted_ = true;
+if (!flags_.hello_emitted) {
+flags_.hello_emitted = true;
 Debug(this, "Scheduling onclienthello");
 
 // The hello data is only valid inside the library callback, and JS must
@@ -480,7 +479,7 @@ bool TLSWrap::OnEarlyClientHello(const unsigned char* session_id,
 if (ssl_) EmitClientHello(id, has_ticket);
  });
  }
-returnhello_answered_;
+returnflags_.hello_answered;
 }
 
 voidTLSWrap::EmitClientHello(const std::vector<unsignedchar>& session_id,
@@ -658,8 +657,8 @@ void TLSWrap::Start(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
 
-CHECK(!wrap->started_);
- wrap->started_ = true;
+CHECK(!wrap->flags_.started);
+ wrap->flags_.started = true;
 
 // Send ClientHello handshake
 CHECK(wrap->is_client());
@@ -703,7 +702,7 @@ void TLSWrap::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
 CHECK(!SSL_renegotiate_pending(ssl));
  Local<Value> callback;
 
- c->established_ = true;
+ c->flags_.established = true;
 
 if (object->Get(env->context(), env->onhandshakedone_string())
  .ToLocal(&callback) && callback->IsFunction()) {
@@ -727,17 +726,17 @@ void TLSWrap::EncOut() {
 return;
  }
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this,
 "Returning from EncOut(), "
 "has_active_write_issued_by_prev_listener_ is true");
 return;
  }
 
 // Split-off queue
-if (established_ && current_write_) {
+if (flags_.established && current_write_) {
 Debug(this, "EncOut() write is scheduled");
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
  }
 
 if (ssl_ == nullptr) {
@@ -750,7 +749,7 @@ void TLSWrap::EncOut() {
 Debug(this, "No pending encrypted output");
 if (!pending_cleartext_input_ ||
  pending_cleartext_input_->ByteLength() == 0) {
-if (!in_dowrite_) {
+if (!flags_.in_dowrite) {
 Debug(this, "No pending cleartext input, not inside DoWrite()");
 InvokeQueued(0);
  } else {
@@ -805,7 +804,7 @@ void TLSWrap::EncOut() {
 voidTLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 Debug(this, "OnStreamAfterWrite(status = %d)", status);
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this, "Notify write finish to the previous_listener_");
 CHECK_EQ(write_size_, 0); // we must have restrained writes
 
@@ -830,7 +829,7 @@ void TLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 
 // Handle error
 if (status) {
-if (shutdown_) {
+if (flags_.shutdown) {
 Debug(this, "Ignoring error after shutdown");
 return;
  }
@@ -855,7 +854,7 @@ void TLSWrap::ClearOut() {
 Debug(this, "Trying to read cleartext output");
 
 // No reads after EOF
-if (eof_) {
+if (flags_.eof) {
 Debug(this, "Returning from ClearOut(), EOF reached");
 return;
  }
@@ -911,8 +910,8 @@ void TLSWrap::ClearOut() {
 int err = SSL_get_error(ssl_.get(), read);
 switch (err) {
 caseSSL_ERROR_ZERO_RETURN:
-if (!eof_) {
-eof_ = true;
+if (!flags_.eof) {
+flags_.eof = true;
 EmitRead(UV_EOF);
  }
 return;
@@ -1005,7 +1004,7 @@ void TLSWrap::ClearIn() {
 int err = SSL_get_error(ssl_.get(), written);
 if (err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL) {
 Debug(this, "Got SSL error (%d)", err);
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 // TODO(@sam-github) Should forward an error object with
 // .code/.function/.etc, if possible.
 InvokeQueued(UV_EPROTO, GetBIOError().c_str());
@@ -1049,7 +1048,7 @@ bool TLSWrap::IsClosing() {
 
 intTLSWrap::ReadStart() {
 Debug(this, "ReadStart()");
-if (underlying_stream() != nullptr && !eof_)
+if (underlying_stream() != nullptr && !flags_.eof)
 returnunderlying_stream()->ReadStart();
 return0;
 }
@@ -1197,9 +1196,9 @@ int TLSWrap::DoWrite(WriteWrap* w,
 
 // Write any encrypted/handshake output that may be ready.
 // Guard against sync call of current_write_->Done(), its unsupported.
-in_dowrite_ = true;
+flags_.in_dowrite = true;
 EncOut();
-in_dowrite_ = false;
+flags_.in_dowrite = false;
 
 return0;
 }
@@ -1216,16 +1215,15 @@ void TLSWrap::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
 Debug(this, "Read %zd bytes from underlying stream", nread);
 
 // Ignore everything after close_notify (rfc5246#section-7.2.1)
-if (eof_)
-return;
+if (flags_.eof) return;
 
 if (nread < 0) {
 // Error should be emitted only after all data was read
 ClearOut();
 
 if (nread == UV_EOF) {
 // underlying stream already should have also called ReadStop on itself
-eof_ = true;
+flags_.eof = true;
  }
 
 EmitRead(nread);
@@ -1256,7 +1254,7 @@ int TLSWrap::DoShutdown(ShutdownWrap* req_wrap) {
 if (ssl_ && SSL_shutdown(ssl_.get()) == 0)
 SSL_shutdown(ssl_.get());
 
-shutdown_ = true;
+flags_.shutdown = true;
 EncOut();
 returnunderlying_stream()->DoShutdown(req_wrap);
 }
@@ -1352,7 +1350,7 @@ void TLSWrap::Destroy() {
 return;
 
 // If there is a write happening, mark it as finished.
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 
 // And destroy
 InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
@@ -1389,7 +1387,7 @@ void TLSWrap::ResumeAfterCertCb(void* arg) {
 voidTLSWrap::EnableALPNCb(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
- wrap->alpn_callback_enabled_ = true;
+ wrap->flags_.alpn_callback_enabled = true;
 
 SSL* ssl = wrap->ssl_.get();
 SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(ssl);
@@ -1418,7 +1416,7 @@ void TLSWrap::SetServername(const FunctionCallbackInfo<Value>& args) {
 
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsString());
-CHECK(!wrap->started_);
+CHECK(!wrap->flags_.started);
 CHECK(wrap->is_client());
 
 CHECK(wrap->ssl_);
@@ -1633,7 +1631,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
-CHECK(w->is_waiting_cert_cb() && w->cert_cb_running_);
+CHECK(w->is_waiting_cert_cb() && w->flags_.cert_cb_running);
 
  Local<Object> object = w->object();
  Local<Value> ctx = object->Get(env->context(), env->sni_context_string())
@@ -1685,7 +1683,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  cb = w->cert_cb_;
  arg = w->cert_cb_arg_;
 
- w->cert_cb_running_ = false;
+ w->flags_.cert_cb_running = false;
  w->cert_cb_ = nullptr;
  w->cert_cb_arg_ = nullptr;
 
@@ -2072,7 +2070,7 @@ void TLSWrap::ExportKeyingMaterial(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::ClientHelloDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->hello_answered_ = true;
+ w->flags_.hello_answered = true;
  w->Cycle();
 }
 
@@ -2107,7 +2105,7 @@ void TLSWrap::GetTLSTicket(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::NewSessionDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->awaiting_new_session_ = false;
+ w->flags_.awaiting_new_session = false;
  w->NewSessionDoneCb();
 }
 
@@ -2188,7 +2186,7 @@ void TLSWrap::WritesIssuedByPrevListenerDone(
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
 Debug(w, "WritesIssuedByPrevListenerDone is called");
- w->has_active_write_issued_by_prev_listener_ = false;
+ w->flags_.has_active_write_issued_by_prev_listener = false;
  w->EncOut(); // resume all of our restrained writes
 }
 

src/crypto/crypto_tls.h

@@ -62,22 +62,26 @@ class TLSWrap : public AsyncWrap,
 
 ~TLSWrap() override;
 
-inlineboolis_cert_cb_running() const { returncert_cb_running_; }
+inlineboolis_cert_cb_running() const { returnflags_.cert_cb_running; }
 inlineboolis_waiting_cert_cb() const { return cert_cb_ != nullptr; }
-inlineboolhas_session_callbacks() const { returnsession_callbacks_; }
+inlineboolhas_session_callbacks() const { returnflags_.session_callbacks; }
 // We need to suspend the ClientHello only for server session id
 // callbacks, and only on the first pass.
 inlineboolshould_suspend_for_client_hello() const {
-returnis_server() && session_callbacks_ && !hello_answered_;
+returnis_server() && flags_.session_callbacks && !flags_.hello_answered;
+ }
+inlinevoidset_cert_cb_running(bool on = true) {
+ flags_.cert_cb_running = on;
  }
-inlinevoidset_cert_cb_running(bool on = true) { cert_cb_running_ = on; }
 inlinevoidset_awaiting_new_session(bool on = true) {
-awaiting_new_session_ = on;
+flags_.awaiting_new_session = on;
  }
-inlinevoidenable_session_callbacks() { session_callbacks_ = true; }
+inlinevoidenable_session_callbacks() { flags_.session_callbacks = true; }
 inlineboolis_server() const { return kind_ == Kind::kServer; }
 inlineboolis_client() const { return kind_ == Kind::kClient; }
-inlineboolis_awaiting_new_session() const { return awaiting_new_session_; }
+inlineboolis_awaiting_new_session() const {
+return flags_.awaiting_new_session;
+ }
 
 // Implement StreamBase:
 boolIsAlive() override;
@@ -125,6 +129,14 @@ class TLSWrap : public AsyncWrap,
 
  std::string diagnostic_name() constoverride;
 
+boolget_alpn_callback_enabled() const {
+return flags_.alpn_callback_enabled;
+ }
+
+const std::vector<unsignedchar>& get_alpn_protos() const {
+return alpn_protos_;
+ }
+
 private:
 // OpenSSL structures are opaque. Estimate SSL memory size for OpenSSL 1.1.1b:
 // SSL: 6224
@@ -284,26 +296,30 @@ class TLSWrap : public AsyncWrap,
  BaseObjectPtr<AsyncWrap> current_empty_write_;
  std::string error_;
 
-bool session_callbacks_ = false;
-bool awaiting_new_session_ = false;
-// 'onclienthello' has been emitted for this connection.
-bool hello_emitted_ = false;
-// JS has answered it by calling clientHelloDone().
-bool hello_answered_ = false;
-bool in_dowrite_ = false;
-bool started_ = false;
-bool shutdown_ = false;
-bool cert_cb_running_ = false;
-bool eof_ = false;
-
 // TODO(@jasnell): These state flags should be revisited.
 // The established_ flag indicates that the handshake is
 // completed. The write_callback_scheduled_ flag is less
 // clear -- once it is set to true, it is never set to
 // false and it is only set to true after established_
 // is set to true, so it's likely redundant.
-bool established_ = false;
-bool write_callback_scheduled_ = false;
+structFlags {
+bool session_callbacks : 1;
+bool awaiting_new_session : 1;
+// 'onclienthello' has been emitted for this connection.
+bool hello_emitted : 1;
+// JS has answered it by calling clientHelloDone().
+bool hello_answered : 1;
+bool in_dowrite : 1;
+bool started : 1;
+bool shutdown : 1;
+bool cert_cb_running : 1;
+bool eof : 1;
+bool established : 1;
+bool write_callback_scheduled : 1;
+bool has_active_write_issued_by_prev_listener : 1;
+bool alpn_callback_enabled : 1;
+ };
+ Flags flags_{};
 
 int cycle_depth_ = 0;
 
@@ -313,11 +329,7 @@ class TLSWrap : public AsyncWrap,
 
  ncrypto::BIOPointer bio_trace_;
 
-bool has_active_write_issued_by_prev_listener_ = false;
-
-public:
  std::vector<unsignedchar> alpn_protos_; // Accessed by SelectALPNCallback.
-bool alpn_callback_enabled_ = false; // Accessed by SelectALPNCallback.
 };
 
 } // namespace crypto

src/crypto/crypto_tls.cc

@@ -240,7 +240,7 @@ int SelectALPNCallback(
 unsignedint inlen,
 void* arg) {
  TLSWrap* w = static_cast<TLSWrap*>(SSL_get_app_data(s));
-if (w->alpn_callback_enabled_) {
+if (w->get_alpn_callback_enabled()) {
  Environment* env = w->env();
  HandleScope handle_scope(env->isolate());
 
@@ -275,7 +275,7 @@ int SelectALPNCallback(
 returnSSL_TLSEXT_ERR_OK;
  }
 
-const std::vector<unsignedchar>& alpn_protos = w->alpn_protos_;
+auto& alpn_protos = w->get_alpn_protos();
 
 if (alpn_protos.empty()) returnSSL_TLSEXT_ERR_NOACK;
 
@@ -403,9 +403,9 @@ TLSWrap::TLSWrap(Environment* env,
 StreamBase(env),
  env_(env),
  kind_(kind),
- sc_(sc),
- has_active_write_issued_by_prev_listener_(
-under_stream_ws == UnderlyingStreamWriteStatus::kHasActive) {
+ sc_(sc) {
+flags_.has_active_write_issued_by_prev_listener =
+ under_stream_ws == UnderlyingStreamWriteStatus::kHasActive;
 MakeWeak();
 CHECK(sc_);
  ssl_ = sc_->CreateSSL();
@@ -444,8 +444,7 @@ SSL_SESSION* TLSWrap::ReleaseSession() {
 
 voidTLSWrap::InvokeQueued(int status, constchar* error_str) {
 Debug(this, "Invoking queued write callbacks (%d, %s)", status, error_str);
-if (!write_callback_scheduled_)
-return;
+if (!flags_.write_callback_scheduled) return;
 
 if (current_write_) {
  BaseObjectPtr<AsyncWrap> current_write = std::move(current_write_);
@@ -465,8 +464,8 @@ void TLSWrap::NewSessionDoneCb() {
 boolTLSWrap::OnEarlyClientHello(constunsignedchar* session_id,
 size_t session_id_len,
 bool has_ticket) {
-if (!hello_emitted_) {
-hello_emitted_ = true;
+if (!flags_.hello_emitted) {
+flags_.hello_emitted = true;
 Debug(this, "Scheduling onclienthello");
 
 // The hello data is only valid inside the library callback, and JS must
@@ -480,7 +479,7 @@ bool TLSWrap::OnEarlyClientHello(const unsigned char* session_id,
 if (ssl_) EmitClientHello(id, has_ticket);
  });
  }
-returnhello_answered_;
+returnflags_.hello_answered;
 }
 
 voidTLSWrap::EmitClientHello(const std::vector<unsignedchar>& session_id,
@@ -658,8 +657,8 @@ void TLSWrap::Start(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
 
-CHECK(!wrap->started_);
- wrap->started_ = true;
+CHECK(!wrap->flags_.started);
+ wrap->flags_.started = true;
 
 // Send ClientHello handshake
 CHECK(wrap->is_client());
@@ -703,7 +702,7 @@ void TLSWrap::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
 CHECK(!SSL_renegotiate_pending(ssl));
  Local<Value> callback;
 
- c->established_ = true;
+ c->flags_.established = true;
 
 if (object->Get(env->context(), env->onhandshakedone_string())
  .ToLocal(&callback) && callback->IsFunction()) {
@@ -727,17 +726,17 @@ void TLSWrap::EncOut() {
 return;
  }
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this,
 "Returning from EncOut(), "
 "has_active_write_issued_by_prev_listener_ is true");
 return;
  }
 
 // Split-off queue
-if (established_ && current_write_) {
+if (flags_.established && current_write_) {
 Debug(this, "EncOut() write is scheduled");
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
  }
 
 if (ssl_ == nullptr) {
@@ -750,7 +749,7 @@ void TLSWrap::EncOut() {
 Debug(this, "No pending encrypted output");
 if (!pending_cleartext_input_ ||
  pending_cleartext_input_->ByteLength() == 0) {
-if (!in_dowrite_) {
+if (!flags_.in_dowrite) {
 Debug(this, "No pending cleartext input, not inside DoWrite()");
 InvokeQueued(0);
  } else {
@@ -805,7 +804,7 @@ void TLSWrap::EncOut() {
 voidTLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 Debug(this, "OnStreamAfterWrite(status = %d)", status);
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this, "Notify write finish to the previous_listener_");
 CHECK_EQ(write_size_, 0); // we must have restrained writes
 
@@ -830,7 +829,7 @@ void TLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 
 // Handle error
 if (status) {
-if (shutdown_) {
+if (flags_.shutdown) {
 Debug(this, "Ignoring error after shutdown");
 return;
  }
@@ -855,7 +854,7 @@ void TLSWrap::ClearOut() {
 Debug(this, "Trying to read cleartext output");
 
 // No reads after EOF
-if (eof_) {
+if (flags_.eof) {
 Debug(this, "Returning from ClearOut(), EOF reached");
 return;
  }
@@ -911,8 +910,8 @@ void TLSWrap::ClearOut() {
 int err = SSL_get_error(ssl_.get(), read);
 switch (err) {
 caseSSL_ERROR_ZERO_RETURN:
-if (!eof_) {
-eof_ = true;
+if (!flags_.eof) {
+flags_.eof = true;
 EmitRead(UV_EOF);
  }
 return;
@@ -1005,7 +1004,7 @@ void TLSWrap::ClearIn() {
 int err = SSL_get_error(ssl_.get(), written);
 if (err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL) {
 Debug(this, "Got SSL error (%d)", err);
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 // TODO(@sam-github) Should forward an error object with
 // .code/.function/.etc, if possible.
 InvokeQueued(UV_EPROTO, GetBIOError().c_str());
@@ -1049,7 +1048,7 @@ bool TLSWrap::IsClosing() {
 
 intTLSWrap::ReadStart() {
 Debug(this, "ReadStart()");
-if (underlying_stream() != nullptr && !eof_)
+if (underlying_stream() != nullptr && !flags_.eof)
 returnunderlying_stream()->ReadStart();
 return0;
 }
@@ -1197,9 +1196,9 @@ int TLSWrap::DoWrite(WriteWrap* w,
 
 // Write any encrypted/handshake output that may be ready.
 // Guard against sync call of current_write_->Done(), its unsupported.
-in_dowrite_ = true;
+flags_.in_dowrite = true;
 EncOut();
-in_dowrite_ = false;
+flags_.in_dowrite = false;
 
 return0;
 }
@@ -1216,16 +1215,15 @@ void TLSWrap::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
 Debug(this, "Read %zd bytes from underlying stream", nread);
 
 // Ignore everything after close_notify (rfc5246#section-7.2.1)
-if (eof_)
-return;
+if (flags_.eof) return;
 
 if (nread < 0) {
 // Error should be emitted only after all data was read
 ClearOut();
 
 if (nread == UV_EOF) {
 // underlying stream already should have also called ReadStop on itself
-eof_ = true;
+flags_.eof = true;
  }
 
 EmitRead(nread);
@@ -1256,7 +1254,7 @@ int TLSWrap::DoShutdown(ShutdownWrap* req_wrap) {
 if (ssl_ && SSL_shutdown(ssl_.get()) == 0)
 SSL_shutdown(ssl_.get());
 
-shutdown_ = true;
+flags_.shutdown = true;
 EncOut();
 returnunderlying_stream()->DoShutdown(req_wrap);
 }
@@ -1352,7 +1350,7 @@ void TLSWrap::Destroy() {
 return;
 
 // If there is a write happening, mark it as finished.
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 
 // And destroy
 InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
@@ -1389,7 +1387,7 @@ void TLSWrap::ResumeAfterCertCb(void* arg) {
 voidTLSWrap::EnableALPNCb(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
- wrap->alpn_callback_enabled_ = true;
+ wrap->flags_.alpn_callback_enabled = true;
 
 SSL* ssl = wrap->ssl_.get();
 SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(ssl);
@@ -1418,7 +1416,7 @@ void TLSWrap::SetServername(const FunctionCallbackInfo<Value>& args) {
 
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsString());
-CHECK(!wrap->started_);
+CHECK(!wrap->flags_.started);
 CHECK(wrap->is_client());
 
 CHECK(wrap->ssl_);
@@ -1633,7 +1631,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
-CHECK(w->is_waiting_cert_cb() && w->cert_cb_running_);
+CHECK(w->is_waiting_cert_cb() && w->flags_.cert_cb_running);
 
  Local<Object> object = w->object();
  Local<Value> ctx = object->Get(env->context(), env->sni_context_string())
@@ -1685,7 +1683,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  cb = w->cert_cb_;
  arg = w->cert_cb_arg_;
 
- w->cert_cb_running_ = false;
+ w->flags_.cert_cb_running = false;
  w->cert_cb_ = nullptr;
  w->cert_cb_arg_ = nullptr;
 
@@ -2072,7 +2070,7 @@ void TLSWrap::ExportKeyingMaterial(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::ClientHelloDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->hello_answered_ = true;
+ w->flags_.hello_answered = true;
  w->Cycle();
 }
 
@@ -2107,7 +2105,7 @@ void TLSWrap::GetTLSTicket(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::NewSessionDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->awaiting_new_session_ = false;
+ w->flags_.awaiting_new_session = false;
  w->NewSessionDoneCb();
 }
 
@@ -2188,7 +2186,7 @@ void TLSWrap::WritesIssuedByPrevListenerDone(
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
 Debug(w, "WritesIssuedByPrevListenerDone is called");
- w->has_active_write_issued_by_prev_listener_ = false;
+ w->flags_.has_active_write_issued_by_prev_listener = false;
  w->EncOut(); // resume all of our restrained writes
 }
 

src/crypto/crypto_tls.h

@@ -62,22 +62,26 @@ class TLSWrap : public AsyncWrap,
 
 ~TLSWrap() override;
 
-inlineboolis_cert_cb_running() const { returncert_cb_running_; }
+inlineboolis_cert_cb_running() const { returnflags_.cert_cb_running; }
 inlineboolis_waiting_cert_cb() const { return cert_cb_ != nullptr; }
-inlineboolhas_session_callbacks() const { returnsession_callbacks_; }
+inlineboolhas_session_callbacks() const { returnflags_.session_callbacks; }
 // We need to suspend the ClientHello only for server session id
 // callbacks, and only on the first pass.
 inlineboolshould_suspend_for_client_hello() const {
-returnis_server() && session_callbacks_ && !hello_answered_;
+returnis_server() && flags_.session_callbacks && !flags_.hello_answered;
+ }
+inlinevoidset_cert_cb_running(bool on = true) {
+ flags_.cert_cb_running = on;
  }
-inlinevoidset_cert_cb_running(bool on = true) { cert_cb_running_ = on; }
 inlinevoidset_awaiting_new_session(bool on = true) {
-awaiting_new_session_ = on;
+flags_.awaiting_new_session = on;
  }
-inlinevoidenable_session_callbacks() { session_callbacks_ = true; }
+inlinevoidenable_session_callbacks() { flags_.session_callbacks = true; }
 inlineboolis_server() const { return kind_ == Kind::kServer; }
 inlineboolis_client() const { return kind_ == Kind::kClient; }
-inlineboolis_awaiting_new_session() const { return awaiting_new_session_; }
+inlineboolis_awaiting_new_session() const {
+return flags_.awaiting_new_session;
+ }
 
 // Implement StreamBase:
 boolIsAlive() override;
@@ -125,6 +129,14 @@ class TLSWrap : public AsyncWrap,
 
  std::string diagnostic_name() constoverride;
 
+boolget_alpn_callback_enabled() const {
+return flags_.alpn_callback_enabled;
+ }
+
+const std::vector<unsignedchar>& get_alpn_protos() const {
+return alpn_protos_;
+ }
+
 private:
 // OpenSSL structures are opaque. Estimate SSL memory size for OpenSSL 1.1.1b:
 // SSL: 6224
@@ -284,26 +296,30 @@ class TLSWrap : public AsyncWrap,
  BaseObjectPtr<AsyncWrap> current_empty_write_;
  std::string error_;
 
-bool session_callbacks_ = false;
-bool awaiting_new_session_ = false;
-// 'onclienthello' has been emitted for this connection.
-bool hello_emitted_ = false;
-// JS has answered it by calling clientHelloDone().
-bool hello_answered_ = false;
-bool in_dowrite_ = false;
-bool started_ = false;
-bool shutdown_ = false;
-bool cert_cb_running_ = false;
-bool eof_ = false;
-
 // TODO(@jasnell): These state flags should be revisited.
 // The established_ flag indicates that the handshake is
 // completed. The write_callback_scheduled_ flag is less
 // clear -- once it is set to true, it is never set to
 // false and it is only set to true after established_
 // is set to true, so it's likely redundant.
-bool established_ = false;
-bool write_callback_scheduled_ = false;
+structFlags {
+bool session_callbacks : 1;
+bool awaiting_new_session : 1;
+// 'onclienthello' has been emitted for this connection.
+bool hello_emitted : 1;
+// JS has answered it by calling clientHelloDone().
+bool hello_answered : 1;
+bool in_dowrite : 1;
+bool started : 1;
+bool shutdown : 1;
+bool cert_cb_running : 1;
+bool eof : 1;
+bool established : 1;
+bool write_callback_scheduled : 1;
+bool has_active_write_issued_by_prev_listener : 1;
+bool alpn_callback_enabled : 1;
+ };
+ Flags flags_{};
 
 int cycle_depth_ = 0;
 
@@ -313,11 +329,7 @@ class TLSWrap : public AsyncWrap,
 
  ncrypto::BIOPointer bio_trace_;
 
-bool has_active_write_issued_by_prev_listener_ = false;
-
-public:
  std::vector<unsignedchar> alpn_protos_; // Accessed by SelectALPNCallback.
-bool alpn_callback_enabled_ = false; // Accessed by SelectALPNCallback.
 };
 
 } // namespace crypto

src/crypto/crypto_tls.cc

@@ -240,7 +240,7 @@ int SelectALPNCallback(
 unsignedint inlen,
 void* arg) {
  TLSWrap* w = static_cast<TLSWrap*>(SSL_get_app_data(s));
-if (w->alpn_callback_enabled_) {
+if (w->get_alpn_callback_enabled()) {
  Environment* env = w->env();
  HandleScope handle_scope(env->isolate());
 
@@ -275,7 +275,7 @@ int SelectALPNCallback(
 returnSSL_TLSEXT_ERR_OK;
  }
 
-const std::vector<unsignedchar>& alpn_protos = w->alpn_protos_;
+auto& alpn_protos = w->get_alpn_protos();
 
 if (alpn_protos.empty()) returnSSL_TLSEXT_ERR_NOACK;
 
@@ -403,9 +403,9 @@ TLSWrap::TLSWrap(Environment* env,
 StreamBase(env),
  env_(env),
  kind_(kind),
- sc_(sc),
- has_active_write_issued_by_prev_listener_(
-under_stream_ws == UnderlyingStreamWriteStatus::kHasActive) {
+ sc_(sc) {
+flags_.has_active_write_issued_by_prev_listener =
+ under_stream_ws == UnderlyingStreamWriteStatus::kHasActive;
 MakeWeak();
 CHECK(sc_);
  ssl_ = sc_->CreateSSL();
@@ -444,8 +444,7 @@ SSL_SESSION* TLSWrap::ReleaseSession() {
 
 voidTLSWrap::InvokeQueued(int status, constchar* error_str) {
 Debug(this, "Invoking queued write callbacks (%d, %s)", status, error_str);
-if (!write_callback_scheduled_)
-return;
+if (!flags_.write_callback_scheduled) return;
 
 if (current_write_) {
  BaseObjectPtr<AsyncWrap> current_write = std::move(current_write_);
@@ -465,8 +464,8 @@ void TLSWrap::NewSessionDoneCb() {
 boolTLSWrap::OnEarlyClientHello(constunsignedchar* session_id,
 size_t session_id_len,
 bool has_ticket) {
-if (!hello_emitted_) {
-hello_emitted_ = true;
+if (!flags_.hello_emitted) {
+flags_.hello_emitted = true;
 Debug(this, "Scheduling onclienthello");
 
 // The hello data is only valid inside the library callback, and JS must
@@ -480,7 +479,7 @@ bool TLSWrap::OnEarlyClientHello(const unsigned char* session_id,
 if (ssl_) EmitClientHello(id, has_ticket);
  });
  }
-returnhello_answered_;
+returnflags_.hello_answered;
 }
 
 voidTLSWrap::EmitClientHello(const std::vector<unsignedchar>& session_id,
@@ -658,8 +657,8 @@ void TLSWrap::Start(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
 
-CHECK(!wrap->started_);
- wrap->started_ = true;
+CHECK(!wrap->flags_.started);
+ wrap->flags_.started = true;
 
 // Send ClientHello handshake
 CHECK(wrap->is_client());
@@ -703,7 +702,7 @@ void TLSWrap::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
 CHECK(!SSL_renegotiate_pending(ssl));
  Local<Value> callback;
 
- c->established_ = true;
+ c->flags_.established = true;
 
 if (object->Get(env->context(), env->onhandshakedone_string())
  .ToLocal(&callback) && callback->IsFunction()) {
@@ -727,17 +726,17 @@ void TLSWrap::EncOut() {
 return;
  }
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this,
 "Returning from EncOut(), "
 "has_active_write_issued_by_prev_listener_ is true");
 return;
  }
 
 // Split-off queue
-if (established_ && current_write_) {
+if (flags_.established && current_write_) {
 Debug(this, "EncOut() write is scheduled");
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
  }
 
 if (ssl_ == nullptr) {
@@ -750,7 +749,7 @@ void TLSWrap::EncOut() {
 Debug(this, "No pending encrypted output");
 if (!pending_cleartext_input_ ||
  pending_cleartext_input_->ByteLength() == 0) {
-if (!in_dowrite_) {
+if (!flags_.in_dowrite) {
 Debug(this, "No pending cleartext input, not inside DoWrite()");
 InvokeQueued(0);
  } else {
@@ -805,7 +804,7 @@ void TLSWrap::EncOut() {
 voidTLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 Debug(this, "OnStreamAfterWrite(status = %d)", status);
 
-if (has_active_write_issued_by_prev_listener_) [[unlikely]] {
+if (flags_.has_active_write_issued_by_prev_listener) [[unlikely]] {
 Debug(this, "Notify write finish to the previous_listener_");
 CHECK_EQ(write_size_, 0); // we must have restrained writes
 
@@ -830,7 +829,7 @@ void TLSWrap::OnStreamAfterWrite(WriteWrap* req_wrap, int status) {
 
 // Handle error
 if (status) {
-if (shutdown_) {
+if (flags_.shutdown) {
 Debug(this, "Ignoring error after shutdown");
 return;
  }
@@ -855,7 +854,7 @@ void TLSWrap::ClearOut() {
 Debug(this, "Trying to read cleartext output");
 
 // No reads after EOF
-if (eof_) {
+if (flags_.eof) {
 Debug(this, "Returning from ClearOut(), EOF reached");
 return;
  }
@@ -911,8 +910,8 @@ void TLSWrap::ClearOut() {
 int err = SSL_get_error(ssl_.get(), read);
 switch (err) {
 caseSSL_ERROR_ZERO_RETURN:
-if (!eof_) {
-eof_ = true;
+if (!flags_.eof) {
+flags_.eof = true;
 EmitRead(UV_EOF);
  }
 return;
@@ -1005,7 +1004,7 @@ void TLSWrap::ClearIn() {
 int err = SSL_get_error(ssl_.get(), written);
 if (err == SSL_ERROR_SSL || err == SSL_ERROR_SYSCALL) {
 Debug(this, "Got SSL error (%d)", err);
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 // TODO(@sam-github) Should forward an error object with
 // .code/.function/.etc, if possible.
 InvokeQueued(UV_EPROTO, GetBIOError().c_str());
@@ -1049,7 +1048,7 @@ bool TLSWrap::IsClosing() {
 
 intTLSWrap::ReadStart() {
 Debug(this, "ReadStart()");
-if (underlying_stream() != nullptr && !eof_)
+if (underlying_stream() != nullptr && !flags_.eof)
 returnunderlying_stream()->ReadStart();
 return0;
 }
@@ -1197,9 +1196,9 @@ int TLSWrap::DoWrite(WriteWrap* w,
 
 // Write any encrypted/handshake output that may be ready.
 // Guard against sync call of current_write_->Done(), its unsupported.
-in_dowrite_ = true;
+flags_.in_dowrite = true;
 EncOut();
-in_dowrite_ = false;
+flags_.in_dowrite = false;
 
 return0;
 }
@@ -1216,16 +1215,15 @@ void TLSWrap::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
 Debug(this, "Read %zd bytes from underlying stream", nread);
 
 // Ignore everything after close_notify (rfc5246#section-7.2.1)
-if (eof_)
-return;
+if (flags_.eof) return;
 
 if (nread < 0) {
 // Error should be emitted only after all data was read
 ClearOut();
 
 if (nread == UV_EOF) {
 // underlying stream already should have also called ReadStop on itself
-eof_ = true;
+flags_.eof = true;
  }
 
 EmitRead(nread);
@@ -1256,7 +1254,7 @@ int TLSWrap::DoShutdown(ShutdownWrap* req_wrap) {
 if (ssl_ && SSL_shutdown(ssl_.get()) == 0)
 SSL_shutdown(ssl_.get());
 
-shutdown_ = true;
+flags_.shutdown = true;
 EncOut();
 returnunderlying_stream()->DoShutdown(req_wrap);
 }
@@ -1352,7 +1350,7 @@ void TLSWrap::Destroy() {
 return;
 
 // If there is a write happening, mark it as finished.
-write_callback_scheduled_ = true;
+flags_.write_callback_scheduled = true;
 
 // And destroy
 InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
@@ -1389,7 +1387,7 @@ void TLSWrap::ResumeAfterCertCb(void* arg) {
 voidTLSWrap::EnableALPNCb(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* wrap;
 ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
- wrap->alpn_callback_enabled_ = true;
+ wrap->flags_.alpn_callback_enabled = true;
 
 SSL* ssl = wrap->ssl_.get();
 SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(ssl);
@@ -1418,7 +1416,7 @@ void TLSWrap::SetServername(const FunctionCallbackInfo<Value>& args) {
 
 CHECK_EQ(args.Length(), 1);
 CHECK(args[0]->IsString());
-CHECK(!wrap->started_);
+CHECK(!wrap->flags_.started);
 CHECK(wrap->is_client());
 
 CHECK(wrap->ssl_);
@@ -1633,7 +1631,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
-CHECK(w->is_waiting_cert_cb() && w->cert_cb_running_);
+CHECK(w->is_waiting_cert_cb() && w->flags_.cert_cb_running);
 
  Local<Object> object = w->object();
  Local<Value> ctx = object->Get(env->context(), env->sni_context_string())
@@ -1685,7 +1683,7 @@ void TLSWrap::CertCbDone(const FunctionCallbackInfo<Value>& args) {
  cb = w->cert_cb_;
  arg = w->cert_cb_arg_;
 
- w->cert_cb_running_ = false;
+ w->flags_.cert_cb_running = false;
  w->cert_cb_ = nullptr;
  w->cert_cb_arg_ = nullptr;
 
@@ -2072,7 +2070,7 @@ void TLSWrap::ExportKeyingMaterial(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::ClientHelloDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->hello_answered_ = true;
+ w->flags_.hello_answered = true;
  w->Cycle();
 }
 
@@ -2107,7 +2105,7 @@ void TLSWrap::GetTLSTicket(const FunctionCallbackInfo<Value>& args) {
 voidTLSWrap::NewSessionDone(const FunctionCallbackInfo<Value>& args) {
  TLSWrap* w;
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
- w->awaiting_new_session_ = false;
+ w->flags_.awaiting_new_session = false;
  w->NewSessionDoneCb();
 }
 
@@ -2188,7 +2186,7 @@ void TLSWrap::WritesIssuedByPrevListenerDone(
 ASSIGN_OR_RETURN_UNWRAP(&w, args.This());
 
 Debug(w, "WritesIssuedByPrevListenerDone is called");
- w->has_active_write_issued_by_prev_listener_ = false;
+ w->flags_.has_active_write_issued_by_prev_listener = false;
  w->EncOut(); // resume all of our restrained writes
 }
 

src/crypto/crypto_tls.h

@@ -62,22 +62,26 @@ class TLSWrap : public AsyncWrap,
 
 ~TLSWrap() override;
 
-inlineboolis_cert_cb_running() const { returncert_cb_running_; }
+inlineboolis_cert_cb_running() const { returnflags_.cert_cb_running; }
 inlineboolis_waiting_cert_cb() const { return cert_cb_ != nullptr; }
-inlineboolhas_session_callbacks() const { returnsession_callbacks_; }
+inlineboolhas_session_callbacks() const { returnflags_.session_callbacks; }
 // We need to suspend the ClientHello only for server session id
 // callbacks, and only on the first pass.
 inlineboolshould_suspend_for_client_hello() const {
-returnis_server() && session_callbacks_ && !hello_answered_;
+returnis_server() && flags_.session_callbacks && !flags_.hello_answered;
+ }
+inlinevoidset_cert_cb_running(bool on = true) {
+ flags_.cert_cb_running = on;
  }
-inlinevoidset_cert_cb_running(bool on = true) { cert_cb_running_ = on; }
 inlinevoidset_awaiting_new_session(bool on = true) {
-awaiting_new_session_ = on;
+flags_.awaiting_new_session = on;
  }
-inlinevoidenable_session_callbacks() { session_callbacks_ = true; }
+inlinevoidenable_session_callbacks() { flags_.session_callbacks = true; }
 inlineboolis_server() const { return kind_ == Kind::kServer; }
 inlineboolis_client() const { return kind_ == Kind::kClient; }
-inlineboolis_awaiting_new_session() const { return awaiting_new_session_; }
+inlineboolis_awaiting_new_session() const {
+return flags_.awaiting_new_session;
+ }
 
 // Implement StreamBase:
 boolIsAlive() override;
@@ -125,6 +129,14 @@ class TLSWrap : public AsyncWrap,
 
  std::string diagnostic_name() constoverride;
 
+boolget_alpn_callback_enabled() const {
+return flags_.alpn_callback_enabled;
+ }
+
+const std::vector<unsignedchar>& get_alpn_protos() const {
+return alpn_protos_;
+ }
+
 private:
 // OpenSSL structures are opaque. Estimate SSL memory size for OpenSSL 1.1.1b:
 // SSL: 6224
@@ -284,26 +296,30 @@ class TLSWrap : public AsyncWrap,
  BaseObjectPtr<AsyncWrap> current_empty_write_;
  std::string error_;
 
-bool session_callbacks_ = false;
-bool awaiting_new_session_ = false;
-// 'onclienthello' has been emitted for this connection.
-bool hello_emitted_ = false;
-// JS has answered it by calling clientHelloDone().
-bool hello_answered_ = false;
-bool in_dowrite_ = false;
-bool started_ = false;
-bool shutdown_ = false;
-bool cert_cb_running_ = false;
-bool eof_ = false;
-
 // TODO(@jasnell): These state flags should be revisited.
 // The established_ flag indicates that the handshake is
 // completed. The write_callback_scheduled_ flag is less
 // clear -- once it is set to true, it is never set to
 // false and it is only set to true after established_
 // is set to true, so it's likely redundant.
-bool established_ = false;
-bool write_callback_scheduled_ = false;
+structFlags {
+bool session_callbacks : 1;
+bool awaiting_new_session : 1;
+// 'onclienthello' has been emitted for this connection.
+bool hello_emitted : 1;
+// JS has answered it by calling clientHelloDone().
+bool hello_answered : 1;
+bool in_dowrite : 1;
+bool started : 1;
+bool shutdown : 1;
+bool cert_cb_running : 1;
+bool eof : 1;
+bool established : 1;
+bool write_callback_scheduled : 1;
+bool has_active_write_issued_by_prev_listener : 1;
+bool alpn_callback_enabled : 1;
+ };
+ Flags flags_{};
 
 int cycle_depth_ = 0;
 
@@ -313,11 +329,7 @@ class TLSWrap : public AsyncWrap,
 
  ncrypto::BIOPointer bio_trace_;
 
-bool has_active_write_issued_by_prev_listener_ = false;
-
-public:
  std::vector<unsignedchar> alpn_protos_; // Accessed by SelectALPNCallback.
-bool alpn_callback_enabled_ = false; // Accessed by SelectALPNCallback.
 };
 
 } // namespace crypto