Changes to TLS::Callbacks for GH PR #457

Make TLS::Channel::m_callbacks a reference, so deriving from TLS::Callbacks works

Split out the compat (std::function) based interface to Compat_Callbacks.
This avoids the overhead of empty std::functions when using the virtual
interface, and ensures the virtual interface works since there is no
callback path that does not involve a vtable lookup.

Rename the TLS::Callback functions. Since the idea is that often an owning
class will pass *this as the callbacks argument, it is good to namespace
the virtual functions so as not to conflict with other names chosen by
the class. Specifically, prefixes all cb functions with tls_

Revert changes to use the old style alert callback (with no longer used data/len
params) so no API changes are required for old code. The new Callbacks interface
continues to just receive the alert code itself.

Switch to virtual function interface in CLI tls_client for testing.

Inline tls_server_handshake_state.h - only used in tls_server.cpp

Fix tests - test looked like it was creating a new client object but it
was not actually being used. And when enabled, it failed because the queues
were not being emptied in between. So, fix that.

1 files changed, 16 insertions, 22 deletions

diff --git a/src/cli/tls_client.cpp b/src/cli/tls_client.cpp
index e2fc1f027..082daf4ac 100644
--- a/src/cli/tls_client.cpp
+++ b/src/cli/tls_client.cpp
@@ -36,7 +36,7 @@
 
 namespace Botan_CLI {
 
-class TLS_Client final : public Command
+class TLS_Client final : public Command, public Botan::TLS::Callbacks
    {
    public:
       TLS_Client() : Command("tls_client host --port=443 --print-certs --policy= "
@@ -99,15 +99,10 @@ class TLS_Client final : public Command
 
          const std::vector<std::string> protocols_to_offer = Botan::split_on("next-protocols", ',');
 
-         int sockfd = connect_to_host(host, port, use_tcp);
+         m_sockfd = connect_to_host(host, port, use_tcp);
 
          using namespace std::placeholders;
 
-         auto socket_write =
-            use_tcp ?
-            std::bind(stream_socket_write, sockfd, _1, _2) :
-            std::bind(dgram_socket_write, sockfd, _1, _2);
-
          auto version = policy->latest_supported_version(!use_tcp);
 
          if(flag_set("tls1.0"))
@@ -119,11 +114,7 @@ class TLS_Client final : public Command
             version = Botan::TLS::Protocol_Version::TLS_V11;
             }
 
-         Botan::TLS::Client client(Botan::TLS::Callbacks(
-                                      socket_write,
-                                      std::bind(&TLS_Client::process_data, this, _1, _2),
-                                      std::bind(&TLS_Client::alert_received, this, _1),
-                                      std::bind(&TLS_Client::handshake_complete, this, _1)),
+         Botan::TLS::Client client(*this,
                                    *session_mgr,
                                    creds,
                                    *policy,
@@ -138,7 +129,7 @@ class TLS_Client final : public Command
             {
             fd_set readfds;
             FD_ZERO(&readfds);
-            FD_SET(sockfd, &readfds);
+            FD_SET(m_sockfd, &readfds);
 
             if(client.is_active())
                {
@@ -154,13 +145,13 @@ class TLS_Client final : public Command
 
             struct timeval timeout = { 1, 0 };
 
-            ::select(sockfd + 1, &readfds, nullptr, nullptr, &timeout);
+            ::select(m_sockfd + 1, &readfds, nullptr, nullptr, &timeout);
 
-            if(FD_ISSET(sockfd, &readfds))
+            if(FD_ISSET(m_sockfd, &readfds))
                {
                uint8_t buf[4*1024] = { 0 };
 
-               ssize_t got = ::read(sockfd, buf, sizeof(buf));
+               ssize_t got = ::read(m_sockfd, buf, sizeof(buf));
 
                if(got == 0)
                   {
@@ -218,7 +209,7 @@ class TLS_Client final : public Command
                }
             }
 
-         ::close(sockfd);
+         ::close(m_sockfd);
          }
 
    private:
@@ -258,7 +249,7 @@ class TLS_Client final : public Command
          return fd;
          }
 
-      bool handshake_complete(const Botan::TLS::Session& session)
+      bool tls_session_established(const Botan::TLS::Session& session) override
          {
          output() << "Handshake complete, " << session.version().to_string()
                    << " using " << session.ciphersuite().to_string() << "\n";
@@ -292,13 +283,13 @@ class TLS_Client final : public Command
             throw CLI_Error("Socket write failed errno=" + std::to_string(errno));
          }
 
-      static void stream_socket_write(int sockfd, const uint8_t buf[], size_t length)
+      void tls_emit_data(const uint8_t buf[], size_t length) override
          {
          size_t offset = 0;
 
          while(length)
             {
-            ssize_t sent = ::send(sockfd, (const char*)buf + offset,
+            ssize_t sent = ::send(m_sockfd, (const char*)buf + offset,
                                   length, MSG_NOSIGNAL);
 
             if(sent == -1)
@@ -314,16 +305,19 @@ class TLS_Client final : public Command
             }
          }
 
-      void alert_received(Botan::TLS::Alert alert)
+      void tls_alert(Botan::TLS::Alert alert)
          {
          output() << "Alert: " << alert.type_string() << "\n";
          }
 
-      void process_data(const uint8_t buf[], size_t buf_size)
+      void tls_record_received(uint64_t seq_no, const uint8_t buf[], size_t buf_size)
          {
          for(size_t i = 0; i != buf_size; ++i)
             output() << buf[i];
          }
+
+      private:
+         int m_sockfd;
    };
 
 BOTAN_REGISTER_COMMAND("tls_client", TLS_Client);