TelnetServer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "telnet/TelnetStats.hpp"
 
#include <array>
#include <functional>
#include <list>
#include <memory>
#include <string>
#include <thread>
#include <vector>
 
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <unistd.h>
 
class TelnetServer;
class TelnetSession;
 
using Socket = int;
 
class TelnetSession : public std::enable_shared_from_this<TelnetSession> {
  public:
    TelnetSession(Socket ClientSocket, std::shared_ptr<TelnetServer> tServer)
        : m_socket(ClientSocket), m_telnetServer(std::move(tServer))
    {
        m_historyCursor = m_history.end();
    };
 
    void sendLine(std::string data);
    void closeClient();
    bool checkTimeout() const;
    void markTimeout();
 
  protected:
    void initialise();
    void update();
 
  private:
    // Returns ip of the peer
    std::string getPeerIP() const;
    // Write the prompt and any data sat in the input buffer
    void sendPromptAndBuffer();
    // Erase all characters on the current line and move prompt back to beginning of line
    void eraseLine();
    // Echo back message
    void echoBack(const char *buffer, unsigned long length);
    //
    static void stripNVT(std::string &buffer);
    // Remove all escape characters from the line
    static void stripEscapeCharacters(std::string &buffer);
    // Takes backspace commands and removes them and the preceding character from the m_buffer. Handles arrow key
    // actions for history management. Returns true if the input buffer was changed.
    static bool processBackspace(std::string &buffer);
    // Takes tab commands and completes or suggests commands
    bool processTab(std::string &buffer);
    // Add a command into the command history
    void addToHistory(const std::string &line);
    // Handles arrow key actions for history management. Returns true if the input buffer was changed.
    bool processCommandHistory(std::string &buffer);
    //
    static std::vector<std::string> getCompleteLines(std::string &buffer);
 
    TelnetSessionStats stats;
    // Last seen
    std::chrono::system_clock::time_point lastSeenTime;
    // The socket
    Socket m_socket;
    // Parent TelnetServer class
    std::shared_ptr<TelnetServer> m_telnetServer;
    // Buffer of input data (mid line)
    std::string m_buffer;
    // A history of all completed commands
    std::list<std::string> m_history;
    // Iterator to completed commands
    std::list<std::string>::iterator m_historyCursor;
 
    friend TelnetServer;
};
 
using SP_TelnetSession = std::shared_ptr<TelnetSession>;
using VEC_SP_TelnetSession = std::vector<SP_TelnetSession>;
 
using FPTR_ConnectedCallback = std::function<void(SP_TelnetSession)>;
using FPTR_NewLineCallback = std::function<bool(SP_TelnetSession, std::string)>;
using FPTR_TabCallback = std::function<std::string(SP_TelnetSession, std::string)>;
 
class TelnetServer : public std::enable_shared_from_this<TelnetServer> {
  public:
    TelnetServer() = default;
 
    TelnetServer(const TelnetServer & /*unused*/) = delete;
 
    TelnetServer(TelnetServer && /*unused*/) = delete;
 
    TelnetServer &operator=(TelnetServer /*unused*/) = delete;
 
    TelnetServer &operator=(TelnetServer && /*unused*/) = delete;
 
    ~TelnetServer();
 
    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();
 
    void connectedCallback(FPTR_ConnectedCallback func) { m_connectedCallback = std::move(func); }
    FPTR_ConnectedCallback connectedCallback() const { return m_connectedCallback; }
 
    void newLineCallback(FPTR_NewLineCallback func) { m_newlineCallback = std::move(func); }
    FPTR_NewLineCallback newLineCallBack() const { return m_newlineCallback; }
 
    void tabCallback(FPTR_TabCallback func) { m_tabCallback = std::move(func); }
    FPTR_TabCallback tabCallback() const { return m_tabCallback; }
 
    const VEC_SP_TelnetSession &sessions() const { return m_sessions; }
 
    bool interactivePrompt() const { return !m_promptString.empty(); }
    void promptString(const std::string_view &prompt) { m_promptString = prompt; }
    const std::string &promptString() const { return m_promptString; }
 
  private:
    // Called after the telnet session is initialised. function(SP_TelnetSession) {}
    FPTR_ConnectedCallback m_connectedCallback;
    // Called after every new line (from CR or LF) function(SP_TelnetSession, std::string) {}
    FPTR_NewLineCallback m_newlineCallback;
    // Called after TAB detected. function(SP_TelnetSession, std::string, PredictSignalType) {}
    FPTR_TabCallback m_tabCallback;
 
    bool acceptConnection();
    void threadFunc() noexcept;
 
    void update();
 
    unsigned long m_listenPort{};
    Socket m_listenSocket{-1};
    VEC_SP_TelnetSession m_sessions;
    bool m_initialised{false};
    // A string that denotes the current prompt
    std::string m_promptString;
 
    // Statistics
    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; 
};
 
void TelnetPrintAvailableCommands(const SP_TelnetSession &session);
 
void TelnetConnectedCallback(const SP_TelnetSession &session);
 
bool TelnetMessageCallback(const SP_TelnetSession &session, const std::string &line);
 
std::string TelnetTabCallback(const SP_TelnetSession &session, std::string_view line);