Compare commits

...
Author SHA1 Message Date
Sergio R. Caprile 10226d8784 test: assess CPQ UDP buffering proposal 2026-11-19 16:57:20 -03:00
Sergio R. Caprile 069ab78c02 Merge pull request #3784 from cesanta/picosdk
update to Pico-SDK 2.2.0 (to be able to build with GCC 15)
2026-11-18 13:52:53 -03:00
Sergio R. Caprile 1ce7e416b0 update to Pico-SDK 2.2.0 (to be able to build with GCC 15) 2026-11-17 17:43:44 -03:00
19 changed files with 1031 additions and 15 deletions

No files matched your search

+14
View File
@@ -0,0 +1,14 @@
name: CPQ UDP Assessment
on:
workflow_dispatch:
jobs:
cpq-udp:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v5
with: { fetch-depth: 2 }
- run: |
source ./test/setup_ga_network.sh
make -C test/bsd -f failMakefile
+1 -2
View File
@@ -560,8 +560,7 @@ jobs:
# - run: make -C tutorials/${{ matrix.example.path }} build
wizard_examples_arm:
# Keep rp-ti on 24.04: Pico SDK 2.1.1 pioasm fails with GCC 15; update SDK
runs-on: ${{ matrix.group == 'rp-ti' && 'ubuntu-24.04' || 'ubuntu-latest' }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
+3 -6
View File
@@ -201,8 +201,7 @@ jobs:
run: make -C tutorials/${{ matrix.example.path }} build
generic_examples_arm:
# Keep RP on 24.04: Pico SDK 2.1.1 pioasm fails with GCC 15; update SDK
runs-on: ${{ startsWith(matrix.example.path, 'rp/') && 'ubuntu-24.04' || 'ubuntu-latest' }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
@@ -245,8 +244,7 @@ jobs:
run: make -C tutorials/${{ matrix.example.path }} build
device_dashboard_examples_arm:
# Keep RP on 24.04: Pico SDK 2.1.1 pioasm fails with GCC 15; update SDK
runs-on: ${{ startsWith(matrix.example.path, 'rp/') && 'ubuntu-24.04' || 'ubuntu-latest' }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
@@ -272,8 +270,7 @@ jobs:
run: make -C tutorials/${{ matrix.example.path }} build
mqtt_dashboard_examples_arm:
# Pico SDK 2.1.0 pioasm fails with GCC 15; update SDK to unpin
runs-on: ubuntu-24.04
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
+2
View File
@@ -10901,6 +10901,8 @@ static bool rx_udp(struct mg_tcpip_if *ifp, struct pkt *pkt) {
struct connstate *s;
uint8_t *l2addr;
if (c == NULL) return false; // No UDP listener on this port
// BSD socket has an unread datagram: drop this one to keep boundaries
if (c->is_bsd && c->recv.len > 0) return true;
s = (struct connstate *) (c + 1);
c->rem.port = pkt->udp->sport;
#if MG_ENABLE_IPV6
+2
View File
@@ -1226,6 +1226,8 @@ static bool rx_udp(struct mg_tcpip_if *ifp, struct pkt *pkt) {
struct connstate *s;
uint8_t *l2addr;
if (c == NULL) return false; // No UDP listener on this port
// BSD socket has an unread datagram: drop this one to keep boundaries
if (c->is_bsd && c->recv.len > 0) return true;
s = (struct connstate *) (c + 1);
c->rem.port = pkt->udp->sport;
#if MG_ENABLE_IPV6
+120
View File
@@ -0,0 +1,120 @@
#include <errno.h>
#include <spawn.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include "FreeRTOS.h"
#include "task.h"
volatile bool s_cpq_done;
volatile bool s_cpq_ready;
bool s_cpq_remote;
static bool s_cpq_ok;
#include "bsd_udp_cpq_fail.c"
static void cpq_log(char ch, void *param) {
(void) param;
putchar(ch);
}
static void cpq_task1(void *args) {
struct mg_mgr *mgr = (struct mg_mgr *) args;
const char *remote_peer = getenv("CPQ_REMOTE_PEER");
char *ip = NULL;
char *argv[5];
pid_t pid;
pid_t r;
int status;
extern char **environ;
while (mgr->ifp->ip == 0 && mg_millis() < 5000) {
mg_mgr_poll(mgr, 0);
vTaskDelay(1);
}
if (mgr->ifp->ip == 0) {
printf("FAIL setup: DHCP lease timed out\n");
s_cpq_ok = false;
goto done;
}
while (mgr->ifp->state != MG_TCPIP_STATE_READY) {
mg_mgr_poll(mgr, 0);
vTaskDelay(1);
}
s_cpq_remote = remote_peer != NULL && remote_peer[0] != '\0';
s_cpq_done = false;
s_cpq_ready = false;
if (xTaskCreate(bsd_udp_cpq_fail_task, "cpq", 1024, NULL,
configMAX_PRIORITIES - 1, NULL) != pdPASS) {
printf("FAIL setup: cannot create CPQ task\n");
s_cpq_ok = false;
goto done;
}
while (!s_cpq_ready && !s_cpq_done) {
mg_mgr_poll(mgr, 0);
vTaskDelay(1);
}
if (!s_cpq_ready) {
printf("FAIL setup: CPQ task did not bind sockets\n");
s_cpq_ok = false;
goto done;
}
printf("CPQ: sockets ready\n");
ip = mg_mprintf("%M", mg_print_ip4, &mgr->ifp->ip);
printf("CPQ: Mongoose IP %s\n", ip);
argv[0] = (char *) "./bsd_udp_cpq_peer";
argv[1] = s_cpq_remote ? (char *) "--helper" : ip;
argv[2] = s_cpq_remote ? (char *) remote_peer : NULL;
argv[3] = s_cpq_remote ? ip : NULL;
argv[4] = NULL;
if (posix_spawn(&pid, argv[0], NULL, NULL, argv, environ) != 0) {
printf("FAIL setup: cannot start CPQ helper\n");
s_cpq_ok = false;
goto done;
}
printf("CPQ: %s started\n", s_cpq_remote ? "helper" : "peer");
while (!s_cpq_done) {
mg_mgr_poll(mgr, 0);
vTaskDelay(1);
}
while ((r = waitpid(pid, &status, WNOHANG)) == 0) {
mg_mgr_poll(mgr, 0);
vTaskDelay(1);
}
if (r != pid || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
printf("FAIL setup: CPQ peer failed\n");
s_cpq_ok = false;
}
done:
mg_free(ip);
mg_mgr_free(mgr);
vTaskEndScheduler();
}
static bool bsd_cpq_test(struct mg_tcpip_driver *driver, void *driver_data,
const char *mac, const char *debug_level) {
struct mg_mgr mgr;
struct mg_tcpip_if mif;
mg_log_set(atoi(debug_level == NULL ? "3" : debug_level));
mg_log_set_fn(cpq_log, NULL);
mg_mgr_init(&mgr);
memset(&mif, 0, sizeof(mif));
mif.driver = driver;
mif.driver_data = driver_data;
sscanf(mac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &mif.mac[0], &mif.mac[1],
&mif.mac[2], &mif.mac[3], &mif.mac[4], &mif.mac[5]);
mg_tcpip_init(&mgr, &mif);
if (mgr.ifp == NULL ||
xTaskCreate(cpq_task1, "cpqnet", 2048, &mgr,
configMAX_PRIORITIES - 2, NULL) != pdPASS)
return false;
s_cpq_ok = true;
vTaskStartScheduler();
return s_cpq_ok;
}
+8
View File
@@ -95,7 +95,11 @@ bool mg_random(void *buf, size_t len) {
}
#ifdef CPQ_TEST
#include "bsd_cpq_test.c"
#else
#include "bsd_x_test.c"
#endif
int main(void) {
@@ -107,7 +111,11 @@ int main(void) {
printf("Opening SHM interface\n");
usleep(200000); // 200 ms
#ifdef CPQ_TEST
result = bsd_cpq_test(&shm_driver, &shm_data, mac, debug_level);
#else
result = bsd_x_test(&shm_driver, &shm_data, mac, debug_level);
#endif
if (shm_data.shm != NULL) munmap(shm_data.shm, sizeof(*shm_data.shm));
if (shm_data.fp != NULL) fclose(shm_data.fp);
if (!result) return EXIT_FAILURE;
+174
View File
@@ -0,0 +1,174 @@
// Demonstrates UDP behavior with the CPQ patch. Run this task with
// bsd_udp_cpq_peer against a Mongoose interface whose address it receives.
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include "mongoose.h"
#include "FreeRTOS.h"
#include "task.h"
#define DATA_PORT 1234
#define CONTROL_PORT 1235
#define SEND_PORT 1236
#define PEER_A_PORT 14001
static char s_big[1600];
extern volatile bool s_cpq_done;
extern volatile bool s_cpq_ready;
extern bool s_cpq_remote;
void bsd_udp_cpq_fail_task(void *args);
static int udp_bind(unsigned port) {
struct sockaddr_in sa;
int fd = socket(AF_INET, SOCK_DGRAM, 0);
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons((uint16_t) port);
if (fd < 0 || bind(fd, (struct sockaddr *) &sa, sizeof(sa)) != 0) {
printf("cannot bind UDP port %u: %d\n", port, errno);
return -1;
}
return fd;
}
static void go(int fd) {
if (send(fd, "go", 2, 0) != 2) printf("control send failed: %d\n", errno);
}
static void wait_for_packets(void) {
vTaskDelay(pdMS_TO_TICKS(100)); // Let the manager collect peer datagrams
}
void bsd_udp_cpq_fail_task(void *args) {
struct sockaddr_in control_peer, peer, local, other;
socklen_t peerlen, locallen;
char buf[16];
int data = -1, control = -1, out = -1, fd = -1, connected = -1;
ssize_t n;
(void) args;
data = udp_bind(DATA_PORT);
control = udp_bind(CONTROL_PORT);
out = udp_bind(SEND_PORT);
if (data < 0 || control < 0 || out < 0) goto done;
s_cpq_ready = true;
printf("CPQ: control socket waiting\n");
// The peer identifies itself on the control socket, which learns its MAC.
peerlen = sizeof(control_peer);
n = recvfrom(control, buf, sizeof(buf), 0,
(struct sockaddr *) &control_peer, &peerlen);
if (n != 5 || memcmp(buf, "ready", 5) != 0) goto done;
printf("CPQ: peer ready\n");
fd = udp_bind(1237);
n = fd < 0 ? -1 : send(fd, "x", 1, 0);
printf("%s send: expected EDESTADDRREQ, got %d: no peer check\n",
n < 0 && errno == EDESTADDRREQ ? "PASS" : "FAIL", (int) n);
if (fd >= 0) close(fd);
fd = udp_bind(1238);
n = fd < 0 ? -1 : connect(fd, (struct sockaddr *) &control_peer, peerlen);
locallen = sizeof(local);
if (n == 0 && getsockname(fd, (struct sockaddr *) &local, &locallen) == 0) {
printf("%s bind: expected 1238, got %u: connect replaced bind\n",
mg_ntohs(local.sin_port) == 1238 ? "PASS" : "FAIL",
(unsigned) mg_ntohs(local.sin_port));
} else {
printf("FAIL bind: connect failed errno %d\n", errno);
}
if (fd >= 0) close(fd);
fd = udp_bind(1239);
other = control_peer, other.sin_port = htons(14998);
n = fd < 0 ? -1 : sendto(fd, s_big, sizeof(s_big), 0,
(struct sockaddr *) &other, sizeof(other));
printf("%s oversize: expected EMSGSIZE, got %d: later truncated\n",
n < 0 && errno == EMSGSIZE ? "PASS" : "FAIL", (int) n);
if (fd >= 0) close(fd);
// The patch keeps the first nonempty datagram and drops the second.
go(control);
wait_for_packets();
peerlen = sizeof(peer);
n = recvfrom(data, buf, sizeof(buf), 0, (struct sockaddr *) &peer, &peerlen);
if (n == 3 && memcmp(buf, "one", 3) == 0 &&
mg_ntohs(peer.sin_port) == PEER_A_PORT &&
recvfrom(data, buf, sizeof(buf), MSG_DONTWAIT, NULL, NULL) < 0 &&
errno == EAGAIN) {
printf("PASS drop: kept one, dropped two\n");
} else {
printf("FAIL drop: expected one then EAGAIN, got %d \"%.*s\"\n", (int) n,
(int) (n > 0 ? n : 0), buf);
}
// A short UDP receive must discard the rest of that datagram.
go(control);
wait_for_packets();
n = recvfrom(data, buf, 2, 0, NULL, NULL);
n = recvfrom(data, buf, sizeof(buf), MSG_DONTWAIT, NULL, NULL);
printf("%s short: expected EAGAIN, got %d \"%.*s\": tail retained\n",
n < 0 && errno == EAGAIN ? "PASS" : "FAIL", (int) n,
(int) (n > 0 ? n : 0), buf);
// A zero-length datagram is data and recvfrom() must return zero for it.
go(control);
wait_for_packets();
n = recvfrom(data, buf, sizeof(buf), MSG_DONTWAIT, NULL, NULL);
printf("%s empty: expected 0, got %d errno %d: no marker\n",
n == 0 ? "PASS" : "FAIL", (int) n, errno);
// An unbound connected socket must reject another sender's datagram.
if (send(control, "connect", 7, 0) != 7 ||
(connected = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ||
connect(connected, (struct sockaddr *) &control_peer,
sizeof(control_peer)) != 0 ||
send(connected, "hello", 5, 0) != 5) {
goto done;
}
wait_for_packets();
n = recv(connected, buf, sizeof(buf), MSG_DONTWAIT);
printf("%s peer: expected EAGAIN, got %d \"%.*s\": no peer filter\n",
n < 0 && errno == EAGAIN ? "PASS" : "FAIL", (int) n,
(int) (n > 0 ? n : 0), buf);
n = send(connected, "reply", 5, 0);
printf("reply: sent %d bytes; peer reports its destination below\n", (int) n);
if (recv(control, buf, sizeof(buf), 0) < 0) goto done; // Peer checked reply
other = control_peer, other.sin_port = htons(14999);
n = sendto(connected, "x", 1, 0, (struct sockaddr *) &other, sizeof(other));
printf("%s sendto: expected EISCONN, got %d: connected socket accepted it\n",
n < 0 && errno == EISCONN ? "PASS" : "FAIL", (int) n);
// sendto() reports success before this socket has learned a destination MAC.
go(control);
if (recv(control, buf, sizeof(buf), 0) < 0) goto done;
n = sendto(out, "lost", 4, 0, (struct sockaddr *) &control_peer,
sizeof(control_peer));
printf("%s sendto: expected delivery, got %d: no resolution\n",
n == 4 ? "FAIL" : "PASS", (int) n);
if (recv(control, buf, sizeof(buf), 0) < 0) goto done; // Peer reports miss
// sendto() changes c->rem, so send() incorrectly succeeds on this socket.
go(control);
if (recvfrom(out, buf, sizeof(buf), 0, NULL, NULL) < 0) goto done;
n = sendto(out, s_cpq_remote ? "stale" : "sendto", s_cpq_remote ? 5 : 6,
0, (struct sockaddr *) &control_peer, sizeof(control_peer));
printf("sendto after RX: got %d\n", (int) n);
if (s_cpq_remote) go(control); // Server checks its packet used helper's MAC
n = send(out, "send", 4, 0);
printf("%s send: expected EDESTADDRREQ, got %d: sendto set peer\n",
n < 0 && errno == EDESTADDRREQ ? "PASS" : "FAIL", (int) n);
done:
if (data >= 0) close(data);
if (control >= 0) close(control);
if (out >= 0) close(out);
if (connected >= 0) close(connected);
s_cpq_done = true;
vTaskDelete(NULL);
}
+218
View File
@@ -0,0 +1,218 @@
#include <arpa/inet.h>
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>
#define DATA_PORT 1234
#define CONTROL_PORT 1235
#define SEND_PORT 1236
#define CONTROL_PEER_PORT 14000
#define PEER_A_PORT 14001
#define PEER_B_PORT 14002
#define HELPER_PORT 14003
static int open_peer(unsigned port) {
struct sockaddr_in sa;
struct timeval timeout = {1, 0};
int fd = socket(AF_INET, SOCK_DGRAM, 0);
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = htonl(INADDR_ANY);
sa.sin_port = htons((uint16_t) port);
if (fd < 0 || bind(fd, (struct sockaddr *) &sa, sizeof(sa)) != 0 ||
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) != 0)
return -1;
return fd;
}
static int make_peer(struct sockaddr_in *sa, const char *ip, unsigned port) {
memset(sa, 0, sizeof(*sa));
sa->sin_family = AF_INET;
sa->sin_port = htons((uint16_t) port);
return inet_pton(AF_INET, ip, &sa->sin_addr) == 1 ? 0 : -1;
}
static int send_packet(int fd, const struct sockaddr_in *sa, const char *buf,
size_t len) {
return sendto(fd, buf, len, 0, (const struct sockaddr *) sa, sizeof(*sa)) ==
(ssize_t) len
? 0
: -1;
}
static int wait_go(int fd, const char *step) {
char buf[8];
int n = recv(fd, buf, sizeof(buf), 0);
if (n == 2 && memcmp(buf, "go", 2) == 0) return 0;
printf("peer: %s failed: %d\n", step, n);
return -1;
}
static void stale_packet(void) {
printf("TRACE stale MAC: Server received packet despite wrong L2 address\n");
}
static int wait_stale_go(int fd) {
char buf[8];
int n, stale = 0;
for (;;) {
n = recv(fd, buf, sizeof(buf), 0);
if (n == 5 && memcmp(buf, "stale", 5) == 0) {
stale = 1;
stale_packet();
} else if (n == 2 && memcmp(buf, "go", 2) == 0) {
if (stale) return 0;
n = recv(fd, buf, sizeof(buf), 0);
if (n == 5 && memcmp(buf, "stale", 5) == 0)
stale_packet();
else
printf("FAIL stale MAC: expected packet, got none\n");
return 0;
} else {
printf("peer: stale MAC handoff failed: %d\n", n);
return -1;
}
}
}
static int wait_connect(int fd, struct sockaddr_in *peer) {
char buf[8];
socklen_t len = sizeof(*peer);
return recv(fd, buf, sizeof(buf), 0) == 7 && memcmp(buf, "connect", 7) == 0 &&
recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *) peer, &len) == 5 &&
memcmp(buf, "hello", 5) == 0
? 0
: -1;
}
static int wait_helper(int fd, struct sockaddr_in *peer) {
char buf[8];
socklen_t len = sizeof(*peer);
ssize_t n;
while ((n = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *) peer,
&len)) < 0)
len = sizeof(*peer);
return n == 5 && memcmp(buf, "ready", 5) == 0 ? 0 : -1;
}
static int run_helper(const char *server_ip, const char *target_ip) {
struct sockaddr_in server, target;
char buf[32];
unsigned port;
int fd, n;
if (make_peer(&server, server_ip, HELPER_PORT) != 0 ||
make_peer(&target, target_ip, 0) != 0 || (fd = open_peer(0)) < 0)
return 1;
for (;;) {
if (send_packet(fd, &server, "ready", 5) != 0) break;
n = recv(fd, buf, sizeof(buf) - 1, 0);
if (n <= 0) continue; // Retry ready until the Server receives it
buf[n] = '\0';
if (sscanf(buf, "intrude %u", &port) == 1 && port < 65536) {
target.sin_port = htons((uint16_t) port);
if (send_packet(fd, &target, "intruder", 8) != 0) break;
} else if (strcmp(buf, "prime") == 0) {
target.sin_port = htons(SEND_PORT);
if (send_packet(fd, &target, "prime", 5) != 0) break;
return 0;
} else if (strcmp(buf, "reply") == 0) {
printf("FAIL connected peer: helper received reply\n");
}
}
close(fd);
return 1;
}
static int run_peer(const char *target_ip, int remote) {
struct sockaddr_in data, control, out, peer, helper_peer;
char buf[32], cmd[32];
int a, b, ctl, helper = -1;
ssize_t n;
if (make_peer(&data, target_ip, DATA_PORT) != 0) return 1;
control = data, out = data;
control.sin_port = htons(CONTROL_PORT);
out.sin_port = htons(SEND_PORT);
ctl = open_peer(CONTROL_PEER_PORT);
a = open_peer(PEER_A_PORT);
b = open_peer(PEER_B_PORT);
if (remote) helper = open_peer(HELPER_PORT);
if (ctl < 0 || a < 0 || b < 0 || (remote && helper < 0)) return 1;
if (remote && wait_helper(helper, &helper_peer) != 0) return 1;
if (remote) printf("peer: helper ready\n");
if (send_packet(ctl, &control, "ready", 5) != 0 ||
wait_go(ctl, "initial go") != 0)
return 1;
if (send_packet(a, &data, "one", 3) != 0 ||
send_packet(b, &data, "two", 3) != 0 ||
wait_go(ctl, "two datagrams") != 0)
return 1;
if (send_packet(b, &data, "ABCDE", 5) != 0 ||
wait_go(ctl, "short datagram") != 0)
return 1;
if (send_packet(b, &data, "", 0) != 0 || wait_connect(ctl, &peer) != 0) {
printf("peer: connect handshake failed\n");
return 1;
}
if (remote) {
snprintf(cmd, sizeof(cmd), "intrude %u", (unsigned) ntohs(peer.sin_port));
if (send_packet(helper, &helper_peer, cmd, strlen(cmd)) != 0) return 1;
} else if (send_packet(b, &peer, "intruder", 8) != 0) {
return 1;
}
n = recv(ctl, buf, sizeof(buf), 0);
printf("%s reply: expected control, got %s: intruder replaced peer\n",
n < 0 ? "FAIL" : "PASS", n < 0 ? "none" : "control");
if (!remote) {
n = recv(b, buf, sizeof(buf), 0);
printf("%s reply: intruder got %.*s\n", n > 0 ? "FAIL" : "PASS",
(int) (n > 0 ? n : 0), buf);
}
if (send_packet(ctl, &control, "done", 4) != 0 ||
wait_go(ctl, "first sendto") != 0 ||
send_packet(ctl, &control, "sendlost", 8) != 0)
return 1;
n = recv(ctl, buf, sizeof(buf), 0);
printf("%s sendto: expected packet, got %s\n", n < 0 ? "FAIL" : "PASS",
n < 0 ? "none" : "packet");
if (send_packet(ctl, &control, "miss", 4) != 0 ||
wait_go(ctl, "prime") != 0)
return 1;
if (remote) {
if (send_packet(helper, &helper_peer, "prime", 5) != 0 ||
wait_stale_go(ctl) != 0)
return 1;
} else {
if (send_packet(ctl, &out, "prime", 5) != 0) return 1;
n = recv(ctl, buf, sizeof(buf), 0);
printf("sendto after RX: %.*s\n", (int) (n > 0 ? n : 0), buf);
n = recv(ctl, buf, sizeof(buf), 0);
printf("%s send: expected none, got %.*s\n", n > 0 ? "FAIL" : "PASS",
(int) (n > 0 ? n : 0), buf);
}
close(a);
close(b);
close(ctl);
if (helper >= 0) close(helper);
return 0;
}
int main(int argc, char *argv[]) {
if (argc == 2) return run_peer(argv[1], 0);
if (argc == 3 && strcmp(argv[1], "--remote") == 0)
return run_peer(argv[2], 1);
if (argc == 4 && strcmp(argv[1], "--helper") == 0)
return run_helper(argv[2], argv[3]);
return 1;
}
+14
View File
@@ -0,0 +1,14 @@
.DEFAULT_GOAL := cpq_udp
include Makefile
.PHONY: cpq_udp bsd_cpq_test bsd_udp_cpq_peer
cpq_udp: shm_tap_bridge bsd_cpq_test bsd_udp_cpq_peer
sh -c 'TRACE_UDP=1 ./shm_tap_bridge & pid=$$!; sleep 1; timeout 30s ./bsd_cpq_test; rc=$$?; kill $$pid >/dev/null 2>&1; wait $$pid >/dev/null 2>&1; exit $$rc'
bsd_cpq_test: CFLAGS_MONGOOSE += -DMG_ENABLE_FREERTOS=1 -DCPQ_TEST
bsd_cpq_test: FreeRTOS-Kernel bsd_cpq_test.c bsd_udp_cpq_fail.c bsd_shm_test.c
$(CC) $(C_INPUTS) $(FREERTOS_INPUTS) -x c bsd_shm_test.c $(CFLAGS) $(CFLAGS_MONGOOSE) $(CFLAGS_EXTRA) -o $@
bsd_udp_cpq_peer: bsd_udp_cpq_peer.c
$(CC) bsd_udp_cpq_peer.c -o $@
+11
View File
@@ -18,6 +18,15 @@
#include "shm_queue.h"
static volatile sig_atomic_t s_signo;
static int s_trace_udp;
static void trace_udp(const uint8_t *p, size_t len) {
if (!s_trace_udp || len < 34 || p[12] != 8 || p[13] != 0 || p[23] != 17)
return;
printf("UDP IP dst %u.%u.%u.%u -> Ethernet dst %02x:%02x:%02x:%02x:%02x:%02x\n",
p[30], p[31], p[32], p[33], p[0], p[1], p[2], p[3], p[4], p[5]);
}
void signal_handler(int signo) {
s_signo = signo;
}
@@ -58,6 +67,7 @@ int main(void) {
}
memset(shm, 0, sizeof(*shm));
s_trace_udp = getenv("TRACE_UDP") != NULL;
printf("Opened shared memory: %s\n", SHM_NAME);
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
@@ -94,6 +104,7 @@ int main(void) {
uint8_t buf[FRAME_SIZE];
size_t n = shm_queue_pop(&shm->to_tap, buf, sizeof(buf));
if (n > 0) {
trace_udp(buf, n);
// printf("Got at SHM: %d bytes\n", (int) f->len);
write(fd, buf, n);
// printf("Sent to TAP\n");
+457
View File
@@ -0,0 +1,457 @@
# UDP CPQ Patch Assessment
## Scope
This assesses the CPQ patch applied to `master`, with only this receive-side
change:
```c
if (c->is_bsd && c->recv.len > 0) return true;
```
It deliberately does not require the bsdudp TX framing, peer filtering, or
neighbor-cache work. The rule keeps the first unread nonempty datagram and
discards later ones.
## What The CPQ Patch Provides
When two nonempty UDP datagrams arrive before a BSD application calls
`recv()` or `recvfrom()`, the first remains in `c->recv` and later packets are
discarded. Therefore the first payload is no longer concatenated with the
second one, and its source address remains in `c->rem` until it is read.
That is a valid deliberately lossy receive policy. It only addresses this one
case. The rest of the odd/incorrect behaviors found when initially writing code in the bsdudp branch are detailed in subsequent paragraphs. The rest of the missing functionality also observed before is NOT described here, only what is claimed to be functional is evaluated; these are somehow enumerated at the end of this document, just before the appendixes
See [B.1](#b1-cpq-unread-datagram-policy) for the test evidence.
## Rate Limit Of The One-Datagram Policy
The retained datagram is a one-slot loss queue: while the BSD application has
not called `recv()` or `recvfrom()`, every later nonempty datagram is dropped.
If the application needs 4 ms to read it, independent traffic has these
approximate collision probabilities:
| Aggregate UDP rate | Probability of another datagram within 4 ms |
| ---: | ---: |
| 25 packets/s | 9.5% |
| 50 packets/s | 18.1% |
| 100 packets/s | 33.0% |
| 250 packets/s | 63.2% |
| 1000 packets/s | 98.2% |
This is basic queueing theory under an independent-arrivals assumption. See
[Appendix A](#appendix-a-one-slot-queue-model) for the model and limits of the
estimate.
## Baseline Failures
`bsd_udp_cpq_fail.c` and `bsd_udp_cpq_peer.c` print the wire-level effects for
short receives, empty datagrams, connected peers, and `sendto()`.
The target runs Mongoose's built-in TCP/IP stack. A bridge connects its packet
interface to the LAN because this path cannot use BSD sockets: BSD is the API
being tested.
The default runner is self-contained for CI: it starts the peer on the same
host (Workstation) and exercises every failure except a mismatched Ethernet destination. To
show that L2 failure, run the primary peer on a second machine (Laptop):
```text
Laptop: ./bsd_udp_cpq_peer --remote <Mongoose-IP>
Workstation: CPQ_REMOTE_PEER=<Laptop-IP> ./bsd_cpq_test
```
Remote mode starts a Workstation helper automatically. The Laptop and helper
have distinct MAC addresses. The helper first redirects a connected-socket
reply, then populates the unconnected `sendto()` socket with its MAC. The
following `sendto()` names the Laptop IP, but `TRACE_UDP=1` shows the helper's
Ethernet destination. The evidence below was collected with Workstation IP
forwarding disabled, so the Laptop cannot receive a frame addressed to the
helper MAC.
### Short `recvfrom()` turns one datagram into two reads
The CPQ code removes only the copied byte count from `c->recv`. Reading two
bytes of `ABCDE` leaves `CDE` in the buffer, so the next `recvfrom()` returns
it as if it were a new UDP datagram. UDP must discard the unread tail of a
datagram after a non-peek short receive. Dropping later packets does not repair
this: the tail is already in the retained packet.
See [B.2](#b2-short-recvfrom) for the test evidence.
### A connected UDP socket accepts traffic from any sender
`rx_udp()` overwrites `c->rem` and the return L2 address for every accepted
packet. It does not check that an incoming peer matches the peer selected by
`connect()`. An unrelated sender can therefore place data in a connected
socket and replace its reply destination. The demonstrator sends `intruder`
from a third peer: the connected receive succeeds when it should return
`EAGAIN`, and the subsequent `send()` goes to the intruder rather than the
connected peer.
See [B.3](#b3-connected-udp-accepts-another-peer) for the test evidence.
### Unconnected `send()` reports success
`bsd_dispatch(BSD_OP_SEND)` passes UDP bytes to `mg_send()` without checking
whether the socket has a peer. A real UDP socket has nowhere to send in this
state and reports `EDESTADDRREQ`. Here, the API reports that the datagram was
accepted even though it has no valid destination.
See [B.4](#b4-unconnected-send) for the test evidence.
### `sendto()` uses one stale L2 destination
`BSD_OP_SENDTO` changes the destination IP and UDP port in `c->rem`, but calls
`mg_send()` with the one L2 MAC currently stored for the socket. That MAC was
learned when a packet arrived, or while a UDP `connect()` resolved its peer;
there is no resolution or MAC lookup for each `sendto()` destination. An
application using `sendto()` for several peers therefore has one usable L2
destination, not one per peer.
- A single-destination application can appear to work: its only peer is the
one that caused the MAC to be learned. This is likely the tested case.
- Sending to another local-LAN host changes the IP address but keeps that first
host's MAC. The Ethernet frame reaches the first host, which drops it
because its IP destination names the second host. `sendto()` still reports
success.
- Several off-link destinations can also appear to work if the stored MAC is
the common router MAC. The router is the correct L2 next hop for all of
them. This does not make the socket generally correct.
- A socket that has neither received a datagram nor been connected has no
usable destination MAC. Its first proactive `sendto()` reports success but
cannot be delivered correctly.
Receiving an unrelated datagram can also break a destination that was working.
For example, A sends to this UDP port, so the socket stores A's MAC and a
later `sendto(A)` works. B then sends any datagram to the same port.
`rx_udp()` replaces the stored MAC with B's. The next `sendto(A)` still names
A in the IP header, but addresses the Ethernet frame to B; A no longer gets
it. The same overwrite occurs after UDP `connect()`, because the CPQ code does
not filter non-peer senders. Remote traffic through the same router can hide
this again because its Ethernet source MAC remains the router's MAC.
The two-host remote test covers both cases: [B.5](#b5-first-unconnected-sendto)
shows the first `sendto()` without an L2 address, and
[B.6](#b6-sendto-corrupts-later-sends-and-uses-a-stale-mac) shows a Laptop IP
sent with the helper MAC. Two sockets on one Linux host are not sufficient for
the latter because they share one NIC MAC. The bridge prints each outgoing UDP
IP destination beside its Ethernet destination MAC, independently confirming
the wrong L2 destination.
(In branch bsdudp, we fixed this by using a framing transporting TX records between the BSD side and the Mongoose side; a correct `sendto()` must wait
for ARP resolution without losing that destination, so those records/frames are queued at the send buffer and the extraction then can decide whether to start an ARP, thing that is minimized with a small cache-like table holding 4 entries)
See [B.5](#b5-first-unconnected-sendto) and
[B.6](#b6-sendto-corrupts-later-sends-and-uses-a-stale-mac) for the test
evidence.
### `sendto()` changes the meaning of later `send()` calls
The same direct update makes an unconnected socket look connected after a
`sendto()`. A later `send()` succeeds and uses the previous `sendto()` target,
although BSD requires `EDESTADDRREQ` until `connect()` selects a peer. It is
state corruption from the application's point of view: an operation intended
to name one datagram's destination changes the socket's default destination.
See [B.6](#b6-sendto-corrupts-later-sends-and-uses-a-stale-mac) for the test
evidence.
### `bind()` followed by UDP `connect()` loses the bound port
`mg_connect_resolved()` assigns an ephemeral local port unconditionally.
Calling `connect()` on a UDP socket already bound to a specific port replaces
that port. This is independent of receive buffering; the local identity used
by replies changes after `connect()`.
See [B.7](#b7-bind-followed-by-udp-connect) for the test evidence.
### `sendto()` on a connected UDP socket reports success
A connected UDP socket already has a selected peer. `sendto()` must fail with
`EISCONN`, but the CPQ implementation accepts it and changes that peer.
See [B.8](#b8-sendto-on-a-connected-udp-socket) for the test evidence.
### Oversized UDP writes report success after truncation
The CPQ code passes an oversized payload through `mg_send()`. The built-in UDP
path trims to its payload capacity and transmits only that prefix. BSD callers
are told that the whole datagram was sent. A UDP datagram must be sent whole
or fail; partial transmission is not meaningful.
See [B.9](#b9-oversized-udp-write) for the test evidence.
### Empty datagrams disappear
An empty UDP datagram does not increase `c->recv.len`. No later `recv()` can
distinguish it from no packet, so it returns `EAGAIN` or blocks instead of
returning zero. The proposed condition is also false for an empty retained
datagram, so it cannot represent or protect one.
Yes, it has been agreed that is a known and accepted behavior.
For completeness, see [B.10](#b10-empty-datagram) for the test evidence.
## bsdudp Branch Fixes and Additions
These are additional capabilities, not prerequisites for the one-datagram
drop policy above:
- RX drops the complete retained datagram after a short non-peek read.
- RX filters packets from non-peer senders on connected UDP sockets.
- TX records carry each UDP destination, so queued `sendto()` calls retain
their individual targets.
- TX triggers and reuses L2 resolution for `sendto()` destinations.
- Unconnected `send()` returns `EDESTADDRREQ`; connected UDP `sendto()`
returns `EISCONN`.
- `bind()` followed by UDP `connect()` keeps the selected local port.
- BSD writes reject oversized datagrams with `EMSGSIZE` before queuing them.
Empty UDP receives still require an explicit marker or framing record and are
not solved by either the CPQ patch or the current bsdudp simplification.
## Appendix A: One-Slot Queue Model
Let `D` be the time from receiving a datagram until the BSD application reads
it. Let `N` peers each send at `r` packets/s, so the aggregate arrival rate is
`lambda = N * r`. For independent arrivals approximated as a Poisson process,
the probability that at least one later datagram arrives during the unread
window is:
```text
P(collision) = 1 - exp(-lambda * D)
```
The table above uses `D = 4 ms`. It is a collision probability, not a precise
packet-loss percentage: the latter also depends on the scheduler and on when
the application calls `recv()`.
For evenly spaced periodic traffic, the aggregate packet spacing must be at
least `D` to avoid drops. Therefore each of `N` equal-rate peers needs a period
of at least `N * D`: with `D = 4 ms`, 10 peers need at least 40 ms per packet
per peer, while 100 peers need at least 400 ms.
## Appendix B: Two-Host Test Evidence
This run used Mongoose at `192.168.69.231`, the Laptop at
`192.168.69.73`, and a Workstation helper at `192.168.69.11`. The Laptop MAC
learned for normal control traffic was `3c:0a:f3:8c:ce:ef`; the helper MAC was
`06:3f:ad:7e:3f:1c`. Startup and
DHCP are omitted below.
### B.1 CPQ unread-datagram policy
**Test.** Two peers send `one` and `two` before the application reads port
`1234`.
**Expected.** The CPQ rule retains `one` and drops `two`.
**Observed.**
```text
Workstation: PASS drop: kept one, dropped two
Laptop: no separate observation
Bridge: no separate observation
```
**Internal reason.** `rx_udp()` returns once a BSD connection has a nonempty
`c->recv`. It is a one-datagram loss queue, not a UDP receive queue.
### B.2 Short `recvfrom()`
**Test.** A peer sends one five-byte datagram, `ABCDE`. The application first
reads two bytes, then reads again.
**Expected.** The first call returns `AB`; UDP discards the unread `CDE` tail.
The second call returns `EAGAIN` until another datagram arrives.
**Observed.**
```text
Workstation: FAIL short: expected EAGAIN, got 3 "CDE": tail retained
Laptop: sent ABCDE
Bridge: no separate observation
```
**Internal reason.** `BSD_OP_RECVFROM` removes only the copied byte count from
the stream-shaped `c->recv` iobuf. It has no record length to discard the rest
of the datagram.
### B.3 Connected UDP accepts another peer
**Test.** The socket connects to the Laptop. The Workstation helper then sends
`intruder` to that connected socket.
**Expected.** The helper datagram is ignored. A following `send()` still goes
to the Laptop.
**Observed.**
```text
Workstation: FAIL peer: expected EAGAIN, got 8 "intruder": no peer filter
Mongoose: mg_connect_ 7 192.168.69.231:64103 -> 192.168.69.73:14000
Mongoose: mg_connect_ 7 ARP lookup...
Mongoose: rx_arp 7 ARP resolved 192.168.69.73 -> 3c:0a:f3:8c:ce:ef
Workstation: reply: sent 5 bytes; peer reports its destination below
Laptop: FAIL reply: expected control, got none: intruder replaced peer
Helper: FAIL connected peer: helper received reply
Bridge: UDP IP dst 192.168.69.11 -> Ethernet dst 06:3f:ad:7e:3f:1c
```
**Internal reason.** `mg_connect_resolved()` correctly starts an ARP lookup for
the configured Laptop peer and stores its MAC. `rx_udp()` then accepts every
sender matching the local port. Before the BSD read runs, it overwrites
`c->rem` and the connection return MAC with the helper's source. The later
`send()` therefore replies to the helper instead of the peer that was resolved
at `connect()` time.
### B.4 Unconnected `send()`
**Test.** Send one byte on a bound UDP socket that has never called
`connect()` or `sendto()`.
**Expected.** `send()` fails with `EDESTADDRREQ`: there is no peer.
**Observed.**
```text
Workstation: FAIL send: expected EDESTADDRREQ, got 1: no peer check
Laptop: no packet expected
Bridge: UDP IP dst 0.0.0.0 -> Ethernet dst 00:00:00:00:00:00
```
**Internal reason.** `BSD_OP_SEND` calls `mg_send()` without checking whether
the UDP socket has a selected peer. The zeroed remote address reaches the L2
transmit path.
### B.5 First unconnected `sendto()`
**Test.** Call `sendto()` to the Laptop before this socket has received any
packet or connected to a peer.
**Expected.** The implementation resolves the Laptop L2 address, waits if
needed, then delivers the datagram.
**Observed.**
```text
Workstation: FAIL sendto: expected delivery, got 4: no resolution
Laptop: FAIL sendto: expected packet, got none
Bridge: UDP IP dst 192.168.69.73 -> Ethernet dst 00:00:00:00:00:00
```
**Internal reason.** `BSD_OP_SENDTO` replaces only `c->rem` and immediately
calls `mg_send()`. Unlike the preceding `connect()` cases, this operation
produces no `mg_connect_ ... ARP lookup...` or `rx_arp ... ARP resolved ...`
log for the Laptop destination. It neither performs ARP/L2 resolution nor
retains the destination while resolution would be pending. The zero Ethernet
destination in the bridge trace is the direct result.
### B.6 `sendto()` corrupts later sends and uses a stale MAC
**Test.** The helper sends a datagram to the unconnected socket, establishing
the helper MAC. The application then calls `sendto()` to the Laptop and, after
that, calls `send()` on the same socket.
**Expected.** `sendto()` sends to the Laptop MAC without changing the socket's
default peer. The later `send()` fails with `EDESTADDRREQ`.
**Observed.**
```text
Workstation: sendto after RX: got 5
Workstation: FAIL send: expected EDESTADDRREQ, got 4: sendto set peer
Laptop: FAIL stale MAC: expected packet, got none
Bridge: UDP IP dst 192.168.69.73 -> Ethernet dst 3c:0a:f3:8c:ce:ef
Bridge: UDP IP dst 192.168.69.73 -> Ethernet dst 06:3f:ad:7e:3f:1c
```
The first bridge line is normal Laptop control traffic. The second names the
same Laptop IP but uses the helper MAC. The Laptop receives no packet.
**Internal reason.** The implementation keeps only one mutable `c->rem` and
one return MAC per Mongoose UDP connection. Receiving the helper datagram
updates that one MAC to `06:3f:ad:7e:3f:1c`. `sendto()` overwrites `c->rem`,
but does not start an ARP lookup for the Laptop and therefore retains the
helper MAC. There is no `mg_connect_ ... ARP lookup...` or `rx_arp ... ARP
resolved ...` sequence between this `sendto()` and the second bridge line. No
per-datagram destination record or neighbor cache exists.
### B.7 `bind()` followed by UDP `connect()`
**Test.** Bind local port `1238`, then connect to the Laptop and query the
local address.
**Expected.** The socket remains bound to `1238`.
**Observed.**
```text
Workstation: FAIL bind: expected 1238, got 64102: connect replaced bind
Mongoose: mg_connect_ 5 192.168.69.231:64102 -> 192.168.69.73:14000
Mongoose: mg_connect_ 5 ARP lookup...
Mongoose: rx_arp 5 ARP resolved 192.168.69.73 -> 3c:0a:f3:8c:ce:ef
Laptop: normal ARP/control peer
```
**Internal reason.** `mg_connect_resolved()` assigns an ephemeral local port
without preserving the BSD socket's existing bind state.
### B.8 `sendto()` on a connected UDP socket
**Test.** After UDP `connect()`, call `sendto()` with a different destination.
**Expected.** Fail with `EISCONN`; a connected UDP socket uses `send()`.
**Observed.**
```text
Workstation: FAIL sendto: expected EISCONN, got 1: connected socket accepted it
Laptop: no separate observation
Bridge: no separate observation
```
**Internal reason.** `BSD_OP_SENDTO` has no connected-UDP state check and
blindly replaces the peer address. The connected socket's ARP lookup happened
at `connect()` time in B.3; this operation does not validate that state or
start resolution for its replacement destination.
### B.9 Oversized UDP write
**Test.** Send a 1600-byte datagram.
**Expected.** Fail with `EMSGSIZE`; UDP cannot partially send one datagram.
**Observed.**
```text
Workstation: FAIL oversize: expected EMSGSIZE, got 1600: later truncated
Laptop: no receiving socket in this run
Bridge: no payload-length assertion in this run
```
**Internal reason.** The BSD layer does not reject an over-capacity datagram.
The built-in UDP transmit path later limits payload to its available capacity,
while the BSD caller has already been told all 1600 bytes were accepted.
This run proves the false-success API result. A receiver-side payload-length
assertion would additionally demonstrate the transmitted prefix length.
### B.10 Empty datagram
**Test.** Send a zero-byte UDP datagram, then call `recvfrom()`.
**Expected.** `recvfrom()` returns zero and preserves the source address.
**Observed.**
```text
Workstation: FAIL empty: expected 0, got -1 errno 11: no marker
Laptop: sent a zero-byte datagram
Bridge: no separate observation
```
**Internal reason.** An empty payload does not increase `c->recv.len`; the
stream iobuf cannot distinguish an empty datagram from no pending data.
+1 -1
View File
@@ -1,6 +1,6 @@
PROJECTS ?= $(wildcard ../../tutorials/pico-sdk/*-picosdk-*)
SDK_PATH ?= $(realpath $(PWD))/pico-sdk
SDK_VERSION ?= 2.1.0
SDK_VERSION ?= 2.2.0
all: $(PROJECTS)
echo
+1 -1
View File
@@ -31,5 +31,5 @@ clean:
$(RM) build pico_sdk_import.cmake $(SDK_PATH)
$(SDK_PATH):
git clone -c advice.detachedHead=false --quiet --depth 1 -b 2.1.1 https://github.com/raspberrypi/pico-sdk $@
git clone -c advice.detachedHead=false --quiet --depth 1 -b 2.2.0 https://github.com/raspberrypi/pico-sdk $@
cd $@ && git submodule update --quiet --init
+1 -1
View File
@@ -31,5 +31,5 @@ clean:
$(RM) build pico_sdk_import.cmake $(SDK_PATH)
$(SDK_PATH):
git clone -c advice.detachedHead=false --quiet --depth 1 -b 2.1.1 https://github.com/raspberrypi/pico-sdk $@
git clone -c advice.detachedHead=false --quiet --depth 1 -b 2.2.0 https://github.com/raspberrypi/pico-sdk $@
cd $@ && git submodule update --quiet --init
+1 -1
View File
@@ -19,7 +19,7 @@ net.h: ../../mqtt/mqtt-dashboard/device/net.h
cp $< $@
pico-sdk:
git clone --depth 1 -b 2.1.0 https://github.com/raspberrypi/pico-sdk $@
git clone --depth 1 -b 2.2.0 https://github.com/raspberrypi/pico-sdk $@
cd $@ && git submodule update --init
clean:
+1 -1
View File
@@ -31,5 +31,5 @@ clean:
$(RM) build pico_sdk_import.cmake $(SDK_PATH)
$(SDK_PATH):
git clone -c advice.detachedHead=false --quiet --depth 1 -b 2.1.1 https://github.com/raspberrypi/pico-sdk $@
git clone -c advice.detachedHead=false --quiet --depth 1 -b 2.2.0 https://github.com/raspberrypi/pico-sdk $@
cd $@ && git submodule update --quiet --init
+1 -1
View File
@@ -31,7 +31,7 @@ clean:
$(RM) build pico_sdk_import.cmake $(SDK_PATH)
$(SDK_PATH):
git clone -c advice.detachedHead=false --quiet --depth 1 -b 2.1.1 https://github.com/raspberrypi/pico-sdk $@
git clone -c advice.detachedHead=false --quiet --depth 1 -b 2.2.0 https://github.com/raspberrypi/pico-sdk $@
cd $@ && git submodule update --quiet --init
# Automated remote test. Requires env variable VCON_API_KEY set. See https://vcon.io/automated-firmware-tests/
+1 -1
View File
@@ -31,7 +31,7 @@ clean:
$(RM) build pico_sdk_import.cmake $(SDK_PATH)
$(SDK_PATH):
git clone -c advice.detachedHead=false --quiet --depth 1 -b 2.1.1 https://github.com/raspberrypi/pico-sdk $@
git clone -c advice.detachedHead=false --quiet --depth 1 -b 2.2.0 https://github.com/raspberrypi/pico-sdk $@
cd $@ && git submodule update --quiet --init
# Automated remote test. Requires env variable VCON_API_KEY set. See https://vcon.io/automated-firmware-tests/