Use local UDP messages instead of web server

src/controller.cpp

@@ -5,7 +5,7 @@
 #include <SPI.h>
 #include <Ethernet.h>
 
-SesameController::SesameController(uint16_t localWebServerPort) : localWebServer(localWebServerPort) {
+SesameController::SesameController() {
 
 }
 
@@ -51,41 +51,54 @@ void SesameController::configure(ServoConfiguration servoConfig, ServerConfigura
     // Direct messages and errors over the websocket to the controller
     server.configure(serverConfig, this);
     Serial.println("[INFO] Server connection configured");
-    
-    // Direct messages from the local web server to the controller
-    localWebServer.on("/message", HTTP_POST, [this] (AsyncWebServerRequest *request) { 
-        this->handleLocalMessage(request); 
-        this->sendPreparedLocalResponse(request);
-    });
 
-    Serial.println("[INFO] Local web server configured");
+    Udp.begin(ethernetConfig.udpPort);
+    Serial.println("[INFO] Local UDP connection configured");
 }
 
 void SesameController::loop(uint32_t millis) {
     currentTime = millis;
-    server.loop(millis);
+    //server.loop(millis);
+
+    checkLocalMessage();
 }
 
 // MARK: Local
 
-void SesameController::handleLocalMessage(AsyncWebServerRequest *request) {
-    if (!request->hasParam(messageUrlParameter)) {
-        Serial.println("Missing url parameter");
-        prepareResponseBuffer(MessageResult::InvalidUrlParameter);
-        return;
+void SesameController::checkLocalMessage() {
+    if (readLocalMessage()) {
+        sendPreparedLocalResponse();
     }
-    String encoded = request->getParam(messageUrlParameter)->value();
-    if (!convertHexMessageToBinary(encoded.c_str())) {
-        Serial.println("Invalid hex encoding");
-        prepareResponseBuffer(MessageResult::InvalidMessageSizeFromRemote);
-        return;
-    }
-    processMessage(&receivedLocalMessage);
 }
 
-void SesameController::sendPreparedLocalResponse(AsyncWebServerRequest *request) {
-    request->send_P(200, "application/octet-stream", (uint8_t*) &outgoingMessage, SIGNED_MESSAGE_SIZE);
-    Serial.printf("[INFO] Local response %u,%u\n", outgoingMessage.message.messageType, outgoingMessage.message.result);
+bool SesameController::readLocalMessage() {
+    // if there's data available, read a packet
+    int packetSize = Udp.parsePacket();
+    if (packetSize == 0) {
+        return false;
+    }
+    if (packetSize != SIGNED_MESSAGE_SIZE) {
+        Serial.print("Received packet of invalid size ");
+        Serial.println(packetSize);
+        prepareResponseBuffer(MessageResult::InvalidMessageSizeFromRemote);
+        return true;
+    }
+    int bytesRead = Udp.read((uint8_t*) &receivedLocalMessage, SIGNED_MESSAGE_SIZE);
+    if (bytesRead != SIGNED_MESSAGE_SIZE) {
+        Serial.println("Failed to read full local message");
+        prepareResponseBuffer(MessageResult::InvalidMessageSizeFromRemote);
+        return true;
+    }
+    Serial.println("Received local message");
+    processMessage(&receivedLocalMessage, true);
+    return true;
+}
+
+void SesameController::sendPreparedLocalResponse() {
+    // send a reply to the IP address and port that sent us the packet we received
+    Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
+    Udp.write((uint8_t*) &outgoingMessage, SIGNED_MESSAGE_SIZE);
+    Udp.endPacket();
 }
 
 // MARK: Server
@@ -101,7 +114,7 @@ void SesameController::handleServerMessage(uint8_t* payload, size_t length) {
         sendServerError(MessageResult::InvalidMessageSizeFromRemote);
         return;
     }
-    processMessage((SignedMessage*) payload);
+    processMessage((SignedMessage*) payload, true);
     sendPreparedResponseToServer();
 }
 
@@ -112,7 +125,7 @@ void SesameController::sendPreparedResponseToServer() {
 
 // MARK: Message handling
 
-void SesameController::processMessage(SignedMessage* message) {
+void SesameController::processMessage(SignedMessage* message, bool shouldPerformUnlock) {
     // Result must be empty
     if (message->message.result != MessageResult::MessageAccepted) {
         prepareResponseBuffer(MessageResult::InvalidMessageResultFromRemote);
@@ -127,7 +140,7 @@ void SesameController::processMessage(SignedMessage* message) {
         checkAndPrepareChallenge(&message->message);
         return;
     case MessageType::request:
-        completeUnlockRequest(&message->message);
+        completeUnlockRequest(&message->message, shouldPerformUnlock);
         return;
     default:
         prepareResponseBuffer(MessageResult::InvalidMessageTypeFromRemote);
@@ -158,7 +171,7 @@ void SesameController::prepareChallenge(Message* message) {
     prepareResponseBuffer(MessageResult::MessageAccepted, message);
 }
 
-void SesameController::completeUnlockRequest(Message* message) {
+void SesameController::completeUnlockRequest(Message* message, bool shouldPerformUnlock) {
     // Client and server challenge must match
     if (message->clientChallenge != currentClientChallenge) {
         prepareResponseBuffer(MessageResult::InvalidClientChallengeFromRemote, message);
@@ -180,7 +193,9 @@ void SesameController::completeUnlockRequest(Message* message) {
     clearCurrentChallenge();
     
     // Move servo
-    servo.pressButton();
+    if (shouldPerformUnlock) {
+        servo.pressButton();
+    }
     prepareResponseBuffer(MessageResult::MessageAccepted, message);
     Serial.println("[INFO] Accepted message");
 }

src/main.cpp

@@ -22,7 +22,7 @@
 #include "controller.h"
 #include "config.h"
 
-SesameController controller(localPort);
+SesameController controller{};
 
 void setup() {
     Serial.begin(serialBaudRate);
@@ -59,6 +59,7 @@ void setup() {
         .dhcpLeaseResponseTimeoutMs = dhcpLeaseResponseTimeoutMs,
         .manualIp = manualIpAddress,
         .manualDnsAddress = manualDnsServerAddress,
+        .udpPort = localUdpPort,
     };
 
     KeyConfiguration keyConfig {