From 091404842468b6a83b18f757ff2070426a396b5f Mon Sep 17 00:00:00 2001 From: "Sergio R. Caprile" Date: Thu, 19 Nov 2026 18:37:41 -0300 Subject: [PATCH] Add improved datagram support for BSD --- mongoose.c | 199 ++++++++++---- mongoose.h | 12 + src/bsd.c | 146 +++++++--- src/bsd.h | 12 + src/net_builtin.c | 41 ++- test/bsd/Makefile | 15 +- test/bsd/bsd_udp.c | 60 +++++ test/bsd/bsd_x_test.c | 255 +++++++++++++++++- .../minimal-bsd-baremetal/echo.c | 7 +- 9 files changed, 629 insertions(+), 118 deletions(-) create mode 100644 test/bsd/bsd_udp.c diff --git a/mongoose.c b/mongoose.c index f51fe19a..45e8aaab 100644 --- a/mongoose.c +++ b/mongoose.c @@ -167,6 +167,7 @@ fail: #endif + #include #if MG_ENABLE_BSD_SOCKETS && MG_ENABLE_FREERTOS @@ -298,6 +299,46 @@ static struct mg_connection *bsd_new_conn(struct mg_bsd_sock *s) { return c; } +// Mirror net_builtin.c::trim_len() logic +static bool bsd_udp_too_big(struct mg_connection *c, size_t len) { + struct mg_tcpip_if *ifp = c->mgr->ifp; + size_t hlen = c->rem.is_ip6 ? 48 : 32; // IP plus UDP headers + size_t cap = ifp->mtu - hlen; + size_t room = ifp->tx.len - (ifp->framesize - ifp->l2mtu) - hlen; + + return len > cap || len > room; +} + +static bool bsd_udp_queue(struct mg_connection *c, const void *buf, + size_t len) { + // One raw datagram occupies c->send until write_conn() drains it. + return mg_iobuf_add(&c->send, c->send.len, buf, len) == len; +} + +static size_t bsd_recv(struct mg_bsd_sock *s, void *buf, size_t len, + int flags, struct sockaddr *src, socklen_t *addrlen) { + struct mg_connection *c = s->c; + size_t n; + + if (!s->is_udp) { + n = c->recv.len < len ? c->recv.len : len; + memcpy(buf, c->recv.buf, n); + if (!(flags & MSG_PEEK)) mg_iobuf_del(&c->recv, 0, n); + } else { + n = c->recv.len < len ? c->recv.len : len; + memcpy(buf, c->recv.buf, n); + if (src != NULL && addrlen != NULL) { + struct sockaddr_in *sa = (struct sockaddr_in *) src; + sa->sin_family = AF_INET; + sa->sin_port = c->rem.port; + sa->sin_addr.s_addr = c->rem.addr.ip4; + *addrlen = sizeof(*sa); + } + if (!(flags & MSG_PEEK)) mg_iobuf_del(&c->recv, 0, c->recv.len); + } + return n; +} + #if MG_ENABLE_FREERTOS // Complete operations blocked on c before Mongoose destroys it. static void bsd_finish_waiters(struct mg_bsd_sock *s, bool error) { @@ -482,9 +523,10 @@ static int bsd_ready(struct mg_bsd_sock *s) { if (s->is_shut_rd || s->c->recv.len > 0 || s->c->is_draining) ready |= BSD_READ; if (s->is_shut_wr) ready |= BSD_ERROR; - if (!s->is_shut_wr && !s->is_udp && !s->c->is_connecting && - !s->c->is_closing && !s->c->is_draining) - ready |= BSD_WRITE; // Established TCP socket + if (!s->is_shut_wr && (s->is_udp || !s->c->is_connecting) && + !s->c->is_closing && !s->c->is_draining && + (!s->is_udp || s->c->send.len == 0)) + ready |= BSD_WRITE; // UDP socket or established TCP socket return ready; } @@ -498,7 +540,7 @@ static void bsd_close(struct mg_bsd_sock *s) { if (t->orphan && t->listener == s) { if (t->c != NULL) { t->c->fn_data = NULL; - mg_close_conn(t->c); + t->c->is_draining = 1; t->c = NULL; } memset(t, 0, sizeof(*t)); // Release orphan @@ -506,7 +548,7 @@ static void bsd_close(struct mg_bsd_sock *s) { } if (s->c != NULL) { s->c->fn_data = NULL; - mg_close_conn(s->c); + s->c->is_draining = 1; s->c = NULL; } memset(s, 0, sizeof(*s)); // Release socket @@ -696,8 +738,8 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { cmd->result = -1, cmd->err = ECONNREFUSED; return true; } - if (!c->is_connecting) { - cmd->result = 0; + if (s->is_udp || !c->is_connecting) { + cmd->result = 0; // UDP may still resolve ARP; TCP waits for SYN/SYN-ACK return true; } if (s->nonblock) { @@ -722,11 +764,8 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { return true; } if (c->recv.len > 0) { - size_t n = cmd->op_recv.len; - if (c->recv.len < n) n = c->recv.len; - memcpy(cmd->op_recv.buf, c->recv.buf, n); - if (!(cmd->op_recv.flags & MSG_PEEK)) mg_iobuf_del(&c->recv, 0, n); - cmd->result = (int) n; + cmd->result = (int) bsd_recv(s, cmd->op_recv.buf, cmd->op_recv.len, + cmd->op_recv.flags, NULL, NULL); return true; } if (s->err != 0) { @@ -750,7 +789,25 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { } else if (s->is_shut_wr || (c = s->c) == NULL || s->err != 0 || c->is_closing || c->is_draining) { cmd->result = -1, cmd->err = EPIPE; - } else if (mg_send(c, cmd->op_send.buf, cmd->op_send.len)) { + } else if (c == NULL || (s->is_udp && !c->is_client)) { + cmd->result = -1, cmd->err = s->is_udp ? EDESTADDRREQ : EPIPE; + } else if (s->is_udp && cmd->op_send.len == 0) { + cmd->result = 0; + } else if (s->is_udp && bsd_udp_too_big(c, cmd->op_send.len)) { + cmd->result = -1, cmd->err = EMSGSIZE; + } else if (s->is_udp && c->send.len > 0) { + if (s->nonblock || (cmd->op_send.flags & MSG_DONTWAIT)) { + cmd->result = -1, cmd->err = EAGAIN; + } else { +#if MG_ENABLE_FREERTOS + return false; // One UDP datagram is pending, wait +#else + cmd->result = -1, cmd->err = EAGAIN; +#endif + } + } else if ((s->is_udp + ? bsd_udp_queue(c, cmd->op_send.buf, cmd->op_send.len) + : mg_send(c, cmd->op_send.buf, cmd->op_send.len))) { cmd->result = (int) cmd->op_send.len; } else if (s->nonblock || (cmd->op_send.flags & MSG_DONTWAIT)) { cmd->result = -1, cmd->err = EAGAIN; @@ -767,25 +824,49 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { if ((s = bsd_get(cmd->op_sendto.fd)) == NULL) { cmd->result = -1, cmd->err = EBADF; + } else if (!s->is_udp) { + cmd->result = -1, cmd->err = EOPNOTSUPP; } else if ((err = bsd_addr4(cmd->op_sendto.addr, cmd->op_sendto.addrlen)) != 0) { cmd->result = -1, cmd->err = err; } else if (s->is_shut_wr || (c = s->c) == NULL || s->err != 0 || c->is_closing || c->is_draining) { cmd->result = -1, cmd->err = EPIPE; + } else if (c->is_client) { + cmd->result = -1, cmd->err = EISCONN; } else { const struct sockaddr_in *sa = (const struct sockaddr_in *) cmd->op_sendto.addr; - c->rem.port = sa->sin_port; - c->rem.addr.ip4 = sa->sin_addr.s_addr; - c->rem.is_ip6 = false; - if (mg_send(c, cmd->op_sendto.buf, cmd->op_sendto.len)) { - cmd->result = (int) cmd->op_sendto.len; + if (cmd->op_sendto.len == 0) { + cmd->result = 0; + } else if (bsd_udp_too_big(c, cmd->op_sendto.len)) { + cmd->result = -1, cmd->err = EMSGSIZE; + } else if (c->send.len == 0) { + struct mg_addr rem = c->rem; + bool resolve = rem.is_ip6 || rem.addr.ip4 != sa->sin_addr.s_addr; + c->rem.port = sa->sin_port; + c->rem.addr.ip4 = sa->sin_addr.s_addr; + c->rem.is_ip6 = false; + if (bsd_udp_queue(c, cmd->op_sendto.buf, cmd->op_sendto.len)) { + if (resolve) mg_connect_resolved(c); + cmd->result = (int) cmd->op_sendto.len; + } else { + c->rem = rem; + if (s->nonblock || (cmd->op_sendto.flags & MSG_DONTWAIT)) { + cmd->result = -1, cmd->err = EAGAIN; + } else { +#if MG_ENABLE_FREERTOS + return false; // No send buffer space yet, wait +#else + cmd->result = -1, cmd->err = EAGAIN; +#endif + } + } } else if (s->nonblock || (cmd->op_sendto.flags & MSG_DONTWAIT)) { cmd->result = -1, cmd->err = EAGAIN; } else { #if MG_ENABLE_FREERTOS - return false; // No send buffer space yet, wait + return false; // One UDP datagram is pending, wait #else cmd->result = -1, cmd->err = EAGAIN; #endif @@ -797,6 +878,9 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { if ((s = bsd_get(cmd->op_recvfrom.fd)) == NULL) { cmd->result = -1, cmd->err = EBADF; return true; + } else if (!s->is_udp) { + cmd->result = -1, cmd->err = EOPNOTSUPP; + return true; } if (s->is_shut_rd) { cmd->result = 0; @@ -808,25 +892,11 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { return true; } if (c->recv.len > 0) { - size_t n = cmd->op_recvfrom.len; - - if (cmd->op_recvfrom.src != NULL && - (cmd->op_recvfrom.addrlen == NULL || - *cmd->op_recvfrom.addrlen < sizeof(struct sockaddr_in))) { - cmd->result = -1, cmd->err = EINVAL; - return true; - } - if (c->recv.len < n) n = c->recv.len; - memcpy(cmd->op_recvfrom.buf, c->recv.buf, n); - if (!(cmd->op_recvfrom.flags & MSG_PEEK)) mg_iobuf_del(&c->recv, 0, n); - if (cmd->op_recvfrom.src != NULL && cmd->op_recvfrom.addrlen != NULL) { - struct sockaddr_in *sa = (struct sockaddr_in *) cmd->op_recvfrom.src; - sa->sin_family = AF_INET; - sa->sin_port = c->rem.port; - sa->sin_addr.s_addr = c->rem.addr.ip4; - *cmd->op_recvfrom.addrlen = sizeof(*sa); - } - cmd->result = (int) n; + cmd->result = (int) bsd_recv(s, cmd->op_recvfrom.buf, + cmd->op_recvfrom.len, + cmd->op_recvfrom.flags, + cmd->op_recvfrom.src, + cmd->op_recvfrom.addrlen); return true; } if (s->err != 0) { @@ -10900,22 +10970,34 @@ static void proto_error(struct mg_connection *c, bool r, const char *f, ...) { static bool rx_udp(struct mg_tcpip_if *ifp, struct pkt *pkt) { struct mg_connection *c = getpeer(ifp->mgr, pkt, true); struct connstate *s; + struct mg_addr rem; 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; + if (c->is_bsd && !c->is_client && c->send.len > 0) return true; s = (struct connstate *) (c + 1); - c->rem.port = pkt->udp->sport; #if MG_ENABLE_IPV6 if (c->loc.is_ip6) { // matching of v4/v6 to dest is done bt getpeer() if (!udp6csum_ok(pkt->ip6, pkt->udp)) return false; - c->rem.addr.ip6[0] = pkt->ip6->src[0], - c->rem.addr.ip6[1] = pkt->ip6->src[1], c->rem.is_ip6 = true; + if (c->is_bsd && c->is_client && + (c->rem.port != pkt->udp->sport || + !MG_IP6MATCH(c->rem.addr.ip6, pkt->ip6->src))) + return true; + rem.addr.ip6[0] = pkt->ip6->src[0], + rem.addr.ip6[1] = pkt->ip6->src[1], rem.is_ip6 = true; } else #endif { if (!udpcsum_ok(pkt->ip, pkt->udp)) return false; - c->rem.addr.ip4 = pkt->ip->src; + if (c->is_bsd && c->is_client && + (c->rem.port != pkt->udp->sport || c->rem.addr.ip4 != pkt->ip->src)) + return true; + rem.addr.ip4 = pkt->ip->src, rem.is_ip6 = false; } - if ((l2addr = get_return_l2addr(ifp, &c->rem, true, pkt)) == NULL) + rem.port = pkt->udp->sport; + c->rem = rem; + if ((l2addr = get_return_l2addr(ifp, &rem, true, pkt)) == NULL) return false; // safety net for lousy networks memcpy(s->mac, l2addr, sizeof(s->mac)); if (c->recv.len >= MG_MAX_RECV_SIZE) { @@ -12021,20 +12103,25 @@ void mg_connect_resolved(struct mg_connection *c) { s->retransmit = ifp->enable_tcp_retransmit; s->txq.align = MG_TCPIP_TXQ_ALIGN; c->is_resolving = 0; - if (ifp->eport < MG_EPHEMERAL_PORT_BASE) ifp->eport = MG_EPHEMERAL_PORT_BASE; - c->loc.port = mg_htons(ifp->eport++); + if (c->loc.port == 0) { + if (ifp->eport < MG_EPHEMERAL_PORT_BASE) + ifp->eport = MG_EPHEMERAL_PORT_BASE; + c->loc.port = mg_htons(ifp->eport++); + } // otherwise retain an existing bound port #if MG_ENABLE_IPV6 if (c->rem.is_ip6) { - if (c->rem.addr.ip6[0] == ifp->ip6ll[0]) { // same local LAN, use ll + if (c->loc.addr.ip6[0] == 0 && c->loc.addr.ip6[1] == 0 && + c->rem.addr.ip6[0] == ifp->ip6ll[0]) { // same local LAN, use ll c->loc.addr.ip6[0] = ifp->ip6ll[0], c->loc.addr.ip6[1] = ifp->ip6ll[1]; - } else { // use global address + } else if (c->loc.addr.ip6[0] == 0 && c->loc.addr.ip6[1] == 0) { + // Use global address c->loc.addr.ip6[0] = ifp->ip6[0], c->loc.addr.ip6[1] = ifp->ip6[1]; - } + } // otherwise retain an existing bound address c->loc.is_ip6 = true; } else #endif { - c->loc.addr.ip4 = ifp->ip; + if (c->loc.addr.ip4 == 0) c->loc.addr.ip4 = ifp->ip; } MG_DEBUG(("%lu %M -> %M", c->id, mg_print_ip_port, &c->loc, mg_print_ip_port, &c->rem)); @@ -12065,7 +12152,7 @@ void mg_connect_resolved(struct mg_connection *c) { uint32_t rem_ip = c->rem.addr.ip4; if (ifp->ip && MG_IPISLOCAL(ifp, rem_ip) && rem_ip != ifp->gw) { // skip if gw (onstatechange -> ARP) - // If we're in the same LAN, fire an ARP lookup. + // We're in the same LAN, fire an ARP lookup. MG_DEBUG(("%lu ARP lookup...", c->id)); mg_tcpip_arp_request(ifp, rem_ip, NULL); settmout(c, MIP_TTYPE_ARP); @@ -21168,15 +21255,16 @@ void mg_tls_init(struct mg_connection *c, const struct mg_tls_opts *opts) { tls->ca_bundle_der = all_certs; MG_VERBOSE(("%d-cert bundle", cert_count)); } else if (cert_count > 0) { - tls->ca_der.buf = all_certs[0].buf; - tls->ca_der.len = all_certs[0].len; + int i; + tls->ca_der = all_certs[0]; + for (i = 1; i < cert_count; i++) mg_free((void *) all_certs[i].buf); mg_free(all_certs); - } else { // parse again for a possible DER (or a truncated begin string) + } else { // parse again for a possible DER (or a truncated begin string) if (mg_parse_pem(opts->ca, mg_str_s("CERTIFICATE"), &tls->ca_der) < 0) { mg_error(c, "Failed to load CA certificate"); return; } - } // ca_bundle_len != 0 && ca_der.len = 0 => bundle + } // ca_bundle_len != 0 && ca_der.len = 0 => bundle if (!c->is_client) tls->is_twoway = true; // server + CA: two-way auth } @@ -21195,8 +21283,7 @@ void mg_tls_init(struct mg_connection *c, const struct mg_tls_opts *opts) { int cert_count = mg_parse_pem_certs(opts->cert, &all_certs); if (cert_count > 0) { - tls->cert_der.buf = all_certs[0].buf; - tls->cert_der.len = all_certs[0].len; + tls->cert_der = all_certs[0]; if (cert_count > 1) { tls->chain_len = (size_t) cert_count; tls->chain_der = all_certs; diff --git a/mongoose.h b/mongoose.h index ebacb9da..8b47a98a 100644 --- a/mongoose.h +++ b/mongoose.h @@ -5065,6 +5065,18 @@ void mg_bsd_poll(struct mg_mgr *); #ifndef ENOSPC #define ENOSPC 28 #endif +#ifndef EOPNOTSUPP +#define EOPNOTSUPP 95 +#endif +#ifndef EISCONN +#define EISCONN 106 +#endif +#ifndef EDESTADDRREQ +#define EDESTADDRREQ 121 +#endif +#ifndef EMSGSIZE +#define EMSGSIZE 90 +#endif #ifndef EPROTONOSUPPORT #define EPROTONOSUPPORT 93 #endif diff --git a/src/bsd.c b/src/bsd.c index 2b9e272e..2a97b910 100644 --- a/src/bsd.c +++ b/src/bsd.c @@ -1,5 +1,6 @@ #include "bsd.h" #include "dns.h" +#include "util.h" #include #if MG_ENABLE_BSD_SOCKETS && MG_ENABLE_FREERTOS @@ -131,6 +132,46 @@ static struct mg_connection *bsd_new_conn(struct mg_bsd_sock *s) { return c; } +// Mirror net_builtin.c::trim_len() logic +static bool bsd_udp_too_big(struct mg_connection *c, size_t len) { + struct mg_tcpip_if *ifp = c->mgr->ifp; + size_t hlen = c->rem.is_ip6 ? 48 : 32; // IP plus UDP headers + size_t cap = ifp->mtu - hlen; + size_t room = ifp->tx.len - (ifp->framesize - ifp->l2mtu) - hlen; + + return len > cap || len > room; +} + +static bool bsd_udp_queue(struct mg_connection *c, const void *buf, + size_t len) { + // One raw datagram occupies c->send until write_conn() drains it. + return mg_iobuf_add(&c->send, c->send.len, buf, len) == len; +} + +static size_t bsd_recv(struct mg_bsd_sock *s, void *buf, size_t len, + int flags, struct sockaddr *src, socklen_t *addrlen) { + struct mg_connection *c = s->c; + size_t n; + + if (!s->is_udp) { + n = c->recv.len < len ? c->recv.len : len; + memcpy(buf, c->recv.buf, n); + if (!(flags & MSG_PEEK)) mg_iobuf_del(&c->recv, 0, n); + } else { + n = c->recv.len < len ? c->recv.len : len; + memcpy(buf, c->recv.buf, n); + if (src != NULL && addrlen != NULL) { + struct sockaddr_in *sa = (struct sockaddr_in *) src; + sa->sin_family = AF_INET; + sa->sin_port = c->rem.port; + sa->sin_addr.s_addr = c->rem.addr.ip4; + *addrlen = sizeof(*sa); + } + if (!(flags & MSG_PEEK)) mg_iobuf_del(&c->recv, 0, c->recv.len); + } + return n; +} + #if MG_ENABLE_FREERTOS // Complete operations blocked on c before Mongoose destroys it. static void bsd_finish_waiters(struct mg_bsd_sock *s, bool error) { @@ -315,9 +356,10 @@ static int bsd_ready(struct mg_bsd_sock *s) { if (s->is_shut_rd || s->c->recv.len > 0 || s->c->is_draining) ready |= BSD_READ; if (s->is_shut_wr) ready |= BSD_ERROR; - if (!s->is_shut_wr && !s->is_udp && !s->c->is_connecting && - !s->c->is_closing && !s->c->is_draining) - ready |= BSD_WRITE; // Established TCP socket + if (!s->is_shut_wr && (s->is_udp || !s->c->is_connecting) && + !s->c->is_closing && !s->c->is_draining && + (!s->is_udp || s->c->send.len == 0)) + ready |= BSD_WRITE; // UDP socket or established TCP socket return ready; } @@ -331,7 +373,7 @@ static void bsd_close(struct mg_bsd_sock *s) { if (t->orphan && t->listener == s) { if (t->c != NULL) { t->c->fn_data = NULL; - mg_close_conn(t->c); + t->c->is_draining = 1; t->c = NULL; } memset(t, 0, sizeof(*t)); // Release orphan @@ -339,7 +381,7 @@ static void bsd_close(struct mg_bsd_sock *s) { } if (s->c != NULL) { s->c->fn_data = NULL; - mg_close_conn(s->c); + s->c->is_draining = 1; s->c = NULL; } memset(s, 0, sizeof(*s)); // Release socket @@ -529,8 +571,8 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { cmd->result = -1, cmd->err = ECONNREFUSED; return true; } - if (!c->is_connecting) { - cmd->result = 0; + if (s->is_udp || !c->is_connecting) { + cmd->result = 0; // UDP may still resolve ARP; TCP waits for SYN/SYN-ACK return true; } if (s->nonblock) { @@ -555,11 +597,8 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { return true; } if (c->recv.len > 0) { - size_t n = cmd->op_recv.len; - if (c->recv.len < n) n = c->recv.len; - memcpy(cmd->op_recv.buf, c->recv.buf, n); - if (!(cmd->op_recv.flags & MSG_PEEK)) mg_iobuf_del(&c->recv, 0, n); - cmd->result = (int) n; + cmd->result = (int) bsd_recv(s, cmd->op_recv.buf, cmd->op_recv.len, + cmd->op_recv.flags, NULL, NULL); return true; } if (s->err != 0) { @@ -583,7 +622,25 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { } else if (s->is_shut_wr || (c = s->c) == NULL || s->err != 0 || c->is_closing || c->is_draining) { cmd->result = -1, cmd->err = EPIPE; - } else if (mg_send(c, cmd->op_send.buf, cmd->op_send.len)) { + } else if (c == NULL || (s->is_udp && !c->is_client)) { + cmd->result = -1, cmd->err = s->is_udp ? EDESTADDRREQ : EPIPE; + } else if (s->is_udp && cmd->op_send.len == 0) { + cmd->result = 0; + } else if (s->is_udp && bsd_udp_too_big(c, cmd->op_send.len)) { + cmd->result = -1, cmd->err = EMSGSIZE; + } else if (s->is_udp && c->send.len > 0) { + if (s->nonblock || (cmd->op_send.flags & MSG_DONTWAIT)) { + cmd->result = -1, cmd->err = EAGAIN; + } else { +#if MG_ENABLE_FREERTOS + return false; // One UDP datagram is pending, wait +#else + cmd->result = -1, cmd->err = EAGAIN; +#endif + } + } else if ((s->is_udp + ? bsd_udp_queue(c, cmd->op_send.buf, cmd->op_send.len) + : mg_send(c, cmd->op_send.buf, cmd->op_send.len))) { cmd->result = (int) cmd->op_send.len; } else if (s->nonblock || (cmd->op_send.flags & MSG_DONTWAIT)) { cmd->result = -1, cmd->err = EAGAIN; @@ -600,25 +657,49 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { if ((s = bsd_get(cmd->op_sendto.fd)) == NULL) { cmd->result = -1, cmd->err = EBADF; + } else if (!s->is_udp) { + cmd->result = -1, cmd->err = EOPNOTSUPP; } else if ((err = bsd_addr4(cmd->op_sendto.addr, cmd->op_sendto.addrlen)) != 0) { cmd->result = -1, cmd->err = err; } else if (s->is_shut_wr || (c = s->c) == NULL || s->err != 0 || c->is_closing || c->is_draining) { cmd->result = -1, cmd->err = EPIPE; + } else if (c->is_client) { + cmd->result = -1, cmd->err = EISCONN; } else { const struct sockaddr_in *sa = (const struct sockaddr_in *) cmd->op_sendto.addr; - c->rem.port = sa->sin_port; - c->rem.addr.ip4 = sa->sin_addr.s_addr; - c->rem.is_ip6 = false; - if (mg_send(c, cmd->op_sendto.buf, cmd->op_sendto.len)) { - cmd->result = (int) cmd->op_sendto.len; + if (cmd->op_sendto.len == 0) { + cmd->result = 0; + } else if (bsd_udp_too_big(c, cmd->op_sendto.len)) { + cmd->result = -1, cmd->err = EMSGSIZE; + } else if (c->send.len == 0) { + struct mg_addr rem = c->rem; + bool resolve = rem.is_ip6 || rem.addr.ip4 != sa->sin_addr.s_addr; + c->rem.port = sa->sin_port; + c->rem.addr.ip4 = sa->sin_addr.s_addr; + c->rem.is_ip6 = false; + if (bsd_udp_queue(c, cmd->op_sendto.buf, cmd->op_sendto.len)) { + if (resolve) mg_connect_resolved(c); + cmd->result = (int) cmd->op_sendto.len; + } else { + c->rem = rem; + if (s->nonblock || (cmd->op_sendto.flags & MSG_DONTWAIT)) { + cmd->result = -1, cmd->err = EAGAIN; + } else { +#if MG_ENABLE_FREERTOS + return false; // No send buffer space yet, wait +#else + cmd->result = -1, cmd->err = EAGAIN; +#endif + } + } } else if (s->nonblock || (cmd->op_sendto.flags & MSG_DONTWAIT)) { cmd->result = -1, cmd->err = EAGAIN; } else { #if MG_ENABLE_FREERTOS - return false; // No send buffer space yet, wait + return false; // One UDP datagram is pending, wait #else cmd->result = -1, cmd->err = EAGAIN; #endif @@ -630,6 +711,9 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { if ((s = bsd_get(cmd->op_recvfrom.fd)) == NULL) { cmd->result = -1, cmd->err = EBADF; return true; + } else if (!s->is_udp) { + cmd->result = -1, cmd->err = EOPNOTSUPP; + return true; } if (s->is_shut_rd) { cmd->result = 0; @@ -641,25 +725,11 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) { return true; } if (c->recv.len > 0) { - size_t n = cmd->op_recvfrom.len; - - if (cmd->op_recvfrom.src != NULL && - (cmd->op_recvfrom.addrlen == NULL || - *cmd->op_recvfrom.addrlen < sizeof(struct sockaddr_in))) { - cmd->result = -1, cmd->err = EINVAL; - return true; - } - if (c->recv.len < n) n = c->recv.len; - memcpy(cmd->op_recvfrom.buf, c->recv.buf, n); - if (!(cmd->op_recvfrom.flags & MSG_PEEK)) mg_iobuf_del(&c->recv, 0, n); - if (cmd->op_recvfrom.src != NULL && cmd->op_recvfrom.addrlen != NULL) { - struct sockaddr_in *sa = (struct sockaddr_in *) cmd->op_recvfrom.src; - sa->sin_family = AF_INET; - sa->sin_port = c->rem.port; - sa->sin_addr.s_addr = c->rem.addr.ip4; - *cmd->op_recvfrom.addrlen = sizeof(*sa); - } - cmd->result = (int) n; + cmd->result = (int) bsd_recv(s, cmd->op_recvfrom.buf, + cmd->op_recvfrom.len, + cmd->op_recvfrom.flags, + cmd->op_recvfrom.src, + cmd->op_recvfrom.addrlen); return true; } if (s->err != 0) { diff --git a/src/bsd.h b/src/bsd.h index eaeb9621..931ba94f 100644 --- a/src/bsd.h +++ b/src/bsd.h @@ -64,6 +64,18 @@ void mg_bsd_poll(struct mg_mgr *); #ifndef ENOSPC #define ENOSPC 28 #endif +#ifndef EOPNOTSUPP +#define EOPNOTSUPP 95 +#endif +#ifndef EISCONN +#define EISCONN 106 +#endif +#ifndef EDESTADDRREQ +#define EDESTADDRREQ 121 +#endif +#ifndef EMSGSIZE +#define EMSGSIZE 90 +#endif #ifndef EPROTONOSUPPORT #define EPROTONOSUPPORT 93 #endif diff --git a/src/net_builtin.c b/src/net_builtin.c index 9e1a6b73..a6cb363a 100644 --- a/src/net_builtin.c +++ b/src/net_builtin.c @@ -1224,22 +1224,34 @@ static void proto_error(struct mg_connection *c, bool r, const char *f, ...) { static bool rx_udp(struct mg_tcpip_if *ifp, struct pkt *pkt) { struct mg_connection *c = getpeer(ifp->mgr, pkt, true); struct connstate *s; + struct mg_addr rem; 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; + if (c->is_bsd && !c->is_client && c->send.len > 0) return true; s = (struct connstate *) (c + 1); - c->rem.port = pkt->udp->sport; #if MG_ENABLE_IPV6 if (c->loc.is_ip6) { // matching of v4/v6 to dest is done bt getpeer() if (!udp6csum_ok(pkt->ip6, pkt->udp)) return false; - c->rem.addr.ip6[0] = pkt->ip6->src[0], - c->rem.addr.ip6[1] = pkt->ip6->src[1], c->rem.is_ip6 = true; + if (c->is_bsd && c->is_client && + (c->rem.port != pkt->udp->sport || + !MG_IP6MATCH(c->rem.addr.ip6, pkt->ip6->src))) + return true; + rem.addr.ip6[0] = pkt->ip6->src[0], + rem.addr.ip6[1] = pkt->ip6->src[1], rem.is_ip6 = true; } else #endif { if (!udpcsum_ok(pkt->ip, pkt->udp)) return false; - c->rem.addr.ip4 = pkt->ip->src; + if (c->is_bsd && c->is_client && + (c->rem.port != pkt->udp->sport || c->rem.addr.ip4 != pkt->ip->src)) + return true; + rem.addr.ip4 = pkt->ip->src, rem.is_ip6 = false; } - if ((l2addr = get_return_l2addr(ifp, &c->rem, true, pkt)) == NULL) + rem.port = pkt->udp->sport; + c->rem = rem; + if ((l2addr = get_return_l2addr(ifp, &rem, true, pkt)) == NULL) return false; // safety net for lousy networks memcpy(s->mac, l2addr, sizeof(s->mac)); if (c->recv.len >= MG_MAX_RECV_SIZE) { @@ -2345,20 +2357,25 @@ void mg_connect_resolved(struct mg_connection *c) { s->retransmit = ifp->enable_tcp_retransmit; s->txq.align = MG_TCPIP_TXQ_ALIGN; c->is_resolving = 0; - if (ifp->eport < MG_EPHEMERAL_PORT_BASE) ifp->eport = MG_EPHEMERAL_PORT_BASE; - c->loc.port = mg_htons(ifp->eport++); + if (c->loc.port == 0) { + if (ifp->eport < MG_EPHEMERAL_PORT_BASE) + ifp->eport = MG_EPHEMERAL_PORT_BASE; + c->loc.port = mg_htons(ifp->eport++); + } // otherwise retain an existing bound port #if MG_ENABLE_IPV6 if (c->rem.is_ip6) { - if (c->rem.addr.ip6[0] == ifp->ip6ll[0]) { // same local LAN, use ll + if (c->loc.addr.ip6[0] == 0 && c->loc.addr.ip6[1] == 0 && + c->rem.addr.ip6[0] == ifp->ip6ll[0]) { // same local LAN, use ll c->loc.addr.ip6[0] = ifp->ip6ll[0], c->loc.addr.ip6[1] = ifp->ip6ll[1]; - } else { // use global address + } else if (c->loc.addr.ip6[0] == 0 && c->loc.addr.ip6[1] == 0) { + // Use global address c->loc.addr.ip6[0] = ifp->ip6[0], c->loc.addr.ip6[1] = ifp->ip6[1]; - } + } // otherwise retain an existing bound address c->loc.is_ip6 = true; } else #endif { - c->loc.addr.ip4 = ifp->ip; + if (c->loc.addr.ip4 == 0) c->loc.addr.ip4 = ifp->ip; } MG_DEBUG(("%lu %M -> %M", c->id, mg_print_ip_port, &c->loc, mg_print_ip_port, &c->rem)); @@ -2389,7 +2406,7 @@ void mg_connect_resolved(struct mg_connection *c) { uint32_t rem_ip = c->rem.addr.ip4; if (ifp->ip && MG_IPISLOCAL(ifp, rem_ip) && rem_ip != ifp->gw) { // skip if gw (onstatechange -> ARP) - // If we're in the same LAN, fire an ARP lookup. + // We're in the same LAN, fire an ARP lookup. MG_DEBUG(("%lu ARP lookup...", c->id)); mg_tcpip_arp_request(ifp, rem_ip, NULL); settmout(c, MIP_TTYPE_ARP); diff --git a/test/bsd/Makefile b/test/bsd/Makefile index 5740935c..a7dfbf9e 100644 --- a/test/bsd/Makefile +++ b/test/bsd/Makefile @@ -13,7 +13,7 @@ else C_WARN ?= -Wno-deprecated endif -.PHONY: all bsd bsd_test bsd_client bsd_nortos bsd_nortos_test shm_tap_bridge \ +.PHONY: all bsd bsd_test bsd_client bsd_udp bsd_nortos bsd_nortos_test shm_tap_bridge \ shm_port_bridge bsd_s390 bsd_nortos_s390 clean TEST_SOURCES = bsd_shm_test.c @@ -47,11 +47,11 @@ DOCKER ?= $(DOCKER_BIN) run --platform linux/amd64 --net=host --rm $(ENV) -v $(R CFLAGS_MONGOOSE += -DMG_ARCH=MG_ARCH_CUSTOM -all bsd: shm_tap_bridge bsd_client FreeRTOS-Kernel bsd_test +all bsd: shm_tap_bridge bsd_client bsd_udp FreeRTOS-Kernel bsd_test ASAN_OPTIONS=$(ASAN_OPTIONS) $(RUN) ./bsd_test $(ARGS) # also -bsd_nortos: shm_tap_bridge bsd_client bsd_nortos_test +bsd_nortos: shm_tap_bridge bsd_client bsd_udp bsd_nortos_test ASAN_OPTIONS=$(ASAN_OPTIONS) $(RUN) ./bsd_nortos_test $(ARGS) # requires shm_tap_bridge to be running @@ -70,6 +70,9 @@ bsd_nortos_test: bsd_client: bsd_client.c $(CC) bsd_client.c -pthread -o $@ +bsd_udp: bsd_udp.c + $(CC) bsd_udp.c -o $@ + # bridge shm queue <--> TAP interface shm_tap_bridge: shm_tap_bridge.c shm_queue.h $(CC) shm_tap_bridge.c -pthread -o $@ @@ -79,7 +82,7 @@ bsd_s390: CFLAGS_MONGOOSE += -DMG_ENABLE_BSD_PROTOTYPES=0 bsd_s390: ASAN= bsd_s390: CC = $(DOCKER) mdashnet/s390 cc bsd_s390: RUN = $(DOCKER) --init mdashnet/s390 -bsd_s390: shm_port_bridge bsd_client FreeRTOS-Kernel bsd_test +bsd_s390: shm_port_bridge bsd_client bsd_udp FreeRTOS-Kernel bsd_test $(RUN) sh -c './shm_port_bridge & pid=$$!; sleep 1; ./bsd_test; rc=$$?; kill $$pid >/dev/null 2>&1; wait $$pid >/dev/null 2>&1; exit $$rc' #also @@ -87,14 +90,14 @@ bsd_nortos_s390: CFLAGS_MONGOOSE += -DMG_ENABLE_BSD_PROTOTYPES=0 bsd_nortos_s390: ASAN= bsd_nortos_s390: CC = $(DOCKER) mdashnet/s390 cc bsd_nortos_s390: RUN = $(DOCKER) --init mdashnet/s390 -bsd_nortos_s390: shm_port_bridge bsd_client bsd_nortos_test +bsd_nortos_s390: shm_port_bridge bsd_client bsd_udp bsd_nortos_test $(RUN) sh -c './shm_port_bridge & pid=$$!; sleep 1; ./bsd_nortos_test; rc=$$?; kill $$pid >/dev/null 2>&1; wait $$pid >/dev/null 2>&1; exit $$rc' shm_port_bridge: shm_port_bridge.c shm_queue.h $(CC) shm_port_bridge.c $(CFLAGS) -pthread -o $@ clean: # Cleanup. Delete built program and all build artifacts - rm -rf bsd_test bsd_client shm_port_bridge *.o *.obj FreeRTOS-Kernel + rm -rf bsd_test bsd_client bsd_udp shm_port_bridge *.o *.obj FreeRTOS-Kernel FreeRTOS-Kernel: # FreeRTOS sources git clone -q -c advice.detachedHead=false --depth 1 -b V11.2.0 https://github.com/FreeRTOS/FreeRTOS-Kernel $@ diff --git a/test/bsd/bsd_udp.c b/test/bsd/bsd_udp.c new file mode 100644 index 00000000..e251fdad --- /dev/null +++ b/test/bsd/bsd_udp.c @@ -0,0 +1,60 @@ +#include +#include +#include +#include +#include +#include + +#define PORT 1235 + +int main(int argc, char *argv[]) { + struct sockaddr_in sa; + struct timeval timeout; + char buf[8]; + ssize_t n; + int fd, rogue; + + if (argc != 2) return 1; + memset(&sa, 0, sizeof(sa)); + sa.sin_family = AF_INET; + sa.sin_port = htons(PORT); + if (inet_pton(AF_INET, argv[1], &sa.sin_addr) != 1) return 1; + timeout.tv_sec = 5, timeout.tv_usec = 0; + if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 || + setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) != 0 || + connect(fd, (struct sockaddr *) &sa, sizeof(sa)) != 0 || + send(fd, "hello", 5, 0) != 5 || recv(fd, buf, sizeof(buf), 0) != 5 || + memcmp(buf, "ready", 5) != 0) + goto fail; + if ((rogue = socket(AF_INET, SOCK_DGRAM, 0)) < 0 || + setsockopt(rogue, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) != + 0 || + sendto(rogue, "rogueid", 7, 0, (struct sockaddr *) &sa, sizeof(sa)) != + 7 || + recv(fd, buf, sizeof(buf), 0) != 7 || memcmp(buf, "peerone", 7) != 0 || + recv(rogue, buf, sizeof(buf), 0) != 7 || memcmp(buf, "rogueok", 7) != 0 || + send(fd, "one", 3, 0) != 3 || + sendto(rogue, "two2", 4, 0, (struct sockaddr *) &sa, sizeof(sa)) != 4 || + recv(fd, buf, sizeof(buf), 0) != 4 || memcmp(buf, "drop", 4) != 0 || + send(fd, "truncate", 8, 0) != 8 || + recv(fd, buf, sizeof(buf), 0) != 5 || memcmp(buf, "short", 5) != 0 || + send(fd, "peek", 4, 0) != 4 || + recv(fd, buf, sizeof(buf), 0) != 4 || memcmp(buf, "peek", 4) != 0 || + sendto(rogue, "rogue", 5, 0, (struct sockaddr *) &sa, sizeof(sa)) != 5 || + send(fd, "more", 4, 0) != 4 || + recv(fd, buf, sizeof(buf), 0) != 7 || memcmp(buf, "checked", 7) != 0 || + recv(fd, buf, sizeof(buf), 0) != 3 || memcmp(buf, "one", 3) != 0 || + recv(fd, buf, sizeof(buf), 0) != 4 || memcmp(buf, "two2", 4) != 0 || + send(fd, "echo", 4, 0) != 4 || recv(fd, buf, sizeof(buf), 0) != 4 || + memcmp(buf, "echo", 4) != 0) + goto fail_close_rogue; + close(rogue); + close(fd); + return 0; + +fail_close_rogue: + close(rogue); +fail: + close(fd); + return 1; +} diff --git a/test/bsd/bsd_x_test.c b/test/bsd/bsd_x_test.c index dd8ecf3b..f3571873 100644 --- a/test/bsd/bsd_x_test.c +++ b/test/bsd/bsd_x_test.c @@ -33,6 +33,198 @@ static int s_abort = 0; #define DASHBOARD(x) \ printf("HEALTH_DASHBOARD\t\"%s\": %s,\n", x, s_error ? "false" : "true") +#define UDP_PORT 1235 + +#if MG_ENABLE_FREERTOS +static volatile bool s_tx_held, s_tx_waits; +#endif + +static int open_udp(void) { + struct sockaddr_in sa; + char buf; + int fd; + + memset(&sa, 0, sizeof(sa)); + sa.sin_family = AF_INET; + sa.sin_port = htons(UDP_PORT); + sa.sin_addr.s_addr = INADDR_ANY; + ASSERT((fd = socket(AF_INET, SOCK_DGRAM, 0)) >= 0); + ASSERT(bind(fd, (struct sockaddr *) &sa, sizeof(sa)) == 0); + ASSERT(send(fd, &buf, sizeof(buf), 0) < 0 && errno == EDESTADDRREQ); + ASSERT(fcntl(fd, F_SETFL, O_NONBLOCK) == 0); + return fd; +} + +static void check_udp_oversize(struct mg_mgr *mgr, int fd, + const struct sockaddr *dst, socklen_t dstlen) { + static char buf[1600]; + size_t len = mgr->ifp->mtu + 1; + + ASSERT(len <= sizeof(buf)); + if (dst == NULL) { + ASSERT(send(fd, buf, len, 0) < 0 && errno == EMSGSIZE); + } else { + ASSERT(sendto(fd, buf, len, 0, dst, dstlen) < 0 && errno == EMSGSIZE); + } +} + +static void udp_exchange(struct mg_mgr *mgr, int fd, + void (*progress)(struct mg_mgr *)) { + struct sockaddr_in peer, sender; + socklen_t peerlen, senderlen; + uint64_t deadline; + struct timeval zero = {0, 0}; + struct pollfd p; + fd_set r, w, e; + char buf[8]; + ssize_t n; + + for (;;) { + peerlen = sizeof(peer); + n = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *) &peer, &peerlen); + if (n >= 0) break; + ASSERT(errno == EAGAIN); + progress(mgr); + } + ASSERT(n == 5 && memcmp(buf, "hello", 5) == 0); + ASSERT(sendto(fd, "ready", 5, 0, (struct sockaddr *) &peer, peerlen) == + 5); + check_udp_oversize(mgr, fd, (struct sockaddr *) &peer, peerlen); + do { + senderlen = sizeof(sender); + n = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *) &sender, + &senderlen); + if (n < 0) { + ASSERT(errno == EAGAIN); + progress(mgr); + } + } while (n < 0); + ASSERT(n == 7 && memcmp(buf, "rogueid", 7) == 0 && + sender.sin_port != peer.sin_port); +#if MG_ENABLE_FREERTOS + s_tx_waits = false, s_tx_held = true; +#endif + ASSERT(sendto(fd, "peerone", 7, 0, (struct sockaddr *) &peer, peerlen) == + 7); + ASSERT(sendto(fd, "rogueok", 7, 0, (struct sockaddr *) &sender, + senderlen) < 0 && errno == EAGAIN); +#if MG_ENABLE_FREERTOS + while (!s_tx_waits) progress(mgr); // Keep peerone in the UDP slot + s_tx_held = false; +#endif + while ((n = sendto(fd, "rogueok", 7, 0, (struct sockaddr *) &sender, + senderlen)) < 0) { + ASSERT(errno == EAGAIN); + progress(mgr); + } + ASSERT(n == 7); + deadline = mg_millis() + 100; + while (mg_millis() < deadline) progress(mgr); // Queue both; drop the second + do { + senderlen = sizeof(sender); + n = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *) &sender, + &senderlen); + if (n < 0) { + ASSERT(errno == EAGAIN); + progress(mgr); + } + } while (n < 0); + ASSERT(n == 3 && memcmp(buf, "one", 3) == 0 && + sender.sin_port == peer.sin_port); + ASSERT(recvfrom(fd, buf, sizeof(buf), MSG_DONTWAIT, NULL, NULL) < 0 && + errno == EAGAIN); + ASSERT(connect(fd, (struct sockaddr *) &peer, peerlen) == 0); + senderlen = sizeof(sender); + ASSERT(getsockname(fd, (struct sockaddr *) &sender, &senderlen) == 0 && + sender.sin_port == htons(UDP_PORT)); + ASSERT(sendto(fd, "no", 2, 0, (struct sockaddr *) &peer, peerlen) < 0 && + errno == EISCONN); + check_udp_oversize(mgr, fd, NULL, 0); + ASSERT(send(fd, "drop", 4, 0) == 4); + do { + n = recv(fd, buf, 3, 0); + if (n < 0) { + ASSERT(errno == EAGAIN); + progress(mgr); + } + } while (n < 0); + ASSERT(n == 3 && memcmp(buf, "tru", 3) == 0); + ASSERT(recv(fd, buf, sizeof(buf), MSG_DONTWAIT) < 0 && errno == EAGAIN); + ASSERT(send(fd, "short", 5, 0) == 5); + do { + n = recv(fd, buf, sizeof(buf), MSG_PEEK); + if (n < 0) { + ASSERT(errno == EAGAIN); + progress(mgr); + } + } while (n < 0); + ASSERT(n == 4 && memcmp(buf, "peek", 4) == 0); + ASSERT(recv(fd, buf, sizeof(buf), 0) == 4 && memcmp(buf, "peek", 4) == 0); + ASSERT(send(fd, "peek", 4, 0) == 4); + deadline = mg_millis() + 100; + while (mg_millis() < deadline) progress(mgr); // Let rogue arrive; ignore it + do { + p.fd = fd, p.events = POLLIN | POLLOUT, p.revents = 0; + ASSERT(poll(&p, 1, 0) == 1); + if (!(p.revents & POLLIN)) progress(mgr); + } while (!(p.revents & POLLIN)); + ASSERT(p.revents == (POLLIN | POLLOUT)); + FD_ZERO(&r); + FD_ZERO(&w); + FD_ZERO(&e); + FD_SET(fd, &r); + FD_SET(fd, &w); + FD_SET(fd, &e); + ASSERT(select(fd + 1, &r, &w, &e, &zero) == 1); + ASSERT(FD_ISSET(fd, &r) && FD_ISSET(fd, &w) && !FD_ISSET(fd, &e)); + do { + n = recv(fd, buf, sizeof(buf), 0); + if (n < 0) { + ASSERT(errno == EAGAIN); + progress(mgr); + } + } while (n < 0); + ASSERT(n == 4 && memcmp(buf, "more", 4) == 0); + p.events = POLLIN | POLLOUT, p.revents = 0; + ASSERT(poll(&p, 1, 0) == 1 && p.revents == POLLOUT); + while ((n = send(fd, "checked", 7, 0)) < 0) { + ASSERT(errno == EAGAIN); + progress(mgr); + } + ASSERT(n == 7); + while ((n = send(fd, "one", 3, MSG_DONTWAIT)) < 0) { + ASSERT(errno == EAGAIN); + progress(mgr); + } + ASSERT(n == 3); + p.fd = fd, p.events = POLLOUT, p.revents = 0; + ASSERT(poll(&p, 1, 0) == 0 && p.revents == 0); +#if MG_ENABLE_FREERTOS + s_tx_waits = false, s_tx_held = true; +#endif + ASSERT(send(fd, "two2", 4, MSG_DONTWAIT) < 0 && errno == EAGAIN); + ASSERT(send(fd, "", 0, 0) == 0); +#if MG_ENABLE_FREERTOS + while (!s_tx_waits) progress(mgr); // MG_IO_WAIT keeps one datagram queued + s_tx_held = false; +#endif + while ((n = send(fd, "two2", 4, MSG_DONTWAIT)) < 0) { + ASSERT(errno == EAGAIN); + progress(mgr); + } + ASSERT(n == 4); + for (;;) { + n = recv(fd, buf, sizeof(buf), 0); + if (n >= 0) break; + ASSERT(errno == EAGAIN); + progress(mgr); + } + ASSERT(n == 4 && memcmp(buf, "echo", 4) == 0); + ASSERT(send(fd, "echo", 4, 0) == 4); + progress(mgr); // Drain the last queued datagram before close + ASSERT(close(fd) == 0); +} + static pid_t start_client(const char *ip, const char *connections) { char *cmd[4]; pid_t pid; @@ -46,6 +238,18 @@ static pid_t start_client(const char *ip, const char *connections) { return pid; } +static pid_t start_udp(const char *ip) { + char *cmd[3]; + pid_t pid; + extern char **environ; + + cmd[0] = (char *) "./bsd_udp"; + cmd[1] = (char *) ip; + cmd[2] = NULL; + ASSERT(posix_spawn(&pid, cmd[0], NULL, NULL, cmd, environ) == 0); + return pid; +} + static bool client_done(pid_t pid, int *status) { pid_t r = waitpid(pid, status, WNOHANG); ASSERT(r >= 0); @@ -60,12 +264,17 @@ static void check_client(int status) { static int open_listener(int backlog, bool nonblock) { int lfd = socket(AF_INET, SOCK_STREAM, 0); struct sockaddr_in sa; + char buf; memset(&sa, 0, sizeof(sa)); sa.sin_family = AF_INET; sa.sin_port = htons(1234); sa.sin_addr.s_addr = INADDR_ANY; ASSERT(lfd >= 0); + ASSERT(sendto(lfd, &buf, sizeof(buf), 0, (struct sockaddr *) &sa, + sizeof(sa)) < 0 && errno == EOPNOTSUPP); + ASSERT(recvfrom(lfd, &buf, sizeof(buf), 0, NULL, NULL) < 0 && + errno == EOPNOTSUPP); ASSERT(bind(lfd, (struct sockaddr *) &sa, sizeof(sa)) == 0); ASSERT(listen(lfd, backlog) == 0); if (nonblock) ASSERT(fcntl(lfd, F_SETFL, O_NONBLOCK) == 0); @@ -146,12 +355,13 @@ static volatile bool s_select_waiting, s_select_done; static volatile bool s_poll_waiting, s_poll_done; static volatile bool s_ready_waiting, s_ready_done; static volatile bool s_backlog_ready, s_backlog_full, s_backlog_accept; -static volatile bool s_tx_held, s_tx_waits, s_tx_fail, s_tx_error; +static volatile bool s_tx_fail, s_tx_error; static volatile bool s_send_waiting; static volatile bool s_send_done, s_send_expect_error, s_send_expect_shutdown; static volatile bool s_recv_start, s_recv_waiting, s_recv_done; static volatile bool s_recv_expect_error; static volatile bool s_shutdown_waiting, s_shutdown_done; +static volatile bool s_udp_ready, s_udp_done; static size_t (*s_tx)(const void *, size_t, struct mg_tcpip_if *); struct client_data { @@ -170,6 +380,7 @@ static void readiness_task(void *args); static void backlog_task(void *args); static void tx_gate_task(void *args); static void shutdown_task(void *args); +static void udp_task(void *args); struct atask_args { bool listener_nonblock; @@ -329,6 +540,21 @@ static void tx_gate_task(void *args) { (void) args; } +static void udp_delay(struct mg_mgr *mgr) { + (void) mgr; + vTaskDelay(1); +} + +static void udp_task(void *args) { + struct mg_mgr *mgr = (struct mg_mgr *) args; + int fd = open_udp(); + + s_udp_ready = true; + udp_exchange(mgr, fd, udp_delay); + s_udp_done = true; + vTaskDelete(NULL); +} + static void recv_wait_task(void *args) { char buf; int fd = (int) (uintptr_t) args; @@ -599,12 +825,22 @@ static void task2(void *args) { struct mg_mgr *mgr = (struct mg_mgr *)args; // Event manager char *ip; int status; - pid_t first, second; + pid_t first, second, udp; vTaskDelay(pdMS_TO_TICKS(500)); // 500 ms s_error = false; s_wait = false; ip = mg_mprintf("%M", mg_print_ip4, &mgr->ifp->ip); + s_udp_ready = s_udp_done = false; + ASSERT(xTaskCreate(udp_task, "udp", 512, mgr, configMAX_PRIORITIES - 1, + NULL) == pdPASS); + while (!s_udp_ready) vTaskDelay(1); + udp = start_udp(ip); + while (!client_done(udp, &status)) vTaskDelay(1); + check_client(status); + while (!s_udp_done) vTaskDelay(1); + DASHBOARD("udp"); + s_poll_waiting = s_poll_done = false; ASSERT(xTaskCreate(poll_task, "poll", 512, NULL, configMAX_PRIORITIES - 1, NULL) == pdPASS); @@ -963,6 +1199,20 @@ static void nortos_echo(struct mg_mgr *mgr, struct nortos_echo_client *clients, nortos_wait_client(mgr, pid); } +static void udp_poll(struct mg_mgr *mgr) { + mg_mgr_poll(mgr, 0); +} + +static void nortos_udp(struct mg_mgr *mgr, const char *ip) { + pid_t pid; + int fd = open_udp(); + + pid = start_udp(ip); + udp_exchange(mgr, fd, udp_poll); + nortos_wait_client(mgr, pid); + DASHBOARD("nortos_udp"); +} + static void nortos_test(struct mg_mgr *mgr) { static const char bootstrap = '\0'; static const char grow[512] = {0}; @@ -1083,6 +1333,7 @@ static void nortos_test(struct mg_mgr *mgr) { ASSERT(close(fd) == 0); mg_mgr_poll(mgr, 0); DASHBOARD("nortos_nonblocking_connect"); + nortos_udp(mgr, ip); mg_free(ip); } diff --git a/tutorials/stm32/nucleo-h723zg/minimal-bsd-baremetal/echo.c b/tutorials/stm32/nucleo-h723zg/minimal-bsd-baremetal/echo.c index 8a805f92..b3e84cae 100644 --- a/tutorials/stm32/nucleo-h723zg/minimal-bsd-baremetal/echo.c +++ b/tutorials/stm32/nucleo-h723zg/minimal-bsd-baremetal/echo.c @@ -6,7 +6,6 @@ #include "mongoose.h" -#include #include struct echo_server { @@ -43,12 +42,12 @@ int echo_init(uint16_t port) { if (fd < 0 || !echo_nonblock(fd) || bind(fd, (struct sockaddr *) &sa, sizeof(sa)) < 0 || listen(fd, 3) < 0) { - printf("BSD echo init: %d\n", errno); + MG_ERROR(("BSD echo init: %d", errno)); if (fd >= 0) close(fd); return 0; } s_server.sock = fd; - printf("BSD echo server on port %hu\n", port); + MG_INFO(("BSD echo server on port %hu", port)); return 1; } @@ -80,7 +79,7 @@ void echo_poll(void) { if (fd >= 0) { c = (struct echo_client *) calloc(1, sizeof(*c)); if (c == NULL || !echo_nonblock(fd)) { - printf("BSD echo accept: %d\n", c == NULL ? ENOMEM : errno); + MG_ERROR(("BSD echo accept: %d", c == NULL ? ENOMEM : errno)); close(fd); free(c); } else {