TelnetSession Class Reference

#include <TelnetServer.hpp>

Inheritance diagram for TelnetSession:

Collaboration diagram for TelnetSession:

Public Member Functions
	TelnetSession (Socket ClientSocket, std::shared_ptr< TelnetServer > tServer)
	Constructor for session.
void	sendLine (std::string data)
	Send a line of data to the Telnet Server.
void	closeClient ()
	Finish the session.
bool	checkTimeout () const
	Checks the connection timeout.
void	markTimeout ()
	Marks timeout to close session.

Protected Member Functions
void	initialise ()
	Initialise session.
void	update ()
	Called every frame/loop by the Terminal Server.

Private Member Functions
std::string	getPeerIP () const
void	sendPromptAndBuffer ()
void	eraseLine ()
void	echoBack (const char *buffer, unsigned long length)
bool	processTab (std::string &buffer)
void	addToHistory (const std::string &line)
bool	processCommandHistory (std::string &buffer)

Static Private Member Functions
static void	stripNVT (std::string &buffer)
static void	stripEscapeCharacters (std::string &buffer)
static bool	processBackspace (std::string &buffer)
static std::vector< std::string >	getCompleteLines (std::string &buffer)

Private Attributes
TelnetSessionStats	stats
	Statistics variables.
std::chrono::system_clock::time_point	lastSeenTime
Socket	m_socket
std::shared_ptr< TelnetServer >	m_telnetServer
std::string	m_buffer
std::list< std::string >	m_history
std::list< std::string >::iterator	m_historyCursor
friend	TelnetServer

Detailed Description

Session class for manage connections

Definition at line 56 of file TelnetServer.hpp.

Constructor & Destructor Documentation

TelnetSession()

TelnetSession::TelnetSession ( Socket ClientSocket, std::shared_ptr< TelnetServer > tServer )

inline

Constructor for session.

Definition at line 59 of file TelnetServer.hpp.

        : m_socket(ClientSocket), m_telnetServer(std::move(tServer))
    {
        m_historyCursor = m_history.end();
    };

Member Function Documentation

addToHistory()

void TelnetSession::addToHistory ( const std::string & line )

private

Definition at line 362 of file TelnetServer.cpp.

{
    // Add it to the history
    if (line != (!m_history.empty() ? m_history.back() : "") && !line.empty())
    {
        m_history.push_back(line);
        if (m_history.size() > TELNET_HISTORY_LIMIT)
        {
            m_history.pop_front();
        }
    }
    m_historyCursor = m_history.end();
}

Here is the caller graph for this function:

checkTimeout()

bool TelnetSession::checkTimeout

(

)

const

Checks the connection timeout.

Definition at line 194 of file TelnetServer.cpp.

{
    return (llabs(std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - lastSeenTime)
                      .count()) > TELNET_TIMEOUT);
}

closeClient()

void TelnetSession::closeClient

(

)

Finish the session.

Definition at line 180 of file TelnetServer.cpp.

{
    spdlog::info("Telnet connection to {} closed", getPeerIP());
 
    // Attempt to cleanly shutdown the connection since we're done
    shutdown(m_socket, SHUT_WR);
 
    // Cleanup
    close(m_socket);
 
    // Set disconnect time
    stats.disconnectTime = std::chrono::high_resolution_clock::now();
}

Here is the call graph for this function:

echoBack()

void TelnetSession::echoBack ( const char * buffer, unsigned long length )

private

Definition at line 205 of file TelnetServer.cpp.

{
    // If you are an NVT command (i.e. first it of data is 255) then ignore the echo back
    if (static_cast<uint8_t>(*buffer) == ASCII_NBSP)
    {
        return;
    }
 
    const ssize_t sendBytes = send(m_socket, buffer, length, 0);
    if (sendBytes > 0)
    {
        stats.uploadBytes += static_cast<size_t>(sendBytes);
    }
}

Here is the caller graph for this function:

eraseLine()

void TelnetSession::eraseLine ( )

private

Definition at line 142 of file TelnetServer.cpp.

