Fix build failures depending on build optionsfix/5.1.0_build_failures

3 files changed, 87 insertions, 45 deletions

diff --git a/src/components/transport_manager/include/transport_manager/cloud/websocket_client_connection.h b/src/components/transport_manager/include/transport_manager/cloud/websocket_client_connection.h
index aa608312a0..a726524af2 100644
--- a/src/components/transport_manager/include/transport_manager/cloud/websocket_client_connection.h
+++ b/src/components/transport_manager/include/transport_manager/cloud/websocket_client_connection.h
@@ -38,11 +38,13 @@
 
 #include <boost/beast/core.hpp>
 #include <boost/beast/websocket.hpp>
-#include <boost/beast/websocket/ssl.hpp>
 #include <boost/asio/connect.hpp>
 #include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/ssl/stream.hpp>
 #include <boost/asio/thread_pool.hpp>
+#ifdef ENABLE_SECURITY
+#include <boost/asio/ssl/stream.hpp>
+#include <boost/beast/websocket/ssl.hpp>
+#endif  // ENABLE_SECURITY
 #include <cstdlib>
 #include <functional>
 #include <iostream>
@@ -55,16 +57,21 @@
 #include "utils/threads/message_loop_thread.h"
 #include "utils/message_queue.h"
 
-using tcp = boost::asio::ip::tcp;  // from <boost/asio/ip/tcp.hpp>
-namespace ssl = boost::asio::ssl;  // from <boost/asio/ssl.hpp>
 namespace websocket =
     boost::beast::websocket;  // from <boost/beast/websocket.hpp>
+
+using tcp = boost::asio::ip::tcp;  // from <boost/asio/ip/tcp.hpp>
+typedef websocket::stream<tcp::socket> WS;
+
+#ifdef ENABLE_SECURITY
+namespace ssl = boost::asio::ssl;  // from <boost/asio/ssl.hpp>
+typedef websocket::stream<ssl::stream<tcp::socket> > WSS;
+#endif  // ENABLE_SECURITY
+
 using ::utils::MessageQueue;
 
 typedef std::queue<protocol_handler::RawMessagePtr> AsyncQueue;
 typedef protocol_handler::RawMessagePtr Message;
