tls: various variable name and comment cleanups.

Signed-off-by: Ismo Puustinen <ismo.puustinen@intel.com>
envoyproxy · Aug 22, 2019 · abf8758 · abf8758
1 parent b79e532
commit abf8758
Show file tree

Hide file tree

Showing 8 changed files with 33 additions and 41 deletions.
diff --git a/include/envoy/ssl/private_key/private_key.h b/include/envoy/ssl/private_key/private_key.h
@@ -70,17 +70,15 @@ class PrivateKeyMethodManager {
   /**
    * Finds and returns a private key operations provider for BoringSSL.
    *
-   * @param message a protobuf message object containing a
-   * PrivateKeyProvider message.
-   * @param private_key_method_provider_context context that provides components for creating and
-   * initializing connections for keyless TLS etc.
+   * @param config a protobuf message object containing a PrivateKeyProvider message.
+   * @param factory_context context that provides components for creating and
+   * initializing connections using asynchronous private key operations.
    * @return PrivateKeyMethodProvider the private key operations provider, or nullptr if
    * no provider can be used with the context configuration.
    */
-  virtual PrivateKeyMethodProviderSharedPtr
-  createPrivateKeyMethodProvider(const envoy::api::v2::auth::PrivateKeyProvider& message,
-                                 Envoy::Server::Configuration::TransportSocketFactoryContext&
-                                     private_key_method_provider_context) PURE;
+  virtual PrivateKeyMethodProviderSharedPtr createPrivateKeyMethodProvider(
+      const envoy::api::v2::auth::PrivateKeyProvider& config,
+      Envoy::Server::Configuration::TransportSocketFactoryContext& factory_context) PURE;
 };
 
 } // namespace Ssl

