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)
bool	editInput (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 366 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 196 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 182 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 207 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:

editInput()

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

private

Definition at line 526 of file TelnetServer.cpp.

{
    if (!m_telnetServer->interactivePrompt())
    {
        return false;
    }
 
    // Read up and down arrow keys and scroll through history
    bool changed = processCommandHistory(buffer);
    stripEscapeCharacters(buffer);
 
    // Remove characters
    changed |= processBackspace(buffer);
    // Complete commands
    changed |= processTab(buffer);
    return changed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eraseLine()

void TelnetSession::eraseLine ( )

private

Definition at line 144 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 439 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 110 of file TelnetServer.cpp.

{
    sockaddr_in client_info{};
    memset(&client_info, 0, sizeof(client_info));
    socklen_t addrsize = sizeof(client_info);
    getpeername(m_socket, std::bit_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 222 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 202 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 301 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 (found > 0)
            {
                buffer.erase(found - 1, 2);
            }
            else
            {
                // Nothing to delete before it, drop only the backspace itself
                buffer.erase(0, 1);
            }
            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 380 of file TelnetServer.cpp.

{
    if (!m_telnetServer->interactivePrompt())
    {
        return false;
    }
 
    // Handle up and down arrow actions
    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 (m_historyCursor == m_history.end())
        {
            buffer.clear();
        }
        else
        {
            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 332 of file TelnetServer.cpp.

{
    bool foundTabs = false;
 
    size_t found = 0;
    do
    {
        found = buffer.find_first_of('\t');
        if (found == std::string::npos)
        {
            continue;
        }
 
        // Remove single tab
        if (!buffer.empty())
        {
            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 162 of file TelnetServer.cpp.

{
    // If is something is on the prompt, wipe it off
    if (m_telnetServer->interactivePrompt() || !m_buffer.empty())
    {
        eraseLine();
    }
 
    data.append("\r\n");
    if (const auto sendBytes = send(m_socket, data.c_str(), data.length(), 0); sendBytes > 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 123 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.empty())
    {
        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 283 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 266 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 458 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
        std::replace_if(
            recvbuf.begin(), recvbuf.begin() + readBytes, [](char chr) { return chr == ASCII_NULL; }, ASCII_LF);
 
        // Add it to the received buffer
        m_buffer.append(recvbuf.data(), static_cast<unsigned int>(readBytes));
        // Remove telnet negotiation sequences
        stripNVT(m_buffer);
 
        // Several commands can arrive in a single recv. Split them first so line editing (history, backspace, tab)
        // is applied to each line separately instead of the whole chunk
        std::string pending = std::move(m_buffer);
        m_buffer.clear();
 
        const auto lines = getCompleteLines(pending);
        for (auto line : lines)
        {
            editInput(line);
 
            if (!m_telnetServer->newLineCallBack())
            {
                break;
            }
 
            m_telnetServer->newLineCallBack()(shared_from_this(), line) ? ++stats.successCmdCtr : ++stats.failCmdCtr;
            addToHistory(line);
        }
 
        // Remaining incomplete line stays in the buffer
        m_buffer = std::move(pending);
        if (editInput(m_buffer) && m_telnetServer->interactivePrompt())
        {
            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 110 of file TelnetServer.hpp.

m_buffer

std::string TelnetSession::m_buffer

private

Definition at line 116 of file TelnetServer.hpp.

m_history

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

private

Definition at line 118 of file TelnetServer.hpp.

m_historyCursor

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

private

Definition at line 120 of file TelnetServer.hpp.

m_socket

Socket TelnetSession::m_socket

private

Definition at line 112 of file TelnetServer.hpp.

m_telnetServer

std::shared_ptr<TelnetServer> TelnetSession::m_telnetServer

private

Definition at line 114 of file TelnetServer.hpp.

stats

TelnetSessionStats TelnetSession::stats

private

Statistics variables.

Definition at line 108 of file TelnetServer.hpp.

TelnetServer

friend TelnetSession::TelnetServer

private

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