-typedef websocket::stream<tcp::socket> WS;
-typedef websocket::stream<ssl::stream<tcp::socket> > WSS;
 
 namespace transport_manager {
 namespace transport_adapter {
@@ -106,12 +113,12 @@ class WebsocketClientConnection
   TransportAdapter::Error Start();
 
   /**
- * @brief Send data frame.
- *
- * @param message Smart pointer to the raw message.
- *
- * @return Error Information about possible reason of sending data failure.
- */
+   * @brief Send data frame.
+   *
+   * @param message Smart pointer to the raw message.
+   *
+   * @return Error Information about possible reason of sending data failure.
+   */
   TransportAdapter::Error SendData(::protocol_handler::RawMessagePtr message);
 
   /**
@@ -121,12 +128,14 @@ class WebsocketClientConnection
    */
   TransportAdapter::Error Disconnect();
 
+#ifdef ENABLE_SECURITY
   /**
    * @brief Attempt to add provided certificate to the ssl::context
    *
    * @param cert Certificate string from policy table
    */
   void AddCertificateAuthority(std::string cert, boost::system::error_code& ec);
+#endif  // ENABLE_SECURITY
 
   void Shutdown();
 
@@ -137,13 +146,15 @@ class WebsocketClientConnection
  private:
   TransportAdapterController* controller_;
   boost::asio::io_context ioc_;
-  ssl::context ctx_;
   tcp::resolver resolver_;
   boost::beast::flat_buffer buffer_;
   std::string host_;
   std::string text_;
   WS ws_;
+#ifdef ENABLE_SECURITY
+  ssl::context ctx_;
   WSS wss_;
+#endif  // ENABLE_SECURITY
 
   std::atomic_bool shutdown_;
 
diff --git a/src/components/transport_manager/src/cloud/websocket_client_connection.cc b/src/components/transport_manager/src/cloud/websocket_client_connection.cc
index 057e3d7208..bb654822c3 100644
--- a/src/components/transport_manager/src/cloud/websocket_client_connection.cc
+++ b/src/components/transport_manager/src/cloud/websocket_client_connection.cc
@@ -47,22 +47,26 @@ WebsocketClientConnection::WebsocketClientConnection(
     const ApplicationHandle& app_handle,
     TransportAdapterController* controller)
     : controller_(controller)
-    , ctx_(ssl::context::sslv23_client)
     , resolver_(ioc_)
     , ws_(ioc_)
+#ifdef ENABLE_SECURITY
+    , ctx_(ssl::context::sslv23_client)
     , wss_(ioc_, ctx_)
+#endif  // ENABLE_SECURITY
     , shutdown_(false)
     , thread_delegate_(new LoopThreadDelegate(&message_queue_, this))
     , write_thread_(threads::CreateThread("WS Async Send", thread_delegate_))
     , device_uid_(device_uid)
     , app_handle_(app_handle)
-    , io_pool_(1) {}
+    , io_pool_(1) {
+}
 
 WebsocketClientConnection::~WebsocketClientConnection() {
   ioc_.stop();
   io_pool_.join();
 }
 
+#ifdef ENABLE_SECURITY
 void WebsocketClientConnection::AddCertificateAuthority(
     const std::string cert, boost::system::error_code& ec) {
   ctx_.add_certificate_authority(boost::asio::buffer(cert.data(), cert.size()),
@@ -73,6 +77,7 @@ void WebsocketClientConnection::AddCertificateAuthority(
 
   wss_.next_layer().set_verify_mode(ssl::verify_peer);
 }
+#endif  // ENABLE_SECURITY
 
 TransportAdapter::Error WebsocketClientConnection::Start() {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -106,12 +111,16 @@ TransportAdapter::Error WebsocketClientConnection::Start() {
   }
 
   // Make Connection to host IP Address over TCP
-  if (cloud_properties.cloud_transport_type == "WSS") {
+  if (cloud_properties.cloud_transport_type == "WS") {
+    boost::asio::connect(ws_.next_layer(), results.begin(), results.end(), ec);
+  }
+#ifdef ENABLE_SECURITY
+  else if (cloud_properties.cloud_transport_type == "WSS") {
     boost::asio::connect(
         wss_.next_layer().next_layer(), results.begin(), results.end(), ec);
-  } else {
-    boost::asio::connect(ws_.next_layer(), results.begin(), results.end(), ec);
   }
+#endif  // ENABLE_SECURITY
+
   if (ec) {
     std::string str_err = "ErrorMessage: " + ec.message();
     LOG4CXX_ERROR(logger_,
@@ -120,6 +129,7 @@ TransportAdapter::Error WebsocketClientConnection::Start() {
     return TransportAdapter::FAIL;
   }
 
+#ifdef ENABLE_SECURITY
   if (cloud_properties.cloud_transport_type == "WSS") {
     AddCertificateAuthority(cloud_properties.certificate, ec);
 
@@ -146,13 +156,17 @@ TransportAdapter::Error WebsocketClientConnection::Start() {
       return TransportAdapter::FAIL;
     }
   }
+#endif  // ENABLE_SECURITY
 
   // Perform websocket handshake
-  if (cloud_properties.cloud_transport_type == "WSS") {
-    wss_.handshake(host, "/", ec);
-  } else {
+  if (cloud_properties.cloud_transport_type == "WS") {
     ws_.handshake(host, "/", ec);
   }
+#ifdef ENABLE_SECURITY
+  else if (cloud_properties.cloud_transport_type == "WSS") {
+    wss_.handshake(host, "/", ec);
+  }
+#endif  // ENABLE_SECURITY
   if (ec) {
     std::string str_err = "ErrorMessage: " + ec.message();
     LOG4CXX_ERROR(logger_,
@@ -163,28 +177,34 @@ TransportAdapter::Error WebsocketClientConnection::Start() {
   }
 
   // Set the binary message write option
-  if (cloud_properties.cloud_transport_type == "WSS") {
-    wss_.binary(true);
-  } else {
+  if (cloud_properties.cloud_transport_type == "WS") {
     ws_.binary(true);
   }
+#ifdef ENABLE_SECURITY
+  else if (cloud_properties.cloud_transport_type == "WSS") {
+    wss_.binary(true);
+  }
+#endif  // ENABLE_SECURITY
   write_thread_->start(threads::ThreadOptions());
   controller_->ConnectDone(device_uid_, app_handle_);
 
   // Start async read
-  if (cloud_properties.cloud_transport_type == "WSS") {
-    wss_.async_read(buffer_,
-                    std::bind(&WebsocketClientConnection::OnRead,
-                              this,
-                              std::placeholders::_1,
-                              std::placeholders::_2));
-  } else {
+  if (cloud_properties.cloud_transport_type == "WS") {
     ws_.async_read(buffer_,
                    std::bind(&WebsocketClientConnection::OnRead,
                              this,
                              std::placeholders::_1,
                              std::placeholders::_2));
   }
+#ifdef ENABLE_SECURITY
+  else if (cloud_properties.cloud_transport_type == "WSS") {
+    wss_.async_read(buffer_,
+                    std::bind(&WebsocketClientConnection::OnRead,
+                              this,
+                              std::placeholders::_1,
+                              std::placeholders::_2));
+  }
+#endif  // ENABLE_SECURITY
 
   boost::asio::post(io_pool_, [&]() { ioc_.run(); });
 
@@ -205,19 +225,22 @@ void WebsocketClientConnection::Recv(boost::system::error_code ec) {
     Shutdown();
     return;
   }
-  if (cloud_properties.cloud_transport_type == "WSS") {
-    wss_.async_read(buffer_,
-                    std::bind(&WebsocketClientConnection::OnRead,
-                              this,
-                              std::placeholders::_1,
-                              std::placeholders::_2));
-  } else {
+  if (cloud_properties.cloud_transport_type == "WS") {
     ws_.async_read(buffer_,
                    std::bind(&WebsocketClientConnection::OnRead,
                              this,
                              std::placeholders::_1,
                              std::placeholders::_2));
   }
+#ifdef ENABLE_SECURITY
+  else if (cloud_properties.cloud_transport_type == "WSS") {
+    wss_.async_read(buffer_,
+                    std::bind(&WebsocketClientConnection::OnRead,
+                              this,
+                              std::placeholders::_1,
+                              std::placeholders::_2));
+  }
+#endif  // ENABLE_SECURITY
 }
 
 void WebsocketClientConnection::OnRead(boost::system::error_code ec,
@@ -303,13 +326,16 @@ void WebsocketClientConnection::LoopThreadDelegate::DrainQueue() {
     message_queue_.pop(message_ptr);
     if (!shutdown_) {
       boost::system::error_code ec;
-      if (handler_.cloud_properties.cloud_transport_type == "WSS") {
-        handler_.wss_.write(
-            boost::asio::buffer(message_ptr->data(), message_ptr->data_size()));
-      } else {
+      if (handler_.cloud_properties.cloud_transport_type == "WS") {
         handler_.ws_.write(
             boost::asio::buffer(message_ptr->data(), message_ptr->data_size()));
       }
+#ifdef ENABLE_SECURITY
+      else if (handler_.cloud_properties.cloud_transport_type == "WSS") {
+        handler_.wss_.write(
+            boost::asio::buffer(message_ptr->data(), message_ptr->data_size()));
+      }
+#endif  // ENABLE_SECURITY
       if (ec) {
         LOG4CXX_ERROR(logger_, "Error writing to websocket");
         handler_.controller_->DataSendFailed(handler_.device_uid_,
diff --git a/src/components/transport_manager/src/transport_manager_impl.cc b/src/components/transport_manager/src/transport_manager_impl.cc
index d197882120..2b23fd73b2 100644
--- a/src/components/transport_manager/src/transport_manager_impl.cc
+++ b/src/components/transport_manager/src/transport_manager_impl.cc
@@ -134,10 +134,15 @@ void TransportManagerImpl::AddCloudDevice(
     const transport_manager::transport_adapter::CloudAppProperties
         cloud_properties) {
   transport_adapter::DeviceType type = transport_adapter::DeviceType::UNKNOWN;
-  if ((cloud_properties.cloud_transport_type == "WS") ||
-      (cloud_properties.cloud_transport_type == "WSS")) {
+  if (cloud_properties.cloud_transport_type == "WS") {
     type = transport_adapter::DeviceType::CLOUD_WEBSOCKET;
-  } else {
+  }
+#ifdef ENABLE_SECURITY
+  else if (cloud_properties.cloud_transport_type == "WSS") {
+    type = transport_adapter::DeviceType::CLOUD_WEBSOCKET;
+  }
+#endif  // ENABLE_SECURITY
+  else {
     return;
   }