#include <TelnetServer.hpp>

Inheritance diagram for TelnetServer:

Collaboration diagram for TelnetServer:

Public Member Functions
	TelnetServer ()=default
	Constructor for server.

	TelnetServer (const TelnetServer &)=delete
	Copy constructor.

	TelnetServer (TelnetServer &&)=delete
	Move constructor.

TelnetServer &	operator= (TelnetServer)=delete
	Copy assignment operator.

TelnetServer &	operator= (TelnetServer &&)=delete
	Move assignment operator.

	~TelnetServer ()
	Destructor for server.

bool	initialise (unsigned long listenPort, const std::shared_ptr< std::atomic_flag > &checkFlag, std::string promptString="", const std::shared_ptr< prometheus::Registry > &reg=nullptr, const std::string &prependName="")

void	shutdown ()
	Closes the Telnet Server.

void	connectedCallback (FPTR_ConnectedCallback func)

FPTR_ConnectedCallback	connectedCallback () const

void	newLineCallback (FPTR_NewLineCallback func)

FPTR_NewLineCallback	newLineCallBack () const

void	tabCallback (FPTR_TabCallback func)

FPTR_TabCallback	tabCallback () const

const VEC_SP_TelnetSession &	sessions () const

bool	interactivePrompt () const

void	promptString (const std::string_view &prompt)

const std::string &	promptString () const

Private Member Functions
bool	acceptConnection ()

void	threadFunc () noexcept

void	update ()
	Process new connections and messages.

Private Attributes
FPTR_ConnectedCallback	m_connectedCallback

FPTR_NewLineCallback	m_newlineCallback

FPTR_TabCallback	m_tabCallback

unsigned long	m_listenPort {}

Socket	m_listenSocket {-1}

VEC_SP_TelnetSession	m_sessions

bool	m_initialised {false}

std::string	m_promptString

std::unique_ptr< TelnetStats >	m_stats

std::atomic_flag	m_shouldStop {false}

std::unique_ptr< std::thread >	m_serverThread

std::shared_ptr< std::atomic_flag >	m_checkFlag

Detailed Description

Definition at line 130 of file TelnetServer.hpp.

Constructor & Destructor Documentation

◆ TelnetServer() [1/3]

TelnetServer::TelnetServer ( )

default

Constructor for server.

◆ TelnetServer() [2/3]

TelnetServer::TelnetServer ( const TelnetServer & )

delete

Copy constructor.

◆ TelnetServer() [3/3]

TelnetServer::TelnetServer ( TelnetServer && )

delete

Move constructor.

◆ ~TelnetServer()

TelnetServer::~TelnetServer ( )

Destructor for server.

Definition at line 531 of file TelnetServer.cpp.

{
    try
    {
        shutdown();
    }
    catch (const std::exception &e)
    {
        try
        {
            spdlog::error("Telnet server destructor thrown an exception: {}", e.what());
        }
        catch (const std::exception &e2)
        {
            std::cerr << "Telnet server destructor and also logger thrown an exception: " << e.what() << '\n'
                      << e2.what() << '\n';
        }
    }
}

Here is the call graph for this function:

Member Function Documentation

◆ acceptConnection()

bool TelnetServer::acceptConnection ( )

private

Definition at line 622 of file TelnetServer.cpp.

{
    const Socket ClientSocket = accept(m_listenSocket, nullptr, nullptr);
    if (ClientSocket == INVALID_SOCKET)
    {
        return false;
    }
    if (m_sessions.size() >= MAX_AVAILABLE_SESSION)
    {
        // Create for only sending error
        const auto session = std::make_shared<TelnetSession>(ClientSocket, shared_from_this());
        session->initialise();
 
        session->sendLine("Too many active connections. Please try again later. \r\nClosing...");
        session->closeClient();
        return false;
    }
 
    const auto session = std::make_shared<TelnetSession>(ClientSocket, shared_from_this());
    m_sessions.push_back(session);
    session->initialise();
    return true;
}

Here is the caller graph for this function:

◆ connectedCallback() [1/2]

FPTR_ConnectedCallback TelnetServer::connectedCallback ( ) const

inline

Definition at line 167 of file TelnetServer.hpp.

167{ return m_connectedCallback; }

TelnetServer::m_connectedCallback

FPTR_ConnectedCallback m_connectedCallback

Definition TelnetServer.hpp:183

◆ connectedCallback() [2/2]

void TelnetServer::connectedCallback ( FPTR_ConnectedCallback func )

inline

Definition at line 166 of file TelnetServer.hpp.

166{ m_connectedCallback = std::move(func); }

◆ initialise()

bool TelnetServer::initialise	(	unsigned long	listenPort,
		const std::shared_ptr< std::atomic_flag > &	checkFlag,
		std::string	promptString = "",
		const std::shared_ptr< prometheus::Registry > &	reg = nullptr,
		const std::string &	prependName = "" )

Initializes a new Telnet server

Parameters

[in]	listenPort	Port to listen
[in]	promptString	Prompt string for connected users
[in]	reg	Prometheus registry for stats
[in]	prependName	Prefix for Prometheus stats

Returns: true If initialized; false otherwise

