244 lines
7.7 KiB
C++
244 lines
7.7 KiB
C++
#include "SerialEthernetInterface.h"
|
|
#include "../CompanionFrameQueue.h"
|
|
|
|
#define RECV_STATE_IDLE 0
|
|
#define RECV_STATE_HDR_FOUND 1
|
|
#define RECV_STATE_LEN1_FOUND 2
|
|
#define RECV_STATE_LEN2_FOUND 3
|
|
|
|
#if !ETHERNET_RAW_LINE
|
|
static constexpr uint32_t ETHERNET_FRAME_TIMEOUT_MS = 5000;
|
|
#endif
|
|
|
|
bool SerialEthernetInterface::begin() {
|
|
return true;
|
|
}
|
|
|
|
void SerialEthernetInterface::enable() {
|
|
if (_isEnabled) return;
|
|
_isEnabled = true;
|
|
clearBuffers();
|
|
}
|
|
|
|
void SerialEthernetInterface::disable() {
|
|
_isEnabled = false;
|
|
disconnectClient();
|
|
onClientDisconnected();
|
|
clearBuffers();
|
|
}
|
|
|
|
bool SerialEthernetInterface::isConnected() const {
|
|
return _isEnabled && session_active;
|
|
}
|
|
|
|
size_t SerialEthernetInterface::writeFrame(const uint8_t src[], size_t len) {
|
|
if (len > MAX_FRAME_SIZE) {
|
|
ETHERNET_DEBUG_PRINTLN("writeFrame(), frame too big, len=%d\n", len);
|
|
return 0;
|
|
}
|
|
|
|
if (_isEnabled && isConnected() && src != nullptr && len > 0) {
|
|
// A partly written frame must remain at the head even if a new response
|
|
// displaces or reorders lower-priority frames in the waiting tail.
|
|
const int pinned = send_queue_len > 0 && (send_offset != 0 || hasInFlightFrame()) ? 1 : 0;
|
|
int tail_len = send_queue_len - pinned;
|
|
if (!mesh::enqueueCompanionFrame(send_queue + pinned, tail_len, FRAME_QUEUE_SIZE - pinned,
|
|
src, len)) {
|
|
ETHERNET_DEBUG_PRINTLN("writeFrame(), send_queue is full!");
|
|
return 0;
|
|
}
|
|
send_queue_len = tail_len + pinned;
|
|
return len;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool SerialEthernetInterface::isWriteBusy() const {
|
|
return isIOUnavailable() || send_queue_len >= (FRAME_QUEUE_SIZE * 2 / 3);
|
|
}
|
|
|
|
bool SerialEthernetInterface::isReadBusy() const {
|
|
return _state != RECV_STATE_IDLE || _rx_len > 0;
|
|
}
|
|
|
|
bool SerialEthernetInterface::hasPendingIO() const {
|
|
// Ethernet is polled, so an active connection must keep receiving loop
|
|
// service even when no complete frame is queued yet.
|
|
return _isEnabled && isConnected();
|
|
}
|
|
|
|
void SerialEthernetInterface::onClientConnected(uint32_t remote_ip) {
|
|
const bool different_owner = queue_has_ip && queue_ip != remote_ip;
|
|
if (different_owner) {
|
|
// Cancel response producers while the displaced route is unavailable.
|
|
// Ethernet has only its original four-frame queue: unlike WiFi there is
|
|
// no spare queue for a different IP's backlog, so discard it on takeover.
|
|
onClientDisconnected();
|
|
send_queue_len = 0;
|
|
}
|
|
resetInput();
|
|
send_offset = 0; // Replay a complete frame on a fresh TCP stream.
|
|
queue_ip = remote_ip;
|
|
queue_has_ip = true;
|
|
session_active = true;
|
|
}
|
|
|
|
void SerialEthernetInterface::onClientDisconnected() {
|
|
const bool was_active = session_active;
|
|
session_active = false;
|
|
resetInput();
|
|
send_offset = 0;
|
|
if (was_active && session_changed != nullptr) session_changed(session_context);
|
|
}
|
|
|
|
void SerialEthernetInterface::rejectInput() {
|
|
disconnectClient();
|
|
onClientDisconnected();
|
|
}
|
|
|
|
bool SerialEthernetInterface::updateIOPause(uint32_t now) {
|
|
const bool unavailable = isIOUnavailable();
|
|
#if !ETHERNET_RAW_LINE
|
|
if (!isReadBusy()) {
|
|
_io_paused = false;
|
|
_io_paused_at = 0;
|
|
} else if (unavailable && !_io_paused) {
|
|
// Exclude only time owned by the worker. Never revive a frame whose
|
|
// original budget was already exhausted when backpressure was observed.
|
|
if ((uint32_t)(now - _rx_started) < ETHERNET_FRAME_TIMEOUT_MS) {
|
|
_io_paused_at = now;
|
|
_io_paused = true;
|
|
}
|
|
} else if (!unavailable && _io_paused) {
|
|
_rx_started += (uint32_t)(now - _io_paused_at);
|
|
_io_paused_at = 0;
|
|
_io_paused = false;
|
|
}
|
|
#else
|
|
(void)now;
|
|
#endif
|
|
return unavailable;
|
|
}
|
|
|
|
size_t SerialEthernetInterface::checkRecvFrame(uint8_t dest[]) {
|
|
if (!_isEnabled) return 0;
|
|
if (isConnected()) {
|
|
if (updateIOPause((uint32_t)millis())) return 0;
|
|
#if !ETHERNET_RAW_LINE
|
|
if (isReadBusy() && (uint32_t)((uint32_t)millis() - _rx_started) >= ETHERNET_FRAME_TIMEOUT_MS) {
|
|
rejectInput();
|
|
return 0;
|
|
}
|
|
#endif
|
|
if (send_queue_len > 0) { // first, check send queue
|
|
|
|
_last_write = millis();
|
|
int len = send_queue[0].len;
|
|
|
|
uint8_t pkt[MAX_FRAME_SIZE + 3];
|
|
#if ETHERNET_RAW_LINE
|
|
ETHERNET_DEBUG_PRINTLN("TX line len=%d", len);
|
|
memcpy(pkt, send_queue[0].buf, len);
|
|
pkt[len] = '\r';
|
|
pkt[len + 1] = '\n';
|
|
const size_t total = len + 2U;
|
|
#else
|
|
pkt[0] = '>';
|
|
pkt[1] = (len & 0xFF); // LSB
|
|
pkt[2] = (len >> 8); // MSB
|
|
memcpy(&pkt[3], send_queue[0].buf, send_queue[0].len);
|
|
ETHERNET_DEBUG_PRINTLN("Sending frame len=%d", len);
|
|
#if ETHERNET_DEBUG_LOGGING && ARDUINO
|
|
ETHERNET_DEBUG_PRINTLN("TX frame len=%d", len);
|
|
#endif
|
|
const size_t total = len + 3U;
|
|
#endif
|
|
const size_t remaining = total - send_offset;
|
|
const size_t written = write(pkt + send_offset, remaining);
|
|
// A bounded backend write may hand socket completion to its worker.
|
|
(void)updateIOPause((uint32_t)millis());
|
|
send_offset += written < remaining ? written : remaining;
|
|
if (send_offset < total) return 0;
|
|
send_offset = 0;
|
|
send_queue_len--;
|
|
for (int i = 0; i < send_queue_len; i++) { // delete top item from queue
|
|
send_queue[i] = send_queue[i + 1];
|
|
}
|
|
} else {
|
|
// Newly arriving bytes belong to the next mesh loop. A continuously
|
|
// writing peer must not monopolize radio and watchdog service.
|
|
int pending = available();
|
|
while (pending-- > 0) {
|
|
// A read may likewise hand its receive-ACK command to the worker;
|
|
// leave the rest of the frame untouched until hardware is available.
|
|
if (updateIOPause((uint32_t)millis())) break;
|
|
int c = read();
|
|
if (c < 0) break;
|
|
|
|
#if ETHERNET_RAW_LINE
|
|
if (c == '\r' || c == '\n') {
|
|
if (_rx_len == 0) {
|
|
continue;
|
|
}
|
|
uint16_t out_len = _rx_len;
|
|
if (dest == nullptr) { rejectInput(); return 0; }
|
|
memcpy(dest, _rx_buf, out_len);
|
|
resetInput();
|
|
return out_len;
|
|
}
|
|
if (_rx_len < MAX_FRAME_SIZE) {
|
|
if (_rx_len == 0) _rx_started = (uint32_t)millis();
|
|
_rx_buf[_rx_len] = (uint8_t)c;
|
|
_rx_len++;
|
|
} else {
|
|
rejectInput(); // Never execute the prefix of an overlong command.
|
|
return 0;
|
|
}
|
|
#else
|
|
switch (_state) {
|
|
case RECV_STATE_IDLE:
|
|
if (c == '<') {
|
|
_state = RECV_STATE_HDR_FOUND;
|
|
_rx_started = (uint32_t)millis();
|
|
}
|
|
break;
|
|
case RECV_STATE_HDR_FOUND:
|
|
_frame_len = (uint8_t)c;
|
|
_state = RECV_STATE_LEN1_FOUND;
|
|
break;
|
|
case RECV_STATE_LEN1_FOUND:
|
|
_frame_len |= ((uint16_t)c) << 8;
|
|
if (_frame_len == 0 || _frame_len > MAX_FRAME_SIZE) {
|
|
rejectInput();
|
|
return 0;
|
|
}
|
|
_rx_len = 0;
|
|
_state = RECV_STATE_LEN2_FOUND;
|
|
break;
|
|
default:
|
|
if (_rx_len < MAX_FRAME_SIZE) {
|
|
_rx_buf[_rx_len] = (uint8_t)c;
|
|
}
|
|
_rx_len++;
|
|
if (_rx_len >= _frame_len) {
|
|
#if ETHERNET_DEBUG_LOGGING && ARDUINO
|
|
ETHERNET_DEBUG_PRINTLN("RX frame len=%d", _frame_len);
|
|
#endif
|
|
if (dest == nullptr) { rejectInput(); return 0; }
|
|
const size_t out_len = _frame_len;
|
|
memcpy(dest, _rx_buf, out_len);
|
|
resetInput();
|
|
return out_len;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
// Snapshot availability or the final budgeted read can hand IO to the
|
|
// worker. Observe that pause after the byte has changed parser state.
|
|
(void)updateIOPause((uint32_t)millis());
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|