{
    // Send an erase line
    ssize_t sendBytes = send(m_socket, ANSI_ERASE_LINE.c_str(), ANSI_ERASE_LINE.length(), 0);
    if (sendBytes > 0)
    {
        stats.uploadBytes += static_cast<size_t>(sendBytes);
    }
 
    // Move the cursor to the beginning of the line
    const std::string moveBack = "\x1b[80D";
    sendBytes = send(m_socket, moveBack.c_str(), moveBack.length(), 0);
    if (sendBytes > 0)
    {
        stats.uploadBytes += static_cast<size_t>(sendBytes);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

getCompleteLines()

std::vector< std::string > TelnetSession::getCompleteLines ( std::string & buffer )

staticprivate

Definition at line 426 of file TelnetServer.cpp.

{
    // Now find all new lines (<CR><LF>) and place in a vector and delete from buffer
    std::vector<std::string> lines;
 
    size_t found = 0;
    do
    {
        found = buffer.find("\r\n");
        if (found != std::string::npos)
        {
            lines.push_back(buffer.substr(0, found));
            buffer.erase(0, found + 2);
        }
    } while (found != std::string::npos);
 
    return lines;
}

Here is the caller graph for this function:

getPeerIP()

std::string TelnetSession::getPeerIP ( ) const

private

Definition at line 108 of file TelnetServer.cpp.

{
    sockaddr_in client_info{};
    memset(&client_info, 0, sizeof(client_info));
    socklen_t addrsize = sizeof(client_info);
    getpeername(m_socket, reinterpret_cast<sockaddr *>(&client_info), &addrsize);
 
    std::array<char, INET_ADDRSTRLEN> ipAddr{};
    inet_ntop(AF_INET, &client_info.sin_addr, ipAddr.data(), INET_ADDRSTRLEN);
 
    return ipAddr.data();
}

Here is the caller graph for this function:

initialise()

void TelnetSession::initialise ( )

protected

Initialise session.

Definition at line 220 of file TelnetServer.cpp.

{
    // Get details of connection
    spdlog::info("Telnet connection received from {}", getPeerIP());
 
    stats.connectTime = std::chrono::high_resolution_clock::now();
 
    // Set the connection to be non-blocking
    unsigned long iMode = 1;
    ioctl(m_socket, FIONBIO, &iMode);
 
    // Set NVT mode to say that I will echo back characters.
    const std::array<uint8_t, 3> willEcho{0xff, 0xfb, 0x01};
    ssize_t sendBytes = send(m_socket, willEcho.data(), 3, 0);
    if (sendBytes > 0)
    {
        stats.uploadBytes += static_cast<size_t>(sendBytes);
    }
 
    // Set NVT requesting that the remote system not/dont echo back characters
    const std::array<uint8_t, 3> dontEcho{0xff, 0xfe, 0x01};
    sendBytes = send(m_socket, dontEcho.data(), 3, 0);
    if (sendBytes > 0)
    {
        stats.uploadBytes += static_cast<size_t>(sendBytes);
    }
 
    // Set NVT mode to say that I will suppress go-ahead. Stops remote clients from doing local linemode.
    const std::array<uint8_t, 3> willSGA{0xff, 0xfb, 0x03};
    sendBytes = send(m_socket, willSGA.data(), 3, 0);
    if (sendBytes > 0)
    {
        stats.uploadBytes += static_cast<size_t>(sendBytes);
    }
 
    if (m_telnetServer->connectedCallback())
    {
        m_telnetServer->connectedCallback()(shared_from_this());
    }
 
    // Set last seen
    lastSeenTime = std::chrono::system_clock::now();
}

Here is the call graph for this function:

markTimeout()

void TelnetSession::markTimeout

(

)

Marks timeout to close session.

Definition at line 200 of file TelnetServer.cpp.

{
    lastSeenTime = std::chrono::system_clock::time_point(std::chrono::duration<int>(0));
}

processBackspace()

bool TelnetSession::processBackspace ( std::string & buffer )

staticprivate

Definition at line 299 of file TelnetServer.cpp.

{
    bool foundBackspaces = false;
 
    size_t found = 0;
    do
    {
        // Need to handle both \x7f and \b backspaces
        found = buffer.find_first_of('\x7f');
        if (found == std::string::npos)
        {
            found = buffer.find_first_of('\b');
        }
 
        if (found != std::string::npos)
        {
            if (buffer.length() > 1 && (found > 0))
            {
                buffer.erase(found - 1, 2);
            }
            else
            {
                buffer = "";
            }
            foundBackspaces = true;
        }
    } while (found != std::string::npos);
    return foundBackspaces;
}

Here is the caller graph for this function:

processCommandHistory()

bool TelnetSession::processCommandHistory ( std::string & buffer )

private

Definition at line 376 of file TelnetServer.cpp.

{
    // Handle up and down arrow actions
    if (m_telnetServer->interactivePrompt())
    {
        if (buffer.find(ANSI_ARROW_UP) != std::string::npos && !m_history.empty())
        {
            if (m_historyCursor != m_history.begin())
            {
                --m_historyCursor;
            }
            buffer = *m_historyCursor;
 
            // Issue a cursor command to counter it
            ssize_t sendBytes = 0;
            if ((sendBytes = send(m_socket, ANSI_ARROW_DOWN.c_str(), ANSI_ARROW_DOWN.length(), 0)) < 0)
            {
                return false;
            }
            stats.uploadBytes += static_cast<size_t>(sendBytes);
            return true;
        }
        if (buffer.find(ANSI_ARROW_DOWN) != std::string::npos && !m_history.empty())
        {
            if (next(m_historyCursor) != m_history.end())
            {
                ++m_historyCursor;
            }
            buffer = *m_historyCursor;
 
            // Issue a cursor command to counter it
            ssize_t sendBytes = 0;
            if ((sendBytes = send(m_socket, ANSI_ARROW_UP.c_str(), ANSI_ARROW_UP.length(), 0)) < 0)
            {
                return false;
            }
 
            stats.uploadBytes += static_cast<size_t>(sendBytes);
            return true;
        }
 
        // Ignore left and right and just reprint buffer
        if (buffer.find(ANSI_ARROW_LEFT) != std::string::npos || buffer.find(ANSI_ARROW_RIGHT) != std::string::npos)
        {
            return true;
        }
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

processTab()

bool TelnetSession::processTab ( std::string & buffer )

private

Definition at line 329 of file TelnetServer.cpp.

{
    bool foundTabs = false;
 
    size_t found = 0;
    do
    {
        found = buffer.find_first_of('\t');
        if (found != std::string::npos)
        {
            // Remove single tab
            if (buffer.length() > 0)
            {
                buffer.erase(found, 1);
            }
            foundTabs = true;
 
            // Process
            if (m_telnetServer->tabCallback())
            {
                const std::string retCommand =
                    m_telnetServer->tabCallback()(shared_from_this(), buffer.substr(0, found));
                if (!retCommand.empty())
                {
                    buffer.erase(0, found);
                    buffer.insert(0, retCommand);
                }
            }
        }
    } while (found != std::string::npos);
    return foundTabs;
}

Here is the caller graph for this function:

sendLine()

void TelnetSession::sendLine

(

std::string

data

)

Send a line of data to the Telnet Server.

Definition at line 160 of file TelnetServer.cpp.

{
    // If is something is on the prompt, wipe it off
    if (m_telnetServer->interactivePrompt() || m_buffer.length() > 0)
    {
        eraseLine();
    }
 
    data.append("\r\n");
    if (auto sendBytes = send(m_socket, data.c_str(), data.length(), 0) > 0)
    {
        stats.uploadBytes += static_cast<size_t>(sendBytes);
    }
 
    if (m_telnetServer->interactivePrompt())
    {
        sendPromptAndBuffer();
    }
}

Here is the call graph for this function:

sendPromptAndBuffer()

void TelnetSession::sendPromptAndBuffer ( )

private

Definition at line 121 of file TelnetServer.cpp.

{
    // Output the prompt
    ssize_t sendBytes =
        send(m_socket, m_telnetServer->promptString().c_str(), m_telnetServer->promptString().length(), 0);
    if (sendBytes > 0)
    {
        stats.uploadBytes += static_cast<size_t>(sendBytes);
    }
 
    // Resend the buffer
    if (m_buffer.length() > 0)
    {
        sendBytes = send(m_socket, m_buffer.c_str(), m_buffer.length(), 0);
        if (sendBytes > 0)
        {
            stats.uploadBytes += static_cast<size_t>(sendBytes);
        }
    }
}

Here is the caller graph for this function:

stripEscapeCharacters()

void TelnetSession::stripEscapeCharacters ( std::string & buffer )

staticprivate

Definition at line 281 of file TelnetServer.cpp.

{
    size_t found = 0;
    const std::array<std::string, 4> cursors = {ANSI_ARROW_UP, ANSI_ARROW_DOWN, ANSI_ARROW_RIGHT, ANSI_ARROW_LEFT};
 
    for (const auto &cursor : cursors)
    {
        do
        {
            found = buffer.find(cursor);
            if (found != std::string::npos)
            {
                buffer.erase(found, cursor.length());
            }
        } while (found != std::string::npos);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

stripNVT()

void TelnetSession::stripNVT ( std::string & buffer )

staticprivate

Definition at line 264 of file TelnetServer.cpp.

{
    size_t found = 0;
    do
    {
        found = buffer.find_first_of(static_cast<char>(ASCII_NBSP));
        if (found != std::string::npos && (found + 2) <= buffer.length() - 1)
        {
            buffer.erase(found, 3);
        }
        else if ((found + 2) >= buffer.length())
        {
            break;
        }
    } while (found != std::string::npos);
}

Here is the caller graph for this function:

update()

void TelnetSession::update ( )

protected

Called every frame/loop by the Terminal Server.

Definition at line 445 of file TelnetServer.cpp.

{
    ssize_t readBytes = 0;
    std::array<char, DEFAULT_BUFLEN> recvbuf{};
 
    // Reset stats
    stats.uploadBytes = 0;
    stats.downloadBytes = 0;
    stats.successCmdCtr = 0;
    stats.failCmdCtr = 0;
 
    // Receive
    readBytes = recv(m_socket, recvbuf.data(), DEFAULT_BUFLEN, 0);
 
    // Check for errors from the read
    if (readBytes < 0 && errno != EAGAIN)
    {
        close(m_socket);
    }
    else if (readBytes > 0)
    {
        stats.downloadBytes += static_cast<size_t>(readBytes);
 
        // Update last seen
        lastSeenTime = std::chrono::system_clock::now();
 
        // Echo it back to the sender
        echoBack(recvbuf.data(), static_cast<size_t>(readBytes));
 
        // we've got to be careful here. Telnet client might send null characters for New Lines mid-data block. We need
        // to swap these out. recv is not null terminated, so its cool
        for (size_t i = 0; i < static_cast<size_t>(readBytes); i++)
        {
            if (recvbuf[i] == ASCII_NULL) // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
            {
                // New Line constant
                recvbuf[i] = ASCII_LF; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
            }
        }
 
        // Add it to the received buffer
        m_buffer.append(recvbuf.data(), static_cast<unsigned int>(readBytes));
        // Remove telnet negotiation sequences
        stripNVT(m_buffer);
 
        bool requirePromptReprint = false;
        if (m_telnetServer->interactivePrompt())
        {
            // Read up and down arrow keys and scroll through history
            if (processCommandHistory(m_buffer))
            {
                requirePromptReprint = true;
            }
            stripEscapeCharacters(m_buffer);
 
            // Remove characters
            if (processBackspace(m_buffer))
            {
                requirePromptReprint = true;
            }
            // Complete commands
            if (processTab(m_buffer))
            {
                requirePromptReprint = true;
            }
        }
 
        // Process commands
        auto lines = getCompleteLines(m_buffer);
        for (const auto &line : lines)
        {
            if (m_telnetServer->newLineCallBack())
            {
                if (m_telnetServer->newLineCallBack()(shared_from_this(), line))
                {
                    ++stats.successCmdCtr;
                }
                else
                {
                    ++stats.failCmdCtr;
                }
                addToHistory(line);
            }
        }
 
        if (m_telnetServer->interactivePrompt() && requirePromptReprint)
        {
            eraseLine();
            sendPromptAndBuffer();
        }
    }
}

Here is the call graph for this function:

Member Data Documentation

lastSeenTime

std::chrono::system_clock::time_point TelnetSession::lastSeenTime

private

Definition at line 108 of file TelnetServer.hpp.

m_buffer

std::string TelnetSession::m_buffer

private

Definition at line 114 of file TelnetServer.hpp.

m_history

std::list<std::string> TelnetSession::m_history

private

Definition at line 116 of file TelnetServer.hpp.

m_historyCursor

std::list<std::string>::iterator TelnetSession::m_historyCursor

private

Definition at line 118 of file TelnetServer.hpp.

m_socket

Socket TelnetSession::m_socket

private

Definition at line 110 of file TelnetServer.hpp.

m_telnetServer

std::shared_ptr<TelnetServer> TelnetSession::m_telnetServer

private

Definition at line 112 of file TelnetServer.hpp.

stats

TelnetSessionStats TelnetSession::stats

private

Statistics variables.

Definition at line 106 of file TelnetServer.hpp.

TelnetServer

friend TelnetSession::TelnetServer

private

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