tls_acceptor.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/.
 */
 
// includes
#include "boost-support/server/tls/tls_acceptor.h"
 
#include <boost/asio.hpp>
 
#include "boost-support/common/logger.h"
#include "boost-support/server/tls/tls_version.h"
#include "boost-support/socket/tls/tls_context.h"
#include "boost-support/socket/tls/tls_socket.h"
 
namespace boost_support {
namespace server {
namespace tls {
namespace {
using Tcp = boost::asio::ip::tcp;
 
using TcpIpAddress = boost::asio::ip::address;
 
std::string CreateServerName(std::string_view server_name, std::uint16_t server_count) {
  std::string final_server_name{server_name};
  final_server_name.append(std::to_string(server_count));
  return final_server_name;
}
}  // namespace
 
template<typename TlsVersion>
class TlsAcceptor<TlsVersion>::TlsAcceptorImpl final {
 public:
  using TlsSocket = socket::tls::TlsSocket;
 
  using TlsContext = socket::tls::TlsContext;
 
 public:
  TlsAcceptorImpl(std::string_view acceptor_name, std::string_view local_ip_address,
                  std::uint16_t local_port_num, std::uint8_t maximum_connection,
                  TlsVersion tls_version, std::string_view certificate_path,
                  std::string_view private_key_path) noexcept
      : io_context_{},
        tls_context_{std::forward<TlsVersion>(tls_version), certificate_path, private_key_path},
        server_count_{0u},
        acceptor_name_{acceptor_name},
        acceptor_{io_context_,
                  Tcp::endpoint(TcpIpAddress::from_string(std::string{local_ip_address}.c_str()),
                                local_port_num)} {
    acceptor_.listen(maximum_connection);
  }
 
  std::optional<TlsServer> GetTlsServer() noexcept {
    using TcpErrorCodeType = boost::system::error_code;
    std::optional<TlsServer> tls_server{};
    TcpErrorCodeType ec{};
    Tcp::endpoint endpoint{};
 
    // blocking accept
    TlsSocket::TcpSocket accepted_socket{acceptor_.accept(endpoint, ec)};
    if (ec.value() == boost::system::errc::success) {
      tls_server.emplace(CreateServerName(acceptor_name_, server_count_),
                         TlsSocket{std::move(accepted_socket), tls_context_});
      common::logger::LibBoostLogger::GetLibBoostLogger().GetLogger().LogDebug(
          FILE_NAME, __LINE__, __func__, [&endpoint](std::stringstream &msg) {
            msg << "Tls socket connection received from client "
                << "<" << endpoint.address().to_string() << "," << endpoint.port() << ">";
          });
      // increment the server count
      server_count_++;
    } else {
      common::logger::LibBoostLogger::GetLibBoostLogger().GetLogger().LogError(
          FILE_NAME, __LINE__, __func__, [ec](std::stringstream &msg) {
            msg << "Tcp socket accept failed with error: " << ec.message();
          });
    }
    return tls_server;
  }
 
 private:
  using Acceptor = boost::asio::ip::tcp::acceptor;
 
  boost::asio::io_context io_context_;
 
  TlsContext tls_context_;
 
  std::uint16_t server_count_;
 
  std::string acceptor_name_;
 
  Acceptor acceptor_;
};
 
template<typename TlsVersion>
TlsAcceptor<TlsVersion>::TlsAcceptor(std::string_view acceptor_name,
                                     std::string_view local_ip_address,
                                     std::uint16_t local_port_num, std::uint8_t maximum_connection,
                                     TlsVersion tls_version, std::string_view certificate_path,
                                     std::string_view private_key_path) noexcept
    : tls_acceptor_impl_{std::make_unique<TlsAcceptorImpl>(
          acceptor_name, local_ip_address, local_port_num, maximum_connection,
          std::move(tls_version), certificate_path, private_key_path)} {}
 
template<typename TlsVersion>
TlsAcceptor<TlsVersion>::~TlsAcceptor() noexcept = default;
 
template<typename TlsVersion>
std::optional<TlsServer> TlsAcceptor<TlsVersion>::GetTlsServer() noexcept {
  return tls_acceptor_impl_->GetTlsServer();
}
 
template class TlsAcceptor<TlsVersion13>;
template class TlsAcceptor<TlsVersion12>;
 
}  // namespace tls
}  // namespace server
}  // namespace boost_support