mh
/
mhsw-espurna
1
0
Fork 0
Code Releases 0 Activity
Fork of the espurna firmware for `mhsw` switches
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3354 Commits
18 Branches
212 MiB
 
 
 
 
 
 
Tree: cb23c9444b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cb23c9444b'
${ noResults }
mhsw-espurna/code/espurna/terminal.cpp

693 lines
20 KiB
Raw Blame History

/*
TERMINAL MODULE
Copyright (C) 2016-2019 by Xose Pérez <xose dot perez at gmail dot com>
Copyright (C) 2020 by Maxim Prokhorov <prokhorov dot max at outlook dot com>
*/
#include "espurna.h"
#if TERMINAL_SUPPORT
#include "api.h"
#include "settings.h"
#include "system.h"
#include "telnet.h"
#include "utils.h"
#include "mqtt.h"
#include "wifi.h"
#include "ws.h"
#include "libs/URL.h"
#include "libs/StreamAdapter.h"
#include "libs/PrintString.h"
#include "web_asyncwebprint_impl.h"
#include <algorithm>
#include <vector>
#include <utility>
#include <Schedule.h>
#include <Stream.h>
// not yet CONNECTING or LISTENING
extern struct tcp_pcb *tcp_bound_pcbs;
// accepting or sending data
extern struct tcp_pcb *tcp_active_pcbs;
// // TIME-WAIT status
extern struct tcp_pcb *tcp_tw_pcbs;
namespace {
// Based on libs/StreamInjector.h by Xose Pérez <xose dot perez at gmail dot com> (see git-log for more info)
// Instead of custom write(uint8_t) callback, we provide writer implementation in-place
struct TerminalIO final : public Stream {
TerminalIO(size_t capacity = 128) :
_buffer(new char[capacity]),
_capacity(capacity),
_write(0),
_read(0)
{}
~TerminalIO() {
delete[] _buffer;
}
// ---------------------------------------------------------------------
// Injects data into the internal buffer so we can read() it
// ---------------------------------------------------------------------
size_t capacity() {
return _capacity;
}
size_t inject(char ch) {
_buffer[_write] = ch;
_write = (_write + 1) % _capacity;
return 1;
}
size_t inject(char *data, size_t len) {
for (size_t index = 0; index < len; ++index) {
inject(data[index]);
}
return len;
}
// ---------------------------------------------------------------------
// XXX: We are only supporting part of the Print & Stream interfaces
// But, we need to be have all pure virtual methods implemented
// ---------------------------------------------------------------------
// Return data from the internal buffer
int available() override {
unsigned int bytes = 0;
if (_read > _write) {
bytes += (_write - _read + _capacity);
} else if (_read < _write) {
bytes += (_write - _read);
}
return bytes;
}
int peek() override {
int ch = -1;
if (_read != _write) {
ch = _buffer[_read];
}
return ch;
}
int read() override {
int ch = -1;
if (_read != _write) {
ch = _buffer[_read];
_read = (_read + 1) % _capacity;
}
return ch;
}
// {Stream,Print}::flush(), see:
// - https://github.com/esp8266/Arduino/blob/master/cores/esp8266/Print.h
// - https://github.com/espressif/arduino-esp32/blob/master/cores/esp32/Print.h
// - https://github.com/arduino/ArduinoCore-API/issues/102
// Old 2.3.0 expects flush() on Stream, latest puts in in Print
// We may have to cheat the system and implement everything as Stream to have it available.
void flush() override {
// Here, reset reader position so that we return -1 until we have new data
// writer flushing is implemented below, we don't need it here atm
_read = _write;
}
size_t write(const uint8_t* buffer, size_t size) override {
// Buffer data until we encounter line break, then flush via Raw debug method
// (which is supposed to 1-to-1 copy the data, without adding the timestamp)
#if DEBUG_SUPPORT
if (!size) return 0;
if (buffer[size-1] == '\0') return 0;
if (_output.capacity() < (size + 2)) {
_output.reserve(_output.size() + size + 2);
}
_output.insert(_output.end(),
reinterpret_cast<const char*>(buffer),
reinterpret_cast<const char*>(buffer) + size
);
if (_output.end() != std::find(_output.begin(), _output.end(), '\n')) {
_output.push_back('\0');
debugSendRaw(_output.data());
_output.clear();
}
#endif
return size;
}
size_t write(uint8_t ch) override {
uint8_t buffer[1] {ch};
return write(buffer, 1);
}
private:
#if DEBUG_SUPPORT
std::vector<char> _output;
#endif
char * _buffer;
unsigned char _capacity;
unsigned char _write;
unsigned char _read;
};
auto _io = TerminalIO(TERMINAL_SHARED_BUFFER_SIZE);
terminal::Terminal _terminal(_io, _io.capacity());
// TODO: re-evaluate how and why this is used
#if SERIAL_RX_ENABLED
constexpr size_t SerialRxBufferSize { 128u };
char _serial_rx_buffer[SerialRxBufferSize];
static unsigned char _serial_rx_pointer = 0;
#endif // SERIAL_RX_ENABLED
// -----------------------------------------------------------------------------
// Commands
// -----------------------------------------------------------------------------
void _terminalHelpCommand(const terminal::CommandContext& ctx) {
auto names = _terminal.names();
// XXX: Core's ..._P funcs only allow 2nd pointer to be in PROGMEM,
// explicitly load the 1st one
std::sort(names.begin(), names.end(), [](const __FlashStringHelper* lhs, const __FlashStringHelper* rhs) {
const String lhs_as_string(lhs);
return strncasecmp_P(lhs_as_string.c_str(), reinterpret_cast<const char*>(rhs), lhs_as_string.length()) < 0;
});
ctx.output.print(F("Available commands:\n"));
for (auto* name : names) {
ctx.output.printf("> %s\n", reinterpret_cast<const char*>(name));
}
terminalOK(ctx.output);
}
namespace dns {
using Callback = std::function<void(const char* name, const ip_addr_t* addr, void* arg)>;
namespace internal {
struct Task {
Task() = delete;
explicit Task(String&& hostname, Callback&& callback) :
_hostname(std::move(hostname)),
_callback(std::move(callback))
{}
ip_addr_t* addr() {
return &_addr;
}
const char* hostname() const {
return _hostname.c_str();
}
void callback(const char* name, const ip_addr_t* addr, void* arg) {
_callback(name, addr, arg);
}
void callback() {
_callback(hostname(), addr(), nullptr);
}
private:
String _hostname;
Callback _callback;
ip_addr_t _addr { IPADDR_NONE };
};
using TaskPtr = std::unique_ptr<Task>;
TaskPtr task;
void callback(const char* name, const ip_addr_t* addr, void* arg) {
if (task) {
task->callback(name, addr, arg);
}
task.reset();
}
} // namespace internal
bool started() {
return static_cast<bool>(internal::task);
}
void start(String&& hostname, Callback&& callback) {
auto task = std::make_unique<internal::Task>(std::move(hostname), std::move(callback));
switch (dns_gethostbyname(task->hostname(), task->addr(), internal::callback, nullptr)) {
case ERR_OK:
task->callback();
break;
case ERR_INPROGRESS:
internal::task = std::move(task);
break;
default:
break;
}
}
} // namespace dns
void _terminalInitCommands() {
terminalRegisterCommand(F("COMMANDS"), _terminalHelpCommand);
terminalRegisterCommand(F("HELP"), _terminalHelpCommand);
terminalRegisterCommand(F("ERASE.CONFIG"), [](const terminal::CommandContext&) {
terminalOK();
customResetReason(CustomResetReason::Terminal);
eraseSDKConfig();
*((int*) 0) = 0; // see https://github.com/esp8266/Arduino/issues/1494
});
terminalRegisterCommand(F("ADC"), [](const terminal::CommandContext& ctx) {
const int pin = (ctx.argc == 2)
? ctx.argv[1].toInt()
: A0;
ctx.output.println(analogRead(pin));
terminalOK(ctx);
});
terminalRegisterCommand(F("GPIO"), [](const terminal::CommandContext& ctx) {
const int pin = (ctx.argc >= 2)
? ctx.argv[1].toInt()
: -1;
if ((pin >= 0) && !gpioValid(pin)) {
terminalError(ctx, F("Invalid pin number"));
return;
}
int start = 0;
int end = gpioPins();
switch (ctx.argc) {
case 3:
pinMode(pin, OUTPUT);
digitalWrite(pin, (1 == ctx.argv[2].toInt()));
break;
case 2:
start = pin;
end = pin + 1;
// fallthrough into print
case 1:
for (auto current = start; current < end; ++current) {
if (gpioValid(current)) {
ctx.output.printf_P(PSTR("%c %s @ GPIO%02d (%s)\n"),
gpioLocked(current) ? '*' : ' ',
GPEP(current) ? "OUTPUT" : "INPUT ",
current,
(HIGH == digitalRead(current)) ? "HIGH" : "LOW"
);
}
}
break;
}
terminalOK(ctx);
});
terminalRegisterCommand(F("HEAP"), [](const terminal::CommandContext& ctx) {
static auto initial = systemInitialFreeHeap();
auto stats = systemHeapStats();
ctx.output.printf_P(PSTR("initial: %u, available: %u, fragmentation: %hhu%%\n"),
initial, stats.available, stats.frag_pct);
terminalOK(ctx);
});
terminalRegisterCommand(F("STACK"), [](const terminal::CommandContext& ctx) {
ctx.output.printf_P(PSTR("continuation stack initial: %d, free: %u\n"),
CONT_STACKSIZE, systemFreeStack());
terminalOK(ctx);
});
terminalRegisterCommand(F("INFO"), [](const terminal::CommandContext&) {
info();
terminalOK();
});
terminalRegisterCommand(F("RESET"), [](const terminal::CommandContext& ctx) {
auto count = 1;
if (ctx.argc == 2) {
count = ctx.argv[1].toInt();
if (count < SYSTEM_CHECK_MAX) {
systemStabilityCounter(count);
}
}
terminalOK(ctx);
deferredReset(100, CustomResetReason::Terminal);
});
terminalRegisterCommand(F("UPTIME"), [](const terminal::CommandContext& ctx) {
ctx.output.println(getUptime());
terminalOK(ctx);
});
#if SECURE_CLIENT == SECURE_CLIENT_BEARSSL
terminalRegisterCommand(F("MFLN.PROBE"), [](const terminal::CommandContext& ctx) {
if (ctx.argc != 3) {
terminalError(F("[url] [value]"));
return;
}
URL _url(ctx.argv[1]);
uint16_t requested_mfln = atol(ctx.argv[2].c_str());
auto client = std::make_unique<BearSSL::WiFiClientSecure>();
client->setInsecure();
if (client->probeMaxFragmentLength(_url.host.c_str(), _url.port, requested_mfln)) {
terminalOK();
} else {
terminalError(F("Buffer size not supported"));
}
});
#endif
terminalRegisterCommand(F("HOST"), [](const terminal::CommandContext& ctx) {
if (ctx.argc != 2) {
terminalError(ctx, F("HOST <hostname>"));
return;
}
dns::start(String(ctx.argv[1]), [&](const char* name, const ip_addr_t* addr, void*) {
if (!addr) {
ctx.output.printf_P(PSTR("%s not found\n"), name);
return;
}
ctx.output.printf_P(PSTR("%s has address %s\n"),
name, IPAddress(addr).toString().c_str());
});
while (dns::started()) {
delay(100);
}
});
terminalRegisterCommand(F("NETSTAT"), [](const terminal::CommandContext& ctx) {
auto print = [](Print& out, tcp_pcb* list) {
for (tcp_pcb* pcb = list; pcb != nullptr; pcb = pcb->next) {
out.printf_P(PSTR("state %s local %s:%hu remote %s:%hu\n"),
tcp_debug_state_str(pcb->state),
IPAddress(pcb->local_ip).toString().c_str(),
pcb->local_port,
IPAddress(pcb->remote_ip).toString().c_str(),
pcb->remote_port);
}
};
print(ctx.output, tcp_active_pcbs);
print(ctx.output, tcp_tw_pcbs);
print(ctx.output, tcp_bound_pcbs);
});
}
void _terminalLoop() {
#if DEBUG_SERIAL_SUPPORT
while (DEBUG_PORT.available()) {
_io.inject(DEBUG_PORT.read());
}
#endif
_terminal.process([](terminal::Terminal::Result result) {
bool out = false;
switch (result) {
case terminal::Terminal::Result::CommandNotFound:
terminalError(terminalDefaultStream(), F("Command not found"));
out = true;
break;
case terminal::Terminal::Result::BufferOverflow:
terminalError(terminalDefaultStream(), F("Command line buffer overflow"));
out = true;
break;
case terminal::Terminal::Result::Command:
out = true;
break;
case terminal::Terminal::Result::Pending:
out = false;
break;
case terminal::Terminal::Result::Error:
terminalError(terminalDefaultStream(), F("Unexpected error when parsing command line"));
out = false;
break;
case terminal::Terminal::Result::NoInput:
out = false;
break;
}
return out;
});
#if SERIAL_RX_ENABLED
while (SERIAL_RX_PORT.available() > 0) {
char rc = SERIAL_RX_PORT.read();
_serial_rx_buffer[_serial_rx_pointer++] = rc;
if ((_serial_rx_pointer == SerialRxBufferSize) || (rc == 10)) {
terminalInject(_serial_rx_buffer, (size_t) _serial_rx_pointer);
_serial_rx_pointer = 0;
}
}
#endif // SERIAL_RX_ENABLED
}
#if MQTT_SUPPORT && TERMINAL_MQTT_SUPPORT
void _terminalMqttSetup() {
mqttRegister([](unsigned int type, const char * topic, const char * payload) {
if (type == MQTT_CONNECT_EVENT) {
mqttSubscribe(MQTT_TOPIC_CMD);
return;
}
if (type == MQTT_MESSAGE_EVENT) {
String t = mqttMagnitude((char *) topic);
if (!t.startsWith(MQTT_TOPIC_CMD)) return;
if (!strlen(payload)) return;
String cmd(payload);
if (!cmd.endsWith("\r\n") && !cmd.endsWith("\n")) {
cmd += '\n';
}
// TODO: unlike http handler, we have only one output stream
// and **must** have a fixed-size output buffer
// (wishlist: MQTT client does some magic and we don't buffer twice)
schedule_function([cmd]() {
PrintString buffer(TCP_MSS);
StreamAdapter<const char*> stream(buffer, cmd.c_str(), cmd.c_str() + cmd.length() + 1);
String out;
terminal::Terminal handler(stream);
switch (handler.processLine()) {
case terminal::Terminal::Result::CommandNotFound:
out += F("Command not found");
break;
case terminal::Terminal::Result::Command:
out = std::move(buffer);
default:
break;
}
if (out.length()) {
mqttSendRaw(mqttTopic(MQTT_TOPIC_CMD, false).c_str(), out.c_str(), false);
}
});
return;
}
});
}
#endif // MQTT_SUPPORT && TERMINAL_MQTT_SUPPORT
} // namespace
// -----------------------------------------------------------------------------
// Pubic API
// -----------------------------------------------------------------------------
#if TERMINAL_WEB_API_SUPPORT
// XXX: new `apiRegister()` depends that `webServer()` is available, meaning we can't call this setup func
// before the `webSetup()` is called. ATM, just make sure it is in order.
void terminalWebApiSetup() {
#if API_SUPPORT
apiRegister(getSetting("termWebApiPath", TERMINAL_WEB_API_PATH),
[](ApiRequest& api) {
api.handle([](AsyncWebServerRequest* request) {
AsyncResponseStream *response = request->beginResponseStream("text/plain");
for (auto* name : _terminal.names()) {
response->print(name);
response->print("\r\n");
}
request->send(response);
});
return true;
},
[](ApiRequest& api) {
// TODO: since HTTP spec allows query string to contain repeating keys, allow iteration
// over every received 'line' to provide a way to call multiple commands at once
auto cmd = api.param(F("line"));
if (!cmd.length()) {
return false;
}
if (!cmd.endsWith("\r\n") && !cmd.endsWith("\n")) {
cmd += '\n';
}
api.handle([&](AsyncWebServerRequest* request) {
AsyncWebPrint::scheduleFromRequest(request, [cmd](Print& print) {
StreamAdapter<const char*> stream(print, cmd.c_str(), cmd.c_str() + cmd.length() + 1);
terminal::Terminal handler(stream);
handler.processLine();
});
});
return true;
}
);
#else
webRequestRegister([](AsyncWebServerRequest* request) {
String path(F(API_BASE_PATH));
path += getSetting("termWebApiPath", TERMINAL_WEB_API_PATH);
if (path != request->url()) {
return false;
}
if (!apiAuthenticate(request)) {
request->send(403);
return true;
}
auto* cmd_param = request->getParam("line", (request->method() == HTTP_PUT));
if (!cmd_param) {
request->send(500);
return true;
}
auto cmd = cmd_param->value();
if (!cmd.length()) {
request->send(500);
return true;
}
if (!cmd.endsWith("\r\n") && !cmd.endsWith("\n")) {
cmd += '\n';
}
// TODO: batch requests? processLine() -> process(...)
AsyncWebPrint::scheduleFromRequest(request, [cmd](Print& print) {
StreamAdapter<const char*> stream(print, cmd.c_str(), cmd.c_str() + cmd.length() + 1);
terminal::Terminal handler(stream);
handler.processLine();
});
return true;
});
#endif // API_SUPPORT
}
#endif // TERMINAL_WEB_API_SUPPORT
Stream & terminalDefaultStream() {
return (Stream &) _io;
}
size_t terminalCapacity() {
return _io.capacity();
}
void terminalInject(void *data, size_t len) {
_io.inject((char *) data, len);
}
void terminalInject(char ch) {
_io.inject(ch);
}
void terminalRegisterCommand(const __FlashStringHelper* name, terminal::Terminal::CommandFunc func) {
terminal::Terminal::addCommand(name, func);
};
void terminalOK(Print& print) {
print.print(F("+OK\n"));
}
void terminalError(Print& print, const String& error) {
print.printf("-ERROR: %s\n", error.c_str());
}
void terminalOK(const terminal::CommandContext& ctx) {
terminalOK(ctx.output);
}
void terminalError(const terminal::CommandContext& ctx, const String& error) {
terminalError(ctx.output, error);
}
void terminalOK() {
terminalOK(_io);
}
void terminalError(const String& error) {
terminalError(_io, error);
}
void terminalSetup() {
// Show DEBUG panel with input
#if WEB_SUPPORT
wsRegister()
.onVisible([](JsonObject& root) { root["cmdVisible"] = 1; });
#endif
// Similar to the above, but we allow only very small and in-place outputs.
#if MQTT_SUPPORT && TERMINAL_MQTT_SUPPORT
_terminalMqttSetup();
#endif
// Initialize default commands
_terminalInitCommands();
#if SERIAL_RX_ENABLED
SERIAL_RX_PORT.begin(SERIAL_RX_BAUDRATE);
#endif // SERIAL_RX_ENABLED
// Register loop
espurnaRegisterLoop(_terminalLoop);
}
#endif // TERMINAL_SUPPORT