/* * This file is part of HayBox * Copyright (C) 2024 Jonathan Haylett * * HayBox is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License version 3 as * published by the Free Software Foundation. * * This software 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 software. If not, see . */ #include "comms/ConfiguratorBackend.hpp" #include "core/InputSource.hpp" #include "core/Persistence.hpp" #include "reboot.hpp" #include #include #include ConfiguratorBackend::ConfiguratorBackend( InputState &inputs, InputSource **input_sources, size_t input_source_count, Config &config, Stream &stream ) : CommunicationBackend(inputs, input_sources, input_source_count), _in(stream), _out(stream), _base_stream(stream), _config(config) {} CommunicationBackendId ConfiguratorBackend::BackendId() { return COMMS_BACKEND_CONFIGURATOR; } void ConfiguratorBackend::SendReport() { int data = ReadByte(); if (data < 0) { if (data == _in.EOP) { SkipToNextPacket(); } return; } Command command = (Command)data; switch (command) { case CMD_GET_DEVICE_INFO: HandleGetDeviceInfo(); break; case CMD_GET_CONFIG: HandleGetConfig(); break; case CMD_SET_CONFIG: HandleSetConfig(); break; case CMD_REBOOT_FIRMWARE: reboot_firmware(); break; case CMD_REBOOT_BOOTLOADER: reboot_bootloader(); break; case CMD_UNSPECIFIED: default: HandleUnknownCommand(command); break; } SkipToNextPacket(); } size_t ConfiguratorBackend::ReadPacket(uint8_t *buffer, size_t max_len) { size_t bytes_read = 0; while (!_in.available()) { delay(1); } while (true) { int result = _in.read(); if (result == _in.EOF) { continue; } if (result == _in.EOP) { break; } buffer[bytes_read++] = result; if (bytes_read >= max_len) { _in.next(); return bytes_read; } } _in.next(); return bytes_read; } int ConfiguratorBackend::ReadByte() { if (!_base_stream.available()) { return -1; } return _in.read(); } void ConfiguratorBackend::SkipToNextPacket() { _in.next(); } bool ConfiguratorBackend::WritePacket(Command command_id, uint8_t *buffer, size_t len) { _out.write((uint8_t)command_id); for (size_t i = 0; i < len; i++) { _out.write(buffer[i]); } return _out.end(); } bool ConfiguratorBackend::HandleGetDeviceInfo() { static const DeviceInfo device_info = { FIRMWARE_NAME, FIRMWARE_VERSION, DEVICE_NAME, }; // Ensure device info encodes correctly. size_t size; if (!pb_get_encoded_size(&size, DeviceInfo_fields, &device_info)) { char errmsg[] = "Failed to encode device info"; WritePacket(CMD_ERROR, (uint8_t *)errmsg, sizeof(errmsg)); return false; } _out.write(CMD_SET_DEVICE_INFO); pb_ostream_t ostream = as_pb_ostream(_out); pb_encode(&ostream, DeviceInfo_fields, &device_info); return _out.end(); } bool ConfiguratorBackend::HandleGetConfig() { if (!persistence.CheckSavedConfig()) { char errmsg[] = "Config file is invalid"; WritePacket(CMD_ERROR, (uint8_t *)errmsg, sizeof(errmsg)); return false; } // Write raw config data to output stream. _out.write(CMD_SET_CONFIG); persistence.LoadConfigRaw(_out, false); return _out.end(); } bool ConfiguratorBackend::HandleSetConfig() { // Reset config defaults first, so config is completely replaced rather than merged. _config = Config_init_default; pb_istream_t istream = as_pb_istream(_in); if (!pb_decode(&istream, Config_fields, &_config)) { char errmsg[100]; size_t errmsg_len = snprintf(errmsg, sizeof(errmsg), "Failed to decode config: %s", istream.errmsg); WritePacket(CMD_ERROR, (uint8_t *)errmsg, errmsg_len); // Restore old config. persistence.LoadConfig(_config); return false; } if (_config.default_backend_config > _config.communication_backend_configs_count) { char errmsg[75]; size_t errmsg_len = snprintf( errmsg, sizeof(errmsg), "Default backend ID is %d but only %d backend configs are defined", (uint8_t)_config.default_backend_config, (uint8_t)_config.communication_backend_configs_count ); WritePacket(CMD_ERROR, (uint8_t *)errmsg, errmsg_len); return false; } for (size_t i = 0; i < _config.communication_backend_configs_count; i++) { uint8_t default_mode_id = _config.communication_backend_configs[i].default_mode_config; if (default_mode_id > _config.game_mode_configs_count) { char errmsg[75]; size_t errmsg_len = snprintf( errmsg, sizeof(errmsg), "Default mode ID is %d for backend %d but only %d modes are defined", (uint8_t)default_mode_id, (uint8_t)i + 1, (uint8_t)_config.game_mode_configs_count ); WritePacket(CMD_ERROR, (uint8_t *)errmsg, errmsg_len); return false; } } for (size_t i = 0; i < _config.game_mode_configs_count; i++) { const GameModeConfig &gamemode_config = _config.game_mode_configs[i]; uint8_t keyboard_mode_id = gamemode_config.keyboard_mode_config; uint8_t custom_mode_id = gamemode_config.custom_mode_config; if (keyboard_mode_id > 0 && gamemode_config.mode_id != MODE_KEYBOARD) { char errmsg[80]; size_t errmsg_len = snprintf( errmsg, sizeof(errmsg), "keyboard_mode_id is set for game mode %d but mode_id is not MODE_KEYBOARD", (uint8_t)i + 1 ); WritePacket(CMD_ERROR, (uint8_t *)errmsg, errmsg_len); return false; } if (custom_mode_id > 0 && gamemode_config.mode_id != MODE_CUSTOM) { char errmsg[75]; size_t errmsg_len = snprintf( errmsg, sizeof(errmsg), "custom_mode_id is set for game mode %d but mode_id is not MODE_CUSTOM", (uint8_t)i + 1 ); WritePacket(CMD_ERROR, (uint8_t *)errmsg, errmsg_len); return false; } if (keyboard_mode_id > _config.keyboard_modes_count) { char errmsg[85]; size_t errmsg_len = snprintf( errmsg, sizeof(errmsg), "Keyboard mode ID %d is for game mode %d but only %d keyboard modes are defined", (uint8_t)keyboard_mode_id, (uint8_t)i + 1, (uint8_t)_config.keyboard_modes_count ); WritePacket(CMD_ERROR, (uint8_t *)errmsg, errmsg_len); return false; } if (custom_mode_id > _config.custom_modes_count) { char errmsg[85]; size_t errmsg_len = snprintf( errmsg, sizeof(errmsg), "Custom mode ID %d is for game mode config %d but only %d custom modes are defined", (uint8_t)custom_mode_id, (uint8_t)i + 1, (uint8_t)_config.custom_modes_count ); WritePacket(CMD_ERROR, (uint8_t *)errmsg, errmsg_len); return false; } } if (!persistence.SaveConfig(_config)) { char errmsg[] = "Failed to save config to memory"; WritePacket(CMD_ERROR, (uint8_t *)errmsg, sizeof(errmsg)); return false; } WritePacket(CMD_SUCCESS, nullptr, 0); return true; } bool ConfiguratorBackend::HandleUnknownCommand(Command command) { char errmsg[50]; size_t errmsg_len = snprintf(errmsg, sizeof(errmsg), "Unknown command ID: %d", (uint8_t)command); return WritePacket(CMD_ERROR, (uint8_t *)errmsg, errmsg_len); }