diff --git a/include/envoy/ssl/private_key/private_key_config.h b/include/envoy/ssl/private_key/private_key_config.h
@@ -12,10 +12,9 @@ namespace Ssl {
 class PrivateKeyMethodProviderInstanceFactory {
 public:
   virtual ~PrivateKeyMethodProviderInstanceFactory() = default;
-  virtual PrivateKeyMethodProviderSharedPtr
-  createPrivateKeyMethodProviderInstance(const envoy::api::v2::auth::PrivateKeyProvider& message,
-                                         Server::Configuration::TransportSocketFactoryContext&
-                                             private_key_method_provider_context) PURE;
+  virtual PrivateKeyMethodProviderSharedPtr createPrivateKeyMethodProviderInstance(
+      const envoy::api::v2::auth::PrivateKeyProvider& config,
+      Server::Configuration::TransportSocketFactoryContext& factory_context) PURE;
   virtual std::string name() const PURE;
 };
 

diff --git a/source/extensions/transport_sockets/tls/private_key/private_key_manager_impl.cc b/source/extensions/transport_sockets/tls/private_key/private_key_manager_impl.cc
@@ -9,17 +9,16 @@ namespace Tls {
 
 Envoy::Ssl::PrivateKeyMethodProviderSharedPtr
 PrivateKeyMethodManagerImpl::createPrivateKeyMethodProvider(
-    const envoy::api::v2::auth::PrivateKeyProvider& message,
-    Server::Configuration::TransportSocketFactoryContext& private_key_method_provider_context) {
+    const envoy::api::v2::auth::PrivateKeyProvider& config,
+    Server::Configuration::TransportSocketFactoryContext& factory_context) {
 
   Ssl::PrivateKeyMethodProviderInstanceFactory* factory =
       Registry::FactoryRegistry<Ssl::PrivateKeyMethodProviderInstanceFactory>::getFactory(
-          message.provider_name());
+          config.provider_name());
 
   // Create a new provider instance with the configuration.
   if (factory) {
-    return factory->createPrivateKeyMethodProviderInstance(message,
-                                                           private_key_method_provider_context);
+    return factory->createPrivateKeyMethodProviderInstance(config, factory_context);
   }
 
   return nullptr;

diff --git a/source/extensions/transport_sockets/tls/private_key/private_key_manager_impl.h b/source/extensions/transport_sockets/tls/private_key/private_key_manager_impl.h
@@ -12,10 +12,9 @@ namespace Tls {
 class PrivateKeyMethodManagerImpl : public virtual Ssl::PrivateKeyMethodManager {
 public:
   // Ssl::PrivateKeyMethodManager
-  Ssl::PrivateKeyMethodProviderSharedPtr
-  createPrivateKeyMethodProvider(const envoy::api::v2::auth::PrivateKeyProvider& message,
-                                 Server::Configuration::TransportSocketFactoryContext&
-                                     private_key_method_provider_context) override;
+  Ssl::PrivateKeyMethodProviderSharedPtr createPrivateKeyMethodProvider(
+      const envoy::api::v2::auth::PrivateKeyProvider& config,
+      Server::Configuration::TransportSocketFactoryContext& factory_context) override;
 };
 
 } // namespace Tls

diff --git a/source/extensions/transport_sockets/tls/ssl_socket.cc b/source/extensions/transport_sockets/tls/ssl_socket.cc
@@ -94,9 +94,9 @@ SslSocket::ReadResult SslSocket::sslReadIntoSlice(Buffer::RawSlice& slice) {
 }
 
 Network::IoResult SslSocket::doRead(Buffer::Instance& read_buffer) {
-  if (state_ != SocketState::HandShakeComplete && state_ != SocketState::ShutdownSent) {
+  if (state_ != SocketState::HandshakeComplete && state_ != SocketState::ShutdownSent) {
     PostIoAction action = doHandshake();
-    if (action == PostIoAction::Close || state_ != SocketState::HandShakeComplete) {
+    if (action == PostIoAction::Close || state_ != SocketState::HandshakeComplete) {
       // end_stream is false because either a hard error occurred (action == Close) or
       // the handshake isn't complete, so a half-close cannot occur yet.
       return {action, 0, false};
@@ -168,11 +168,11 @@ void SslSocket::onPrivateKeyMethodComplete() {
 }
 
 PostIoAction SslSocket::doHandshake() {
-  ASSERT(state_ != SocketState::HandShakeComplete && state_ != SocketState::ShutdownSent);
+  ASSERT(state_ != SocketState::HandshakeComplete && state_ != SocketState::ShutdownSent);
   int rc = SSL_do_handshake(ssl_.get());
   if (rc == 1) {
     ENVOY_CONN_LOG(debug, "handshake complete", callbacks_->connection());
-    state_ = SocketState::HandShakeComplete;
+    state_ = SocketState::HandshakeComplete;
     ctx_->logHandshake(ssl_.get());
     callbacks_->raiseEvent(Network::ConnectionEvent::Connected);
 
@@ -229,9 +229,9 @@ void SslSocket::drainErrorQueue() {
 
 Network::IoResult SslSocket::doWrite(Buffer::Instance& write_buffer, bool end_stream) {
   ASSERT(state_ != SocketState::ShutdownSent || write_buffer.length() == 0);
-  if (state_ != SocketState::HandShakeComplete && state_ != SocketState::ShutdownSent) {
+  if (state_ != SocketState::HandshakeComplete && state_ != SocketState::ShutdownSent) {
     PostIoAction action = doHandshake();
-    if (action == PostIoAction::Close || state_ != SocketState::HandShakeComplete) {
+    if (action == PostIoAction::Close || state_ != SocketState::HandshakeComplete) {
       return {action, 0, false};
     }
   }
@@ -414,7 +414,7 @@ void SslSocket::closeSocket(Network::ConnectionEvent) {
   // Attempt to send a shutdown before closing the socket. It's possible this won't go out if
   // there is no room on the socket. We can extend the state machine to handle this at some point
   // if needed.
-  if (state_ == SocketState::HandshakeInProgress || state_ == SocketState::HandShakeComplete) {
+  if (state_ == SocketState::HandshakeInProgress || state_ == SocketState::HandshakeComplete) {
     shutdownSsl();
   }
 }

diff --git a/source/extensions/transport_sockets/tls/ssl_socket.h b/source/extensions/transport_sockets/tls/ssl_socket.h
@@ -39,7 +39,7 @@ struct SslSocketFactoryStats {
 };
 
 enum class InitialState { Client, Server };
-enum class SocketState { PreHandshake, HandshakeInProgress, HandShakeComplete, ShutdownSent };
+enum class SocketState { PreHandshake, HandshakeInProgress, HandshakeComplete, ShutdownSent };
 
 class SslSocket : public Network::TransportSocket,
                   public Envoy::Ssl::ConnectionInfo,
@@ -73,7 +73,7 @@ class SslSocket : public Network::TransportSocket,
   void setTransportSocketCallbacks(Network::TransportSocketCallbacks& callbacks) override;
   std::string protocol() const override;
   absl::string_view failureReason() const override;
-  bool canFlushClose() override { return state_ == SocketState::HandShakeComplete; }
+  bool canFlushClose() override { return state_ == SocketState::HandshakeComplete; }
   void closeSocket(Network::ConnectionEvent close_type) override;
   Network::IoResult doRead(Buffer::Instance& read_buffer) override;
   Network::IoResult doWrite(Buffer::Instance& write_buffer, bool end_stream) override;

diff --git a/test/extensions/transport_sockets/tls/test_private_key_method_provider.h b/test/extensions/transport_sockets/tls/test_private_key_method_provider.h
@@ -82,12 +82,10 @@ class TestPrivateKeyMethodProvider : public virtual Ssl::PrivateKeyMethodProvide
 class TestPrivateKeyMethodFactory : public Ssl::PrivateKeyMethodProviderInstanceFactory {
 public:
   // Ssl::PrivateKeyMethodProviderInstanceFactory
-  Ssl::PrivateKeyMethodProviderSharedPtr
-  createPrivateKeyMethodProviderInstance(const envoy::api::v2::auth::PrivateKeyProvider& message,
-                                         Server::Configuration::TransportSocketFactoryContext&
-                                             private_key_method_provider_context) override {
-    return std::make_shared<TestPrivateKeyMethodProvider>(message.config(),
-                                                          private_key_method_provider_context);
+  Ssl::PrivateKeyMethodProviderSharedPtr createPrivateKeyMethodProviderInstance(
+      const envoy::api::v2::auth::PrivateKeyProvider& config,
+      Server::Configuration::TransportSocketFactoryContext& factory_context) override {
+    return std::make_shared<TestPrivateKeyMethodProvider>(config.config(), factory_context);
   }
 
   std::string name() const override { return std::string("test"); };

diff --git a/test/mocks/ssl/mocks.h b/test/mocks/ssl/mocks.h
@@ -114,11 +114,10 @@ class MockPrivateKeyMethodManager : public PrivateKeyMethodManager {
   MockPrivateKeyMethodManager();
   ~MockPrivateKeyMethodManager() override;
 
-  MOCK_METHOD2(
-      createPrivateKeyMethodProvider,
-      PrivateKeyMethodProviderSharedPtr(const envoy::api::v2::auth::PrivateKeyProvider& message,
-                                        Envoy::Server::Configuration::TransportSocketFactoryContext&
-                                            private_key_method_provider_context));
+  MOCK_METHOD2(createPrivateKeyMethodProvider,
+               PrivateKeyMethodProviderSharedPtr(
+                   const envoy::api::v2::auth::PrivateKeyProvider& config,
+                   Envoy::Server::Configuration::TransportSocketFactoryContext& factory_context));
 };
 
 class MockPrivateKeyMethodProvider : public PrivateKeyMethodProvider {