Merge pull request #17 from atelier-saulx/feature/tls-flag

frammaa · web-flow · commit 4408bb12cfdf · 2024-07-31T16:25:08.000+02:00
Make TLS a runtime flag
diff --git a/packages/cpp-client/example/example.cpp b/packages/cpp-client/example/example.cpp
@@ -35,10 +35,10 @@ void based_observe_cb(const char* data, uint64_t checksum, const char* error, in
 }
 
 int main(int argc, char** argv) {
-    int client1 = Based__new_client();
+    int client1 = Based__new_client(false);
 
     Based__connect(client1, (char*)"local", (char*)"saulx", (char*)"test", (char*)"ci", (char*)"",
-                   (char*)"", false, (char*)"", (char*)"http://192.168.1.10:24587");
+                   (char*)"", false, (char*)"", (char*)"192.168.1.10:24587");
 
     // Based__connect_to_url(client1, (char*)"ws://localhost:9999");
 
diff --git a/packages/cpp-client/include/based.h b/packages/cpp-client/include/based.h
@@ -8,7 +8,7 @@ typedef int32_t based_id;
 // using based_observe_cb = void (*)(char*, uint64_t, char*);
 // using based_cb = void (*)(char*, char*);
 
-extern "C" based_id Based__new_client();
+extern "C" based_id Based__new_client(bool enable_tls);
 extern "C" void Based__delete_client(based_id client_id);
 
 extern "C" char* Based__get_service(based_id client_id,
diff --git a/packages/cpp-client/src/based.cpp b/packages/cpp-client/src/based.cpp
@@ -8,8 +8,8 @@ based_id idx = 0;
 char get_service_buf[1024];
 char auth_state_buf[1048576];
 
-extern "C" based_id Based__new_client() {
-    BasedClient* cl = new BasedClient;
+extern "C" based_id Based__new_client(bool enable_tls) {
+    BasedClient* cl = new BasedClient(enable_tls);
     idx++;
 
     if (clients.find(idx) != clients.end()) {
diff --git a/packages/cpp-client/src/basedclient.cpp b/packages/cpp-client/src/basedclient.cpp
@@ -20,7 +20,11 @@ enum IncomingType {
     CHANNEL_MESSAGE = 7,
 };
 
-BasedClient::BasedClient() : m_request_id(0), m_sub_id(0), m_auth_in_progress(false){};
+BasedClient::BasedClient(bool enable_tls)
+    : m_request_id(0),
+      m_sub_id(0),
+      m_auth_in_progress(false),
+      m_con(enable_tls){};
 
 /////////////////
 // Helper functions
diff --git a/packages/cpp-client/src/basedclient.hpp b/packages/cpp-client/src/basedclient.hpp
@@ -140,7 +140,7 @@ class BasedClient {
     std::map<sub_id_t, void (*)(const char*, const char*, int)> m_get_sub_callbacks;
 
    public:
-    BasedClient();
+    BasedClient(bool enable_tls);
 
     /**
      * @brief Function to retrieve the url of a specific service.
diff --git a/packages/cpp-client/src/connection.cpp b/packages/cpp-client/src/connection.cpp
@@ -204,36 +204,36 @@ std::pair<std::string, std::string> WsConnection::make_request(std::string url,
 ///////////////////////// Class methods /////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
-WsConnection::WsConnection()
+WsConnection::WsConnection(bool enable_tls)
     : m_status(ConnectionStatus::CLOSED),
       m_on_open(NULL),
       m_on_message(NULL),
       m_reconnect_attempts(0) {
-    // set the endpoint logging behavior to silent by clearing all of the access and error
-    // logging channels
-    m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-    m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
-
-    // try {
-    m_endpoint.init_asio();
-    // } catch (const websocketpp::exception& e) {
-    //     std::cout << "CAUGHT ERROR!!!" << e.m_msg << std::endl;
-    // }
-#ifdef BASED_TLS
-    m_endpoint.set_tls_init_handler(websocketpp::lib::bind(&WsConnection::on_tls_init));
-#endif
-
-    // perpetual mode = the endpoint's processing loop will not exit automatically when it has
-    // no connections
-    m_endpoint.start_perpetual();
-    // run perpetually in a thread
-
-    m_thread = std::make_shared<std::thread>(&ws_client::run, &m_endpoint);
+    m_enable_tls = enable_tls;
+    BASED_LOG("ENABLE TLS = %d", m_enable_tls);
+    if (m_enable_tls) {
+        m_wss_endpoint.clear_access_channels(websocketpp::log::alevel::all);
+        m_wss_endpoint.clear_error_channels(websocketpp::log::elevel::all);
+        m_wss_endpoint.init_asio();
+        m_wss_endpoint.set_tls_init_handler(websocketpp::lib::bind(&WsConnection::on_tls_init));
+        m_wss_endpoint.start_perpetual();
+        m_thread = std::make_shared<std::thread>(&wss_client::run, &m_wss_endpoint);
+    } else {
+        m_ws_endpoint.clear_access_channels(websocketpp::log::alevel::all);
+        m_ws_endpoint.clear_error_channels(websocketpp::log::elevel::all);
+        m_ws_endpoint.init_asio();
+        m_ws_endpoint.start_perpetual();
+        m_thread = std::make_shared<std::thread>(&ws_client::run, &m_ws_endpoint);
+    }
 };
 
 WsConnection::~WsConnection() {
     disconnect();
-    m_endpoint.stop_perpetual();
+    if (m_enable_tls) {
+        m_wss_endpoint.stop_perpetual();
+    } else {
+        m_ws_endpoint.stop_perpetual();
+    }
     m_thread->join();
 
     BASED_LOG("Destroyed WsConnection obj");
@@ -256,11 +256,11 @@ std::string WsConnection::discover_service(BasedConnectOpt opts, bool http) {
     auto service_url = req.first;
     auto access_key = req.second;
     url = service_url;
-#ifdef BASED_TLS
-    return http ? "https://" + url : "wss://" + url + "/" + access_key;
-#else
-    return http ? "http://" + url : "ws://" + url + "/" + access_key;
-#endif
+    if (m_enable_tls) {
+        return http ? "https://" + url : "wss://" + url + "/" + access_key;
+    } else {
+        return http ? "http://" + url : "ws://" + url + "/" + access_key;
+    }
 }
 
 void WsConnection::connect(std::string cluster,
@@ -303,27 +303,51 @@ void WsConnection::connect_to_uri(std::string uri) {
 
     m_uri = uri;
     websocketpp::lib::error_code ec;
-    ws_client::connection_ptr con = m_endpoint.get_connection(m_uri, ec);
 
-    if (ec) {
-        BASED_LOG("Error trying to initialize connection, message = \"%s\"", ec.message().c_str());
-        m_status = ConnectionStatus::FAILED;
-        return;
-    }
+    if (m_enable_tls) {
+        wss_client::connection_ptr con = m_wss_endpoint.get_connection(m_uri, ec);
+
+        if (ec) {
+            BASED_LOG("Error trying to initialize connection, message = \"%s\"",
+                      ec.message().c_str());
+            m_status = ConnectionStatus::FAILED;
+            return;
+        }
+
+        m_status = ConnectionStatus::CONNECTING;
 
-    m_status = ConnectionStatus::CONNECTING;
+        // Add special headers
 
-    // Add special headers
+        con->append_header("sec-websocket-protocol", "{}");
 
-    con->append_header("sec-websocket-protocol", "{}");
+        m_hdl = con->get_handle();
 
-    m_hdl = con->get_handle();
+        set_handlers(con);
 
-    set_handlers(con);
+        m_wss_endpoint.connect(con);
 
-    m_endpoint.connect(con);
+    } else {
+        ws_client::connection_ptr con = m_ws_endpoint.get_connection(m_uri, ec);
 
-    return;
+        if (ec) {
+            BASED_LOG("Error trying to initialize connection, message = \"%s\"",
+                      ec.message().c_str());
+            m_status = ConnectionStatus::FAILED;
+            return;
+        }
+
+        m_status = ConnectionStatus::CONNECTING;
+
+        // Add special headers
+
+        con->append_header("sec-websocket-protocol", "{}");
+
+        m_hdl = con->get_handle();
+
+        set_handlers(con);
+
+        m_ws_endpoint.connect(con);
+    }
 };
 
 void WsConnection::set_open_handler(std::function<void()> on_open) {
@@ -343,7 +367,11 @@ void WsConnection::disconnect() {
     m_status = ConnectionStatus::TERMINATED_BY_USER;
 
     websocketpp::lib::error_code ec;
-    m_endpoint.close(m_hdl, websocketpp::close::status::going_away, "", ec);
+    if (m_enable_tls) {
+        m_wss_endpoint.close(m_hdl, websocketpp::close::status::going_away, "", ec);
+    } else {
+        m_ws_endpoint.close(m_hdl, websocketpp::close::status::going_away, "", ec);
+    }
     if (ec) {
         BASED_LOG("Error trying to close connection, message = \"%s\"", ec.message().c_str());
 
@@ -356,7 +384,13 @@ void WsConnection::send(std::vector<uint8_t> message) {
 
     if (m_status != ConnectionStatus::OPEN) throw(std::runtime_error("Connection is not open."));
 
-    m_endpoint.send(m_hdl, message.data(), message.size(), websocketpp::frame::opcode::binary, ec);
+    if (m_enable_tls) {
+        m_wss_endpoint.send(m_hdl, message.data(), message.size(),
+                            websocketpp::frame::opcode::binary, ec);
+    } else {
+        m_ws_endpoint.send(m_hdl, message.data(), message.size(),
+                           websocketpp::frame::opcode::binary, ec);
+    }
     if (ec) {
         BASED_LOG("Error trying to send message, message = \"%s\"", ec.message().c_str());
         return;
@@ -367,10 +401,7 @@ ConnectionStatus WsConnection::status() {
     return m_status;
 };
 
-#ifdef BASED_TLS
-#ifdef ASIO_STANDALONE
 using context_ptr = std::shared_ptr<asio::ssl::context>;
-
 context_ptr WsConnection::on_tls_init() {
     context_ptr ctx = std::make_shared<asio::ssl::context>(asio::ssl::context::sslv23);
 
@@ -383,27 +414,59 @@ context_ptr WsConnection::on_tls_init() {
     }
     return ctx;
 }
-#else
-using context_ptr = std::shared_ptr<boost::asio::ssl::context>;
 
-context_ptr WsConnection::on_tls_init() {
-    context_ptr ctx =
-        std::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23);
+void WsConnection::set_handlers(ws_client::connection_ptr con) {
+    // bind must be used if the function we're binding to doest have the right number of
+    // arguments (hence the placeholders) these handlers must be set before calling connect, and
+    // can't be changed after (i think)
+    con->set_open_handler([this](websocketpp::connection_hdl) {
+        BASED_LOG("Connection opened");
+        m_status = ConnectionStatus::OPEN;
+        m_reconnect_attempts = 0;
+        if (m_on_open) {
+            m_on_open();
+        }
+    });
 
-    try {
-        ctx->set_options(boost::asio::ssl::context::default_workarounds |
-                         boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::no_sslv3 |
-                         boost::asio::ssl::context::single_dh_use);
+    con->set_message_handler([this](websocketpp::connection_hdl hdl, ws_client::message_ptr msg) {
+        // here we will pass the message to the decoder, which, based on the header, will
+        // call the appropriate callback
 
-    } catch (std::exception& e) {
-        std::cerr << "Error in context pointer: " << e.what() << std::endl;
-    }
-    return ctx;
+        std::string payload = msg->get_payload();
+        if (m_on_message) {
+            m_on_message(payload);
+        }
+    });
+
+    con->set_close_handler([this](websocketpp::connection_hdl) {
+        if (m_status != ConnectionStatus::TERMINATED_BY_USER) {
+            m_status = ConnectionStatus::CLOSED;
+            m_reconnect_attempts++;
+
+            if (!m_opts.name.empty()) {
+                connect(m_opts.cluster, m_opts.org, m_opts.project, m_opts.env, m_opts.key,
+                        m_opts.optional_key, m_opts.host, m_opts.discovery_url);
+            } else {
+                connect_to_uri(m_uri);
+            }
+        }
+    });
+
+    con->set_fail_handler([this](websocketpp::connection_hdl) {
+        BASED_LOG("Received FAIL event");
+        m_status = ConnectionStatus::FAILED;
+        m_reconnect_attempts++;
+
+        if (m_uri.size() == 0) {
+            connect(m_opts.cluster, m_opts.org, m_opts.project, m_opts.env, m_opts.key,
+                    m_opts.optional_key, m_opts.host, m_opts.discovery_url);
+        } else {
+            connect_to_uri(m_uri);
+        }
+    });
 }
-#endif
-#endif
 
-void WsConnection::set_handlers(ws_client::connection_ptr con) {
+void WsConnection::set_handlers(wss_client::connection_ptr con) {
     // bind must be used if the function we're binding to doest have the right number of
     // arguments (hence the placeholders) these handlers must be set before calling connect, and
     // can't be changed after (i think)
@@ -416,7 +479,7 @@ void WsConnection::set_handlers(ws_client::connection_ptr con) {
         }
     });
 
-    con->set_message_handler([this](websocketpp::connection_hdl hdl, ws_client::message_ptr msg) {
+    con->set_message_handler([this](websocketpp::connection_hdl hdl, wss_client::message_ptr msg) {
         // here we will pass the message to the decoder, which, based on the header, will
         // call the appropriate callback
 
diff --git a/packages/cpp-client/src/connection.hpp b/packages/cpp-client/src/connection.hpp
@@ -6,13 +6,11 @@
 #include <thread>
 #include <websocketpp/client.hpp>
 
-#ifdef BASED_TLS
-#include <websocketpp/config/asio_client.hpp>                                 // SSL
-typedef websocketpp::client<websocketpp::config::asio_tls_client> ws_client;  // SSL
-#else
+#include <websocketpp/config/asio_client.hpp>         // SSL
 #include <websocketpp/config/asio_no_tls_client.hpp>  // No SSL
-typedef websocketpp::client<websocketpp::config::asio_client> ws_client;  // No SSL
-#endif
+
+typedef websocketpp::client<websocketpp::config::asio_tls_client> wss_client;  // SSL
+typedef websocketpp::client<websocketpp::config::asio_client> ws_client;       // No SSL
 
 enum ConnectionStatus { OPEN = 0, CONNECTING, CLOSED, FAILED, TERMINATED_BY_USER };
 
@@ -33,7 +31,7 @@ struct BasedConnectOpt {
 class WsConnection {
     // eventually there should be some logic here to handle inactivity.
    public:
-    WsConnection();
+    WsConnection(bool enable_tls);
     ~WsConnection();
     void connect(std::string cluster,
                  std::string org,
@@ -53,18 +51,15 @@ class WsConnection {
     std::string discover_service(BasedConnectOpt opts, bool http);
 
     void set_handlers(ws_client::connection_ptr con);
-#ifdef BASED_TLS
-#ifdef ASIO_STANDALONE
+    void set_handlers(wss_client::connection_ptr con);
+
     using context_ptr = std::shared_ptr<asio::ssl::context>;
     static context_ptr on_tls_init();
-#else
-    // Use Boost
-    using context_ptr = std::shared_ptr<boost::asio::ssl::context>;
-    static context_ptr on_tls_init();
-#endif
-#endif
+
    private:  // Members
-    ws_client m_endpoint;
+    bool m_enable_tls;
+    ws_client m_ws_endpoint;
+    wss_client m_wss_endpoint;
     websocketpp::connection_hdl m_hdl;
     ConnectionStatus m_status;
     std::string m_uri;

Original file line number	Diff line number	Diff line change
`@@ -35,10 +35,10 @@ void based_observe_cb(const char* data, uint64_t checksum, const char* error, in`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`int main(int argc, char** argv) {`
`38`		`- int client1 = Based__new_client();`
	`38`	`+ int client1 = Based__new_client(false);`
`39`	`39`
`40`	`40`	`Based__connect(client1, (char)"local", (char)"saulx", (char)"test", (char)"ci", (char*)"",`
`41`		`- (char)"", false, (char)"", (char*)"http://192.168.1.10:24587");`
	`41`	`+ (char)"", false, (char)"", (char*)"192.168.1.10:24587");`
`42`	`42`
`43`	`43`	`// Based__connect_to_url(client1, (char*)"ws://localhost:9999");`
`44`	`44`