Add Connection Source

* Record and expose source, family and encryption of connection
* Remove testing classes from public header

Author: drewaogle

include/comm/Connection.h

@@ -31,6 +31,7 @@
 #pragma once
 
 #include <string>
+#include <memory>
 #include "util/Macros.h"
 
 namespace comm
@@ -60,6 +61,11 @@ class Connection
     void set_max_buffer_size(uint32_t max_buffer_size);
     bool check_message_size(uint32_t size);
 
+    std::string source_family_name(short source_family) const;
+    virtual std::string get_source() const     = 0;
+    virtual short get_source_family() const    = 0;
+    virtual std::string get_encryption() const = 0;
+
    protected:
     virtual size_t read(uint8_t* buffer, size_t length)        = 0;
     virtual size_t write(const uint8_t* buffer, size_t length) = 0;

src/comm/Connection.cc

@@ -33,6 +33,8 @@
 #include "comm/Exception.h"
 #include "comm/Variables.h"
 
+#include <arpa/inet.h>
+
 using namespace comm;
 
 Connection::Connection(ConnMetrics* metrics)
@@ -125,6 +127,18 @@ void Connection::set_max_buffer_size(uint32_t max_buffer_size)
     _max_buffer_size = std::min(MAX_BUFFER_SIZE, _max_buffer_size);
 }
 
+std::string Connection::source_family_name(short source_family) const
+{
+    switch (source_family) {
+        case AF_INET:
+            return "ipv4";
+        case AF_UNSPEC:
+            return "unspec";
+        default:
+            return "unk";
+    }
+}
+
 ConnMetrics::~ConnMetrics() = default;
 
 void ConnMetrics::observe_bytes_sent(std::size_t /*bytes_sent*/) {}

src/comm/TCPConnection.cc

@@ -41,8 +41,6 @@
 
 using namespace comm;
 
-TCPConnection::TCPConnection(ConnMetrics* metrics) : Connection(metrics), _tcp_socket() {}
-
 TCPConnection::TCPConnection(std::unique_ptr< TCPSocket > tcp_socket, ConnMetrics* metrics)
     : Connection(metrics), _tcp_socket(std::move(tcp_socket))
 {
@@ -103,3 +101,9 @@ size_t TCPConnection::write(const uint8_t* buffer, size_t length)
 
     return static_cast< size_t >(count);
 }
+
+std::string TCPConnection::get_source() const { return _tcp_socket->print_source(); }
+
+short TCPConnection::get_source_family() const { return _tcp_socket->source_family(); }
+
+std::string TCPConnection::get_encryption() const { return "none"; }

src/comm/TCPConnection.h

@@ -45,14 +45,16 @@ class TCPConnection : public Connection
     friend class TLSConnClient;
 
    public:
-    explicit TCPConnection(ConnMetrics* metrics = nullptr);
     explicit TCPConnection(std::unique_ptr< TCPSocket > tcp_socket, ConnMetrics* metrics = nullptr);
 
     MOVEABLE_BY_DEFAULT(TCPConnection);
     NOT_COPYABLE(TCPConnection);
 
     std::unique_ptr< TCPSocket > release_socket();
     void shutdown();
+    std::string get_source() const override;
+    short get_source_family() const override;
+    std::string get_encryption() const override;
 
    protected:
     size_t read(uint8_t* buffer, size_t length) override;

src/comm/TCPSocket.cc

@@ -6,8 +6,8 @@
 
 #include <cstring>
 #include <netdb.h>
-#include <netinet/ip.h>
 #include <sys/socket.h>
+#include <arpa/inet.h>
 #include <unistd.h>
 
 #include "util/gcc_util.h"
@@ -21,8 +21,10 @@ ENABLE_WARNING(effc++)
 #include "comm/Variables.h"
 
 using namespace comm;
-
-TCPSocket::TCPSocket(int socket_fd) : _socket_fd(socket_fd) {}
+TCPSocket::TCPSocket(int socket_fd, sockaddr_in address)
+    : _socket_fd(socket_fd), _source_family(AF_INET), _source(std::move(address))
+{
+}
 
 TCPSocket::~TCPSocket()
 {
@@ -66,7 +68,7 @@ std::unique_ptr< TCPSocket > TCPSocket::accept(const std::unique_ptr< TCPSocket
     }
     // MAGICK can be done here
 
-    return std::unique_ptr< TCPSocket >(new TCPSocket(connected_socket));
+    return std::unique_ptr< TCPSocket >(new TCPSocket(connected_socket, std::move(clnt_addr)));
 }
 
 bool TCPSocket::bind(int port)
