AsyncUDP: keep track of the last sent packet and skip it while LOOPing

This means we don't invoke the receive handler for packets we send.

Author: Jorropo

cores/portduino/AsyncUDP.cpp

@@ -49,12 +49,20 @@ void _asyncudp_on_read_cb(uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf,
 }
 
 void AsyncUDP::_DO_NOT_CALL_uv_on_read(uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf, const struct sockaddr *addr, unsigned flags) {
+    if (nread <= 0) {
+        return;
+    }
     _handlerMutex.lock();
     auto h = _handler;
     _handlerMutex.unlock();
-    if (h) {
-        AsyncUDPPacket packet((uint8_t*)buf->base, nread);
-        h(packet);
+    if (_waitingToBeLooped && nread == _waitingToBeLooped->len && memcmp(buf->base, _waitingToBeLooped->data, nread) == 0) {
+        _waitingToBeLooped = std::unique_ptr<asyncUDPSendTask>();
+        _attemptWrite();
+    } else {
+        if (h) {
+            AsyncUDPPacket packet((uint8_t*)buf->base, nread);
+            h(packet);
+        }
     }
     free(buf->base);
 }
@@ -156,16 +164,21 @@ size_t AsyncUDP::writeTo(const uint8_t *data, size_t len, const IPAddress addr,
     return len;
 }
 
-void AsyncUDP::_DO_NOT_CALL_async_cb() {
+void AsyncUDP::_attemptWrite() {
     _sendQueueMutex.lock();
-    while (!_sendQueue.empty()) {
+    if (!_waitingToBeLooped && !_sendQueue.empty()) {
         auto task = std::move(_sendQueue.back());
         _sendQueue.pop_back();
         _sendQueueMutex.unlock();
         _doWrite(task->data, task->len, task->addr, task->port);
         _sendQueueMutex.lock();
+        _waitingToBeLooped = std::move(task);
     }
     _sendQueueMutex.unlock();
+}
+
+void AsyncUDP::_DO_NOT_CALL_async_cb() {
+    _attemptWrite();
     if (_quit.load()) {
         uv_udp_recv_stop(&_socket);
         // FIXME: don't do bytes → string → bytes IP conversion

cores/portduino/AsyncUDP.h

@@ -69,6 +69,11 @@ class AsyncUDP final
     // the queue is used because uv_udp_send is not threadsafe and uv_async can merge multiple calls into one callback
     std::vector<std::unique_ptr<asyncUDPSendTask>> _sendQueue;
 
+    // _waitingToBeLooped is used to wait for a sent packet to be looped back before we send an other one.
+    // This allows the recv callback to omit sent packets.
+    // It must be accessed from the uv loop.
+    std::unique_ptr<asyncUDPSendTask> _waitingToBeLooped;
+
     std::atomic<bool> _quit;
     std::thread _ioThread;
 
@@ -109,6 +114,9 @@ class AsyncUDP final
     void _DO_NOT_CALL_async_cb();
 
 private:
+    // _attemptWrite must be accessed from the uv loop.
+    void _attemptWrite();
+    // _doWrite must be accessed from the uv loop.
     void _doWrite(const uint8_t *data, size_t len, const IPAddress addr, uint16_t port);
 };