TelnetServer Class Reference

#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 (const std::stop_token &stopToken) 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::shared_ptr< std::atomic_flag >	m_checkFlag
std::unique_ptr< std::jthread >	m_serverThread

Detailed Description

Definition at line 132 of file TelnetServer.hpp.

Constructor & Destructor Documentation

TelnetServer() [1/3]

TelnetServer::TelnetServer ( )

default

Constructor for server.

Here is the caller graph for this function:

TelnetServer() [2/3]

TelnetServer::TelnetServer ( const TelnetServer & )

delete

Copy constructor.

Here is the call graph for this function:

TelnetServer() [3/3]

TelnetServer::TelnetServer ( TelnetServer && )

delete

Move constructor.

Here is the call graph for this function:

~TelnetServer()

TelnetServer::~TelnetServer

(

)

Destructor for server.

Definition at line 546 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)
        {
            (void)std::fprintf(stderr, "Telnet server destructor and also logger thrown an exception: %s %s\n",
                               e.what(), e2.what());
        }
    }
}

Here is the call graph for this function:

Member Function Documentation

acceptConnection()

bool TelnetServer::acceptConnection ( )

private

Definition at line 636 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 169 of file TelnetServer.hpp.

{ return m_connectedCallback; }

connectedCallback() [2/2]

void TelnetServer::connectedCallback ( FPTR_ConnectedCallback func )

inline

Definition at line 168 of file TelnetServer.hpp.

{ 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 566 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_serverThread = std::make_unique<std::jthread>([this](const std::stop_token &sToken) { threadFunc(sToken); });
 
    m_initialised = true;
    return true;
}

Here is the call graph for this function:

interactivePrompt()

bool TelnetServer::interactivePrompt ( ) const

inline

Definition at line 179 of file TelnetServer.hpp.

{ return !m_promptString.empty(); }

newLineCallBack()

FPTR_NewLineCallback TelnetServer::newLineCallBack ( ) const

inline

Definition at line 172 of file TelnetServer.hpp.

{ return m_newlineCallback; }

newLineCallback()

void TelnetServer::newLineCallback ( FPTR_NewLineCallback func )

inline

Definition at line 171 of file TelnetServer.hpp.

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

operator=() [1/2]

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

delete

Move assignment operator.

Here is the call graph for this function:

operator=() [2/2]

TelnetServer & TelnetServer::operator= ( TelnetServer )

delete

Copy assignment operator.

Here is the call graph for this function:

promptString() [1/2]

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

inline

Definition at line 181 of file TelnetServer.hpp.

{ return m_promptString; }

promptString() [2/2]

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

inline

Definition at line 180 of file TelnetServer.hpp.

{ m_promptString = prompt; }

Here is the caller graph for this function:

sessions()

const VEC_SP_TelnetSession & TelnetServer::sessions ( ) const

inline

Definition at line 177 of file TelnetServer.hpp.

{ return m_sessions; }

shutdown()

void TelnetServer::shutdown

(

)

Closes the Telnet Server.

Definition at line 747 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;
 
    if (m_serverThread)
    {
        m_serverThread.reset();
    }
}

Here is the caller graph for this function:

tabCallback() [1/2]

FPTR_TabCallback TelnetServer::tabCallback ( ) const

inline

Definition at line 175 of file TelnetServer.hpp.

{ return m_tabCallback; }

tabCallback() [2/2]

void TelnetServer::tabCallback ( FPTR_TabCallback func )

inline

Definition at line 174 of file TelnetServer.hpp.

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

threadFunc()

void TelnetServer::threadFunc ( const std::stop_token & stopToken )

privatenoexcept

Definition at line 660 of file TelnetServer.cpp.

{
    spdlog::info("Telnet server started");
    while (!stopToken.stop_requested())
    {
        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 682 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 185 of file TelnetServer.hpp.

m_initialised

bool TelnetServer::m_initialised {false}

private

Definition at line 200 of file TelnetServer.hpp.

{false};

m_listenPort

unsigned long TelnetServer::m_listenPort {}

private

Definition at line 197 of file TelnetServer.hpp.

{};

m_listenSocket

Socket TelnetServer::m_listenSocket {-1}

private

Definition at line 198 of file TelnetServer.hpp.

{-1};

m_newlineCallback

FPTR_NewLineCallback TelnetServer::m_newlineCallback

private

Definition at line 187 of file TelnetServer.hpp.

m_promptString

std::string TelnetServer::m_promptString

private

Definition at line 202 of file TelnetServer.hpp.

m_serverThread

std::unique_ptr<std::jthread> TelnetServer::m_serverThread

private

Thread handler

Definition at line 208 of file TelnetServer.hpp.

m_sessions

VEC_SP_TelnetSession TelnetServer::m_sessions

private

Definition at line 199 of file TelnetServer.hpp.

m_stats

std::unique_ptr<TelnetStats> TelnetServer::m_stats

private

Definition at line 205 of file TelnetServer.hpp.

m_tabCallback

FPTR_TabCallback TelnetServer::m_tabCallback

private

Definition at line 189 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