tls_client.cpp

Go to the documentation of this file.

/* Diagnostic Client library
 * Copyright (C) 2024  Avijit Dey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#include "boost-support/client/tls/tls_client.h"
 
#include "boost-support/common/logger.h"
#include "boost-support/connection/tcp/tcp_connection.h"
#include "boost-support/error_domain/boost_support_error_domain.h"
#include "boost-support/socket/io_context.h"
#include "boost-support/socket/tls/tls_context.h"
#include "boost-support/socket/tls/tls_socket.h"
 
namespace boost_support {
namespace client {
namespace tls {
namespace {
std::string AppendIpAddressAndPort(std::string_view client_name, std::string_view ip_address,
                                   std::uint16_t port_num) {
  std::string connection_name{client_name};
  connection_name.append("_");
  connection_name.append(ip_address);
  connection_name.append("_");
  connection_name.append(std::to_string(port_num));
  return connection_name;
}
}  // namespace
 
template<typename TlsVersion>
class TlsClient<TlsVersion>::TlsClientImpl final {
 private:
  using TlsSocket = socket::tls::TlsSocket;
 
  using TcpConnectionSecured =
      connection::tcp::TcpConnection<connection::tcp::ConnectionType::kClient, TlsSocket>;
 
  enum class State : std::uint8_t {
    kConnected = 0U,   
    kDisconnected = 1U 
  };
 
  using IoContext = boost_support::socket::IoContext;
 
  using TlsContext = boost_support::socket::tls::TlsContext;
 
 public:
  TlsClientImpl(std::string_view client_name, std::string_view local_ip_address,
                std::uint16_t local_port_num, std::string_view ca_certification_path,
                TlsVersion tls_version) noexcept
      : io_context_{},
        tls_context_{tls_version, ca_certification_path},
        connection_state_{State::kDisconnected},
        client_name_{AppendIpAddressAndPort(client_name, local_ip_address, local_port_num)},
        tcp_connection_{client_name,
                        TlsSocket{local_ip_address, local_port_num, tls_context_, io_context_}} {}
 
  TlsClientImpl(const TlsClientImpl &other) noexcept = delete;
  TlsClientImpl &operator=(const TlsClientImpl &other) noexcept = delete;
 
  TlsClientImpl(TlsClientImpl &&other) noexcept = delete;
  TlsClientImpl &operator=(TlsClientImpl &&other) noexcept = delete;
 
  ~TlsClientImpl() noexcept = default;
 
  void Initialize() noexcept { tcp_connection_.Initialize(); }
 
  void DeInitialize() noexcept { tcp_connection_.DeInitialize(); }
 
  void SetReadHandler(HandlerRead read_handler) noexcept {
    tcp_connection_.SetReadHandler(std::move(read_handler));
  }
 
  core_type::Result<void> ConnectToHost(std::string_view host_ip_address,
                                        std::uint16_t host_port_num) {
    core_type::Result<void> result{
        error_domain::MakeErrorCode(error_domain::BoostSupportErrorErrc::kSocketError)};
    if (connection_state_.load(std::memory_order_seq_cst) != State::kConnected) {
      if (tcp_connection_.ConnectToHost(host_ip_address, host_port_num)) {
        connection_state_.store(State::kConnected, std::memory_order_seq_cst);
        result.EmplaceValue();
      }  // else, connect failed
    } else {
      // already connected
      result.EmplaceValue();
      common::logger::LibBoostLogger::GetLibBoostLogger().GetLogger().LogVerbose(
          FILE_NAME, __LINE__, __func__,
          [](std::stringstream &msg) { msg << "Tcp client is already connected"; });
    }
    return result;
  }
 
  core_type::Result<void> DisconnectFromHost() {
    core_type::Result<void> result{
        error_domain::MakeErrorCode(error_domain::BoostSupportErrorErrc::kSocketError)};
    if (connection_state_.load(std::memory_order_seq_cst) == State::kConnected) {
      tcp_connection_.DisconnectFromHost();
      connection_state_.store(State::kDisconnected, std::memory_order_seq_cst);
      result.EmplaceValue();
    } else {
      // Not connected
      common::logger::LibBoostLogger::GetLibBoostLogger().GetLogger().LogDebug(
          FILE_NAME, __LINE__, __func__,
          [](std::stringstream &msg) { msg << "Tcp client is in disconnected state"; });
    }
    return result;
  }
 
  auto IsConnectedToHost() const noexcept -> bool {
    return (connection_state_.load(std::memory_order_seq_cst) == State::kConnected);
  }
 
  core_type::Result<void> Transmit(MessageConstPtr tcp_message) {
    core_type::Result<void> result{
        error_domain::MakeErrorCode(error_domain::BoostSupportErrorErrc::kGenericError)};
    if (connection_state_.load(std::memory_order_seq_cst) == State::kConnected) {
      if (tcp_connection_.Transmit(std::move(tcp_message))) { result.EmplaceValue(); }
    } else {
      // not connected
      common::logger::LibBoostLogger::GetLibBoostLogger().GetLogger().LogError(
          FILE_NAME, __LINE__, __func__, [](std::stringstream &msg) {
            msg << "Tcp client is Offline, please connect to server first";
          });
    }
    return result;
  }
 
 private:
  IoContext io_context_;
 
  TlsContext tls_context_;
 
  std::atomic<State> connection_state_;
 
  std::string client_name_;
 
  TcpConnectionSecured tcp_connection_;
};
 
template<typename TlsVersion>
TlsClient<TlsVersion>::TlsClient(std::string_view client_name, std::string_view local_ip_address,
                                 std::uint16_t local_port_num,
                                 std::string_view ca_certification_path,
                                 TlsVersion tls_version) noexcept
    : tls_client_impl_{std::make_unique<TlsClientImpl>(client_name, local_ip_address,
                                                       local_port_num, ca_certification_path,
                                                       std::move(tls_version))} {}
 
template<typename TlsVersion>
TlsClient<TlsVersion>::TlsClient(TlsClient &&other) noexcept = default;
 
template<typename TlsVersion>
TlsClient<TlsVersion> &TlsClient<TlsVersion>::operator=(TlsClient &&other) noexcept = default;
 
template<typename TlsVersion>
TlsClient<TlsVersion>::~TlsClient() noexcept = default;
 
template<typename TlsVersion>
void TlsClient<TlsVersion>::Initialize() noexcept {
  tls_client_impl_->Initialize();
}
 
template<typename TlsVersion>
void TlsClient<TlsVersion>::DeInitialize() noexcept {
  tls_client_impl_->DeInitialize();
}
 
template<typename TlsVersion>
void TlsClient<TlsVersion>::SetReadHandler(TlsClient::HandlerRead read_handler) noexcept {
  tls_client_impl_->SetReadHandler(std::move(read_handler));
}
 
template<typename TlsVersion>
core_type::Result<void> TlsClient<TlsVersion>::ConnectToHost(std::string_view host_ip_address,
                                                             std::uint16_t host_port_num) {
  return tls_client_impl_->ConnectToHost(host_ip_address, host_port_num);
}
 
template<typename TlsVersion>
core_type::Result<void> TlsClient<TlsVersion>::DisconnectFromHost() {
  return tls_client_impl_->DisconnectFromHost();
}
 
template<typename TlsVersion>
auto TlsClient<TlsVersion>::IsConnectedToHost() const noexcept -> bool {
  return tls_client_impl_->IsConnectedToHost();
}
 
template<typename TlsVersion>
core_type::Result<void> TlsClient<TlsVersion>::Transmit(MessageConstPtr tcp_message) {
  return tls_client_impl_->Transmit(std::move(tcp_message));
}
 
template class TlsClient<TlsVersion13>;
template class TlsClient<TlsVersion12>;
 
}  // namespace tls
}  // namespace client
}  // namespace boost_support