Definition at line 551 of file TelnetServer.cpp.

{
    if (m_initialised)
    {
        return false;
    }
 
    m_checkFlag = checkFlag;
    m_listenPort = listenPort;
    m_promptString = std::move(promptString);
 
    addrinfo hints{};
    memset(&hints, 0, sizeof(hints));
 
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
    hints.ai_flags = AI_PASSIVE;
 
    // Resolve the server address and port
    addrinfo *result = nullptr;
    if (getaddrinfo(nullptr, std::to_string(m_listenPort).c_str(), &hints, &result) != 0)
    {
        return false;
    }
 
    // Create a SOCKET for connecting to server
    m_listenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
    if (m_listenSocket == INVALID_SOCKET)
    {
        freeaddrinfo(result);
        return false;
    }
 
    if (int optionVal = 1; setsockopt(m_listenSocket, SOL_SOCKET, SO_REUSEADDR, &optionVal, sizeof(optionVal)) < 0)
    {
        freeaddrinfo(result);
        close(m_listenSocket);
        return false;
    }
 
    // Setup the TCP listening socket
    if (bind(m_listenSocket, result->ai_addr, result->ai_addrlen) < 0)
    {
        freeaddrinfo(result);
        close(m_listenSocket);
        return false;
    }
    freeaddrinfo(result);
 
    if (listen(m_listenSocket, SOMAXCONN) < 0)
    {
        close(m_listenSocket);
        return false;
    }
 
    // If prometheus registry is provided prepare statistics
    if (reg)
    {
        m_stats = std::make_unique<TelnetStats>(reg, listenPort, prependName);
    }
 
    m_shouldStop.clear();
    m_serverThread = std::make_unique<std::thread>(&TelnetServer::threadFunc, this);
 
    m_initialised = true;
    return true;
}

Here is the call graph for this function:

◆ interactivePrompt()

bool TelnetServer::interactivePrompt ( ) const

inline

Definition at line 177 of file TelnetServer.hpp.

177{ return !m_promptString.empty(); }

◆ newLineCallBack()

FPTR_NewLineCallback TelnetServer::newLineCallBack ( ) const

inline

Definition at line 170 of file TelnetServer.hpp.

170{ return m_newlineCallback; }

TelnetServer::m_newlineCallback

FPTR_NewLineCallback m_newlineCallback

Definition TelnetServer.hpp:185

◆ newLineCallback()

void TelnetServer::newLineCallback ( FPTR_NewLineCallback func )

inline

Definition at line 169 of file TelnetServer.hpp.

169{ m_newlineCallback = std::move(func); }

◆ operator=() [1/2]

TelnetServer & TelnetServer::operator= ( TelnetServer && )

delete

Move assignment operator.

◆ operator=() [2/2]

TelnetServer & TelnetServer::operator= ( TelnetServer )

delete

Copy assignment operator.

◆ promptString() [1/2]

const std::string & TelnetServer::promptString ( ) const

inline

Definition at line 179 of file TelnetServer.hpp.

179{ return m_promptString; }

Here is the caller graph for this function:

◆ promptString() [2/2]

void TelnetServer::promptString ( const std::string_view & prompt )

inline

Definition at line 178 of file TelnetServer.hpp.

178{ m_promptString = prompt; }

◆ sessions()

const VEC_SP_TelnetSession & TelnetServer::sessions ( ) const

inline

Definition at line 175 of file TelnetServer.hpp.

175{ return m_sessions; }

◆ shutdown()

void TelnetServer::shutdown ( )

Closes the Telnet Server.

Definition at line 733 of file TelnetServer.cpp.

{
    // Attempt to cleanly close every telnet session in flight.
    for (const SP_TelnetSession &tSession : m_sessions)
    {
        tSession->closeClient();
    }
    m_sessions.clear();
 
    // No longer need server socket so close it.
    close(m_listenSocket);
    m_listenSocket = INVALID_SOCKET;
    m_initialised = false;
 
    m_shouldStop.test_and_set();
    if (m_serverThread && m_serverThread->joinable())
    {
        m_serverThread->join();
        m_serverThread.reset();
    }
}

Here is the caller graph for this function:

◆ tabCallback() [1/2]

FPTR_TabCallback TelnetServer::tabCallback ( ) const

inline

Definition at line 173 of file TelnetServer.hpp.

173{ return m_tabCallback; }

TelnetServer::m_tabCallback

FPTR_TabCallback m_tabCallback

Definition TelnetServer.hpp:187

◆ tabCallback() [2/2]

void TelnetServer::tabCallback ( FPTR_TabCallback func )

inline

Definition at line 172 of file TelnetServer.hpp.

172{ m_tabCallback = std::move(func); }

◆ threadFunc()

void TelnetServer::threadFunc ( )

privatenoexcept

Definition at line 646 of file TelnetServer.cpp.

{
    spdlog::info("Telnet server started");
    while (!m_shouldStop._M_i)
    {
        try
        {
            update();
            if (m_checkFlag)
            {
                m_checkFlag->test_and_set();
            }
        }
        catch (const std::exception &e)
        {
            spdlog::error("Telnet server failed: {}", e.what());
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_INTERVAL_MS));
    }
    spdlog::info("Telnet server stopped");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update()