@@ -104,12 +106,14 @@ bool TCPSocket::connect(const Address& address)
 std::unique_ptr< TCPSocket > TCPSocket::create()
 {
     int tcp_socket = ::socket(AF_INET, SOCK_STREAM, 0);
+    sockaddr_in source;
+    memset(&source, 0, sizeof(_source));
 
     if (tcp_socket < 0) {
         THROW_EXCEPTION(SocketFail);
     }
 
-    return std::unique_ptr< TCPSocket >(new TCPSocket(tcp_socket));
+    return std::unique_ptr< TCPSocket >(new TCPSocket(tcp_socket, std::move(source)));
 }
 
 bool TCPSocket::listen() { return ::listen(_socket_fd, MAX_CONN_QUEUE) == 0; }
@@ -127,3 +131,14 @@ bool TCPSocket::set_timeval_option(int level, int option_name, timeval value)
 }
 
 void TCPSocket::shutdown() { ::shutdown(_socket_fd, SHUT_RDWR); }
+
+std::string TCPSocket::print_source()
+{
+    if (_source_family == AF_UNSPEC) {
+        return "";
+    } else {
+        return std::string(inet_ntoa(_source.sin_addr));
+    }
+}
+
+short TCPSocket::source_family() { return _source_family; }

src/comm/TCPSocket.h

@@ -32,6 +32,7 @@
 
 #include <memory>
 #include <string>
+#include <netinet/ip.h>
 
 #include "comm/Address.h"
 
@@ -60,10 +61,15 @@ class TCPSocket
     bool set_timeval_option(int level, int option_name, timeval value);
     void shutdown();
 
+    std::string print_source();
+    short source_family();
+
    private:
-    explicit TCPSocket(int socket_fd);
+    explicit TCPSocket(int socket_fd, sockaddr_in);
 
     int _socket_fd{-1};
+    short _source_family{AF_UNSPEC};
+    struct sockaddr_in _source;
 };
 
 };  // namespace comm

src/comm/TLSConnection.cc

@@ -22,8 +22,6 @@ ENABLE_WARNING(effc++)
 
 using namespace comm;
 
-TLSConnection::TLSConnection(ConnMetrics* metrics) : Connection(metrics), _tls_socket() {}
-
 TLSConnection::TLSConnection(std::unique_ptr< TLSSocket > tls_socket, ConnMetrics* metrics)
     : Connection(metrics), _tls_socket(std::move(tls_socket))
 {
@@ -86,3 +84,9 @@ size_t TLSConnection::write(const uint8_t* buffer, size_t length)
 
     return static_cast< size_t >(count);
 }
+
+std::string TLSConnection::get_source() const { return _tls_socket->print_source(); }
+
+short TLSConnection::get_source_family() const { return _tls_socket->source_family(); }
+
+std::string TLSConnection::get_encryption() const { return "tls"; }

src/comm/TLSConnection.h

@@ -17,12 +17,15 @@ namespace comm
 class TLSConnection : public Connection
 {
    public:
-    explicit TLSConnection(ConnMetrics* metrics = nullptr);
     explicit TLSConnection(std::unique_ptr< TLSSocket > tls_socket, ConnMetrics* metrics = nullptr);
 
     MOVEABLE_BY_DEFAULT(TLSConnection);
     NOT_COPYABLE(TLSConnection);
 
+    std::string get_source() const override;
+    short get_source_family() const override;
+    std::string get_encryption() const override;
+
    protected:
     size_t read(uint8_t* buffer, size_t length) override;
     size_t write(const uint8_t* buffer, size_t length) override;

src/comm/TLSSocket.cc

@@ -67,3 +67,7 @@ std::unique_ptr< TLSSocket > TLSSocket::create(std::unique_ptr< TCPSocket > tcp_
 
     return std::unique_ptr< TLSSocket >(new TLSSocket(std::move(tcp_socket), ssl));
 }
+
+std::string TLSSocket::print_source() { return _tcp_socket->print_source(); }
+
+short TLSSocket::source_family() { return _tcp_socket->source_family(); }

src/comm/TLSSocket.h

@@ -30,6 +30,9 @@ class TLSSocket
     void accept();
     void connect();
 
+    std::string print_source();
+    short source_family();
+
    private:
     explicit TLSSocket(std::unique_ptr< TCPSocket > tcp_socket, SSL* ssl);