telnet.h

/*
 * uuid-telnet - Telnet service
 * Copyright 2019  Simon Arlott
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef UUID_TELNET_H_
#define UUID_TELNET_H_
 
#include <Arduino.h>
#ifdef ARDUINO_ARCH_ESP8266
# include <ESP8266WiFi.h>
#else
# include <WiFi.h>
#endif
#include <WiFiUdp.h>
 
#include <functional>
#include <list>
#include <memory>
#include <string>
#include <vector>
 
#include <uuid/console.h>
 
namespace uuid {
 
namespace telnet {
 
class TelnetStream: public ::Stream {
public:
    explicit TelnetStream(WiFiClient &client);
    virtual ~TelnetStream() = default;
 
    void start();
 
    int available() override;
    int read() override;
    int peek() override;
    size_t write(uint8_t data) override;
    size_t write(const uint8_t *buffer, size_t size) override;
    void flush() override;
 
private:
    static constexpr const unsigned char NUL = 0; 
    static constexpr const unsigned char BEL = 7; 
    static constexpr const unsigned char BS = 8; 
    static constexpr const unsigned char HT = 9; 
    static constexpr const unsigned char LF = 10; 
    static constexpr const unsigned char VT = 11; 
    static constexpr const unsigned char FF = 12; 
    static constexpr const unsigned char CR = 13; 
    static constexpr const unsigned char SE = 240; 
    static constexpr const unsigned char NOP = 241; 
    static constexpr const unsigned char DM = 242; 
    static constexpr const unsigned char BRK = 243; 
    static constexpr const unsigned char IP = 244; 
    static constexpr const unsigned char AO = 245; 
    static constexpr const unsigned char AYT = 246; 
    static constexpr const unsigned char EC = 247; 
    static constexpr const unsigned char EL = 248; 
    static constexpr const unsigned char GA = 249; 
    static constexpr const unsigned char SB = 250; 
    static constexpr const unsigned char WILL = 251; 
    static constexpr const unsigned char WONT = 252; 
    static constexpr const unsigned char DO = 253; 
    static constexpr const unsigned char DONT = 254; 
    static constexpr const unsigned char IAC = 255; 
    static constexpr const unsigned char OPT_BINARY = 0; 
    static constexpr const unsigned char OPT_ECHO = 1; 
    static constexpr const unsigned char OPT_SGA = 3; 
    static constexpr const size_t BUFFER_SIZE = 536; 
    TelnetStream(const TelnetStream&) = delete;
    TelnetStream& operator=(const TelnetStream&) = delete;
 
    int raw_available();
    int raw_read();
    void buffer_flush();
    size_t raw_write(unsigned char data);
    size_t raw_write(const std::vector<unsigned char> &data);
    size_t raw_write(const uint8_t *buffer, size_t size);
 
    WiFiClient &client_; 
    unsigned char previous_raw_in_ = 0; 
    bool sub_negotiation_ = false; 
    unsigned char previous_in_ = 0; 
    unsigned char previous_out_ = 0; 
    int peek_ = -1; 
    std::vector<char> output_buffer_; 
};
 
class TelnetService {
public:
    static constexpr size_t MAX_CONNECTIONS = 3; 
    static constexpr uint16_t DEFAULT_PORT = 23; 
    static constexpr unsigned long DEFAULT_IDLE_TIMEOUT = 600; 
    static constexpr unsigned long DEFAULT_WRITE_TIMEOUT = 0; 
    using shell_factory_function = std::function<std::shared_ptr<uuid::console::Shell>(Stream &stream, const IPAddress &addr, uint16_t port)>;
 
    TelnetService(std::shared_ptr<uuid::console::Commands> commands, unsigned int context = 0, unsigned int flags = 0);
 
    TelnetService(uint16_t port, std::shared_ptr<uuid::console::Commands> commands, unsigned int context = 0, unsigned int flags = 0);
 
    explicit TelnetService(shell_factory_function shell_factory);
 
    TelnetService(uint16_t port, shell_factory_function shell_factory);
 
    ~TelnetService() = default;
 
    void start();
    void close_all();
    void stop();
 
    size_t maximum_connections() const;
    void maximum_connections(size_t count);
 
    unsigned long initial_idle_timeout() const;
    void initial_idle_timeout(unsigned long timeout);
 
    unsigned long default_write_timeout() const;
    void default_write_timeout(unsigned long timeout);
 
    void loop();
 
private:
    class Connection {
    public:
        Connection(shell_factory_function &shell_factory, WiFiClient &&client, unsigned long idle_timeout, unsigned long write_timeout);
        ~Connection() = default;
 
        bool loop();
        bool stop();
 
    private:
        Connection(const Connection&) = delete;
        Connection& operator=(const Connection&) = delete;
 
        WiFiClient client_; 
        TelnetStream stream_; 
        std::weak_ptr<uuid::console::Shell> shell_; 
        IPAddress addr_; 
        uint16_t port_; 
    };
 
    TelnetService(const TelnetService&) = delete;
    TelnetService& operator=(const TelnetService&) = delete;
 
    static uuid::log::Logger logger_; 
    WiFiServer server_; 
    size_t maximum_connections_ = MAX_CONNECTIONS; 
    std::list<Connection> connections_; 
    shell_factory_function shell_factory_; 
    unsigned long initial_idle_timeout_ = DEFAULT_IDLE_TIMEOUT; 
    unsigned long write_timeout_ = DEFAULT_WRITE_TIMEOUT; 
};
 
} // namespace telnet
 
} // namespace uuid
 
#endif