shell.cpp

/*
 * uuid-console - Microcontroller console shell
 * Copyright 2019,2021-2022  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/>.
 */
 
#include <uuid/console.h>
 
#include <Arduino.h>
#include <stdarg.h>
 
#include <algorithm>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
#include <uuid/common.h>
#include <uuid/log.h>
 
#if !defined(__cpp_lib_make_unique) && !defined(DOXYGEN)
namespace std {
 
template<typename _Tp, typename... _Args>
inline unique_ptr<_Tp> make_unique(_Args&&... __args) {
    return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...));
}
 
} // namespace std
#endif
 
namespace uuid {
 
namespace console {
 
// cppcheck-suppress passedByValue
Shell::Shell(Stream &stream, std::shared_ptr<Commands> commands, unsigned int context, unsigned int flags)
        : stream_(stream), commands_(std::move(commands)), flags_(flags) {
    enter_context(context);
}
 
void Shell::start() {
    uuid::log::Logger::register_handler(this, uuid::log::Level::NOTICE);
    line_buffer_.reserve(maximum_command_line_length_);
    display_banner();
    display_prompt();
    registered_shells().insert(shared_from_this());
    idle_time_ = uuid::get_uptime_ms();
    started();
};
 
void Shell::started() {
 
}
 
bool Shell::running() const {
    return !stopped_;
}
 
void Shell::stop() {
    if (mode_ == Mode::BLOCKING) {
        auto *blocking_data = reinterpret_cast<Shell::BlockingData*>(mode_data_.get());
 
        blocking_data->stop_ = true;
    } else {
        if (running()) {
            stopped_ = true;
            stopped();
        }
    }
}
 
void Shell::stopped() {
 
}
 
bool Shell::exit_context() {
    if (context_.size() > 1) {
        context_.pop_back();
        return true;
    } else {
        return false;
    }
}
 
Commands::AvailableCommands Shell::available_commands() const {
    return commands_->available_commands(*this);
}
 
void Shell::loop_one() {
    if (!running()) {
        return;
    }
 
    switch (mode_) {
    case Mode::NORMAL:
        output_logs();
        loop_normal();
        break;
 
    case Mode::PASSWORD:
        output_logs();
        loop_password();
        break;
 
    case Mode::DELAY:
        output_logs();
        loop_delay();
        break;
 
    case Mode::BLOCKING:
        loop_blocking();
        break;
    }
}
 
void Shell::loop_normal() {
    const int input = stream_.read();
 
    if (input < 0) {
        check_idle_timeout();
        return;
    }
 
    const unsigned char c = input;
 
    switch (c) {
    case '\x03':
        // Interrupt (^C)
        line_buffer_.clear();
        println();
        prompt_displayed_ = false;
        display_prompt();
        break;
 
    case '\x04':
        // End of transmission (^D)
        if (line_buffer_.empty()) {
            end_of_transmission();
        }
        break;
 
    case '\x08':
    case '\x7F':
        // Backspace (^H)
        // Delete (^?)
        if (!line_buffer_.empty()) {
            erase_characters(1);
            line_buffer_.pop_back();
        }
        break;
 
    case '\x09':
        // Tab (^I)
        process_completion();
        break;
 
    case '\x0A':
        // Line feed (^J)
        if (previous_ != '\x0D') {
            process_command();
        }
        break;
 
    case '\x0C':
        // New page (^L)
        erase_current_line();
        prompt_displayed_ = false;
        display_prompt();
        break;
 
    case '\x0D':
        // Carriage return (^M)
        process_command();
        break;
 
    case '\x15':
        // Delete line (^U)
        erase_current_line();
        prompt_displayed_ = false;
        line_buffer_.clear();
        display_prompt();
        break;
 
    case '\x17':
        // Delete word (^W)
        delete_buffer_word(true);
        break;
 
    default:
        if (c >= '\x20' && c <= '\x7E') {
            // ASCII text
            if (line_buffer_.length() < maximum_command_line_length_) {
                line_buffer_.push_back(c);
                write((uint8_t)c);
            }
        }
        break;
    }
 
    previous_ = c;
 
    // This is a hack to let TelnetStream know that command
    // execution is complete and that output can be flushed.
    stream_.available();
 
    idle_time_ = uuid::get_uptime_ms();
}
 
Shell::PasswordData::PasswordData(const __FlashStringHelper *password_prompt, password_function &&password_function)
        : password_prompt_(password_prompt), password_function_(std::move(password_function)) {
 
}
 
void Shell::loop_password() {
    const int input = stream_.read();
 
    if (input < 0) {
        check_idle_timeout();
        return;
    }
 
    const unsigned char c = input;
 
    switch (c) {
    case '\x03':
        // Interrupt (^C)
        process_password(false);
        break;
 
    case '\x08':
    case '\x7F':
        // Backspace (^H)
        // Delete (^?)
        if (!line_buffer_.empty()) {
            line_buffer_.pop_back();
        }
        break;
 
    case '\x0A':
        // Line feed (^J)
        if (previous_ != '\x0D') {
            process_password(true);
        }
        break;
 
    case '\x0C':
        // New page (^L)
        erase_current_line();
        prompt_displayed_ = false;
        display_prompt();
        break;
 
    case '\x0D':
        // Carriage return (^M)
        process_password(true);
        break;
 
    case '\x15':
        // Delete line (^U)
        line_buffer_.clear();
        break;
 
    case '\x17':
        // Delete word (^W)
        delete_buffer_word(false);
        break;
 
    default:
        if (c >= '\x20' && c <= '\x7E') {
            // ASCII text
            if (line_buffer_.length() < maximum_command_line_length_) {
                line_buffer_.push_back(c);
            }
        }
        break;
    }
 
    previous_ = c;
 
    // This is a hack to let TelnetStream know that command
    // execution is complete and that output can be flushed.
    stream_.available();
 
    idle_time_ = uuid::get_uptime_ms();
}
 
Shell::DelayData::DelayData(uint64_t delay_time, delay_function &&delay_function)
        : delay_time_(delay_time), delay_function_(std::move(delay_function)) {
 
}
 
void Shell::loop_delay() {
    auto *delay_data = reinterpret_cast<Shell::DelayData*>(mode_data_.get());
 
    if (uuid::get_uptime_ms() >= delay_data->delay_time_) {
        auto function_copy = delay_data->delay_function_;
 
        mode_ = Mode::NORMAL;
        mode_data_.reset();
 
        function_copy(*this);
 
        if (running()) {
            display_prompt();
        }
 
        idle_time_ = uuid::get_uptime_ms();
    }
}
 
Shell::BlockingData::BlockingData(blocking_function &&blocking_function)
        : blocking_function_(std::move(blocking_function)) {
 
}
 
void Shell::loop_blocking() {
    auto *blocking_data = reinterpret_cast<Shell::BlockingData*>(mode_data_.get());
 
    /* It is not possible to change mode while executing this function,
     * because that would require copying either the std::shared_ptr or
     * the std::function on every loop execution (to ensure that the
     * function captures aren't destroyed while executing).
     */
    if (blocking_data->blocking_function_(*this, blocking_data->stop_)) {
        bool stop_pending = blocking_data->stop_;
 
        mode_ = Mode::NORMAL;
        mode_data_.reset();
 
        if (stop_pending) {
            stop();
        }
 
        if (running()) {
            display_prompt();
        }
 
        idle_time_ = uuid::get_uptime_ms();
    }
}
 
void Shell::enter_password(const __FlashStringHelper *prompt, password_function function) {
    if (mode_ == Mode::NORMAL) {
        mode_ = Mode::PASSWORD;
        mode_data_ = std::make_unique<Shell::PasswordData>(prompt, std::move(function));
    }
}
 
void Shell::delay_for(unsigned long ms, delay_function function) {
    delay_until(uuid::get_uptime_ms() + ms, std::move(function));
}
 
void Shell::delay_until(uint64_t ms, delay_function function) {
    if (mode_ == Mode::NORMAL) {
        mode_ = Mode::DELAY;
        mode_data_ = std::make_unique<Shell::DelayData>(ms, std::move(function));
    }
}
 
void Shell::block_with(blocking_function function) {
    if (mode_ == Mode::NORMAL) {
        mode_ = Mode::BLOCKING;
        mode_data_ = std::make_unique<Shell::BlockingData>(std::move(function));
    }
}
 
void Shell::delete_buffer_word(bool display) {
    size_t pos = line_buffer_.find_last_of(' ');
 
    if (pos == std::string::npos) {
        line_buffer_.clear();
        if (display) {
            erase_current_line();
            prompt_displayed_ = false;
            display_prompt();
        }
    } else {
        if (display) {
            erase_characters(line_buffer_.length() - pos);
        }
        line_buffer_.resize(pos);
    }
}
 
size_t Shell::maximum_command_line_length() const {
    return maximum_command_line_length_;
}
 
void Shell::maximum_command_line_length(size_t length) {
    maximum_command_line_length_ = std::max((size_t)1, length);
    line_buffer_.reserve(maximum_command_line_length_);
}
 
void Shell::process_command() {
    CommandLine command_line{line_buffer_};
 
    line_buffer_.clear();
    println();
    prompt_displayed_ = false;
 
    if (!command_line->empty()) {
        if (commands_) {
            auto execution = commands_->execute_command(*this, std::move(command_line));
 
            if (execution.error != nullptr) {
                println(execution.error);
            }
        } else {
            println(F("No commands configured"));
        }
    }
 
    if (running()) {
        display_prompt();
    }
    ::yield();
}
 
void Shell::process_completion() {
    CommandLine command_line{line_buffer_};
 
    if (!command_line->empty() && commands_) {
        auto completion = commands_->complete_command(*this, command_line);
        bool redisplay = false;
 
        if (!completion.help.empty()) {
            println();
            redisplay = true;
 
            for (auto &help : completion.help) {
                std::string help_line = help.to_string(maximum_command_line_length_);
 
                println(help_line);
            }
        }
 
        if (!completion.replacement->empty()) {
            if (!redisplay) {
                erase_current_line();
                prompt_displayed_ = false;
                redisplay = true;
            }
 
            line_buffer_ = completion.replacement.to_string(maximum_command_line_length_);
        }
 
        if (redisplay) {
            display_prompt();
        }
    }
 
    ::yield();
}
 
void Shell::process_password(bool completed) {
    println();
 
    auto *password_data = reinterpret_cast<Shell::PasswordData*>(mode_data_.get());
    auto function_copy = password_data->password_function_;
 
    mode_ = Mode::NORMAL;
    mode_data_.reset();
 
    function_copy(*this, completed, line_buffer_);
    line_buffer_.clear();
 
    if (running()) {
        display_prompt();
    }
}
 
void Shell::invoke_command(const std::string &line) {
    if (!line_buffer_.empty()) {
        println();
        prompt_displayed_ = false;
    }
    if (!prompt_displayed_) {
        display_prompt();
    }
    line_buffer_ = line;
    print(line_buffer_);
    process_command();
}
 
unsigned long Shell::idle_timeout() const {
    return idle_timeout_ / 1000;
}
 
void Shell::idle_timeout(unsigned long timeout) {
    idle_timeout_ = (uint64_t)timeout * 1000;
}
 
void Shell::check_idle_timeout() {
    if (idle_timeout_ > 0 && uuid::get_uptime_ms() - idle_time_ >= idle_timeout_) {
        println();
        stop();
    }
}
 
} // namespace console
 
} // namespace uuid