void TelnetServer::update ( )

private

Process new connections and messages.

Definition at line 668 of file TelnetServer.cpp.

{
    // See if connection pending on the listening socket
    fd_set readSet;
    FD_ZERO(&readSet);
    FD_SET(m_listenSocket, &readSet);
    timeval timeout{};
    timeout.tv_sec = 0; // Zero timeout (poll)
    timeout.tv_usec = 0;
 
    bool newConnectionAccept = false;
    bool newConnectionRefused = false;
 
    TelnetServerStats serverStats;
    serverStats.processingTimeStart = std::chrono::high_resolution_clock::now();
 
    // If there is a connection pending, accept it.
    if (select(m_listenSocket + 1, &readSet, nullptr, nullptr, &timeout) > 0)
    {
        if (acceptConnection())
        {
            newConnectionAccept = true;
        }
        else
        {
            newConnectionRefused = true;
        }
    }
 
    // Update all the telnet Sessions that are currently in flight.
    for (size_t idx = 0; idx < m_sessions.size(); ++idx)
    {
        // Update session
        m_sessions[idx]->update();
 
        // Close session if needed
        if (m_sessions[idx]->checkTimeout())
        {
            m_sessions[idx]->closeClient();
            if (m_stats)
            {
                m_stats->consumeStats(m_sessions[idx]->stats, true);
            }
            m_sessions.erase(m_sessions.begin() + static_cast<int>(idx));
            --idx;
        }
        else
        {
            if (m_stats)
            {
                m_stats->consumeStats(m_sessions[idx]->stats, false);
            }
        }
    }
 
    serverStats.activeConnectionCtr = m_sessions.size();
    serverStats.acceptedConnectionCtr = static_cast<uint64_t>(newConnectionAccept);
    serverStats.refusedConnectionCtr = static_cast<uint64_t>(newConnectionRefused);
    serverStats.processingTimeEnd = std::chrono::high_resolution_clock::now();
    if (m_stats)
    {
        m_stats->consumeStats(serverStats);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_checkFlag

std::shared_ptr<std::atomic_flag> TelnetServer::m_checkFlag

private

Runtime check flag

Definition at line 207 of file TelnetServer.hpp.

◆ m_connectedCallback

FPTR_ConnectedCallback TelnetServer::m_connectedCallback

private

Definition at line 183 of file TelnetServer.hpp.

◆ m_initialised

bool TelnetServer::m_initialised {false}

private

Definition at line 198 of file TelnetServer.hpp.

198{false};

◆ m_listenPort

unsigned long TelnetServer::m_listenPort {}

private

Definition at line 195 of file TelnetServer.hpp.

195{};

◆ m_listenSocket

Socket TelnetServer::m_listenSocket {-1}

private

Definition at line 196 of file TelnetServer.hpp.

196{-1};

◆ m_newlineCallback

FPTR_NewLineCallback TelnetServer::m_newlineCallback

private

Definition at line 185 of file TelnetServer.hpp.

◆ m_promptString

std::string TelnetServer::m_promptString

private

Definition at line 200 of file TelnetServer.hpp.

◆ m_serverThread

std::unique_ptr<std::thread> TelnetServer::m_serverThread

private

Thread handler

Definition at line 206 of file TelnetServer.hpp.

◆ m_sessions

VEC_SP_TelnetSession TelnetServer::m_sessions

private

Definition at line 197 of file TelnetServer.hpp.

◆ m_shouldStop

std::atomic_flag TelnetServer::m_shouldStop {false}

private

Flag to stop monitoring.

Definition at line 205 of file TelnetServer.hpp.

205{false};

◆ m_stats

std::unique_ptr<TelnetStats> TelnetServer::m_stats

private

Definition at line 203 of file TelnetServer.hpp.

◆ m_tabCallback

FPTR_TabCallback TelnetServer::m_tabCallback

private

Definition at line 187 of file TelnetServer.hpp.

The documentation for this class was generated from the following files:

/__w/Repo-Init/Repo-Init/include/telnet/TelnetServer.hpp
/__w/Repo-Init/Repo-Init/src/telnet/TelnetServer.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TelnetServer() [1/3]

◆ TelnetServer() [2/3]

◆ TelnetServer() [3/3]

◆ ~TelnetServer()

Member Function Documentation

◆ acceptConnection()

◆ connectedCallback() [1/2]

◆ connectedCallback() [2/2]

◆ initialise()

◆ interactivePrompt()

◆ newLineCallBack()

◆ newLineCallback()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ promptString() [1/2]

◆ promptString() [2/2]

◆ sessions()

◆ shutdown()

◆ tabCallback() [1/2]

◆ tabCallback() [2/2]

◆ threadFunc()

◆ update()

Member Data Documentation

◆ m_checkFlag

◆ m_connectedCallback

◆ m_initialised

◆ m_listenPort

◆ m_listenSocket

◆ m_newlineCallback

◆ m_promptString

◆ m_serverThread

◆ m_sessions

◆ m_shouldStop

◆ m_stats

◆ m_tabCallback