Merge pull request #3785 from cesanta/bsdud

Add improved datagram support for BSD
This commit is contained in:
Sergio R. Caprile authored and GitHub committed 2026-11-20 13:52:41 -03:00
commit 1620b2ae03
9 files changed
+629 -118

No files matched your search

+143 -56
View File
@@ -167,6 +167,7 @@ fail:
#endif #endif
#include <stdarg.h> #include <stdarg.h>
#if MG_ENABLE_BSD_SOCKETS && MG_ENABLE_FREERTOS #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; 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 #if MG_ENABLE_FREERTOS
// Complete operations blocked on c before Mongoose destroys it. // Complete operations blocked on c before Mongoose destroys it.
static void bsd_finish_waiters(struct mg_bsd_sock *s, bool error) { 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) if (s->is_shut_rd || s->c->recv.len > 0 || s->c->is_draining)
ready |= BSD_READ; ready |= BSD_READ;
if (s->is_shut_wr) ready |= BSD_ERROR; if (s->is_shut_wr) ready |= BSD_ERROR;
if (!s->is_shut_wr && !s->is_udp && !s->c->is_connecting && if (!s->is_shut_wr && (s->is_udp || !s->c->is_connecting) &&
!s->c->is_closing && !s->c->is_draining) !s->c->is_closing && !s->c->is_draining &&
ready |= BSD_WRITE; // Established TCP socket (!s->is_udp || s->c->send.len == 0))
ready |= BSD_WRITE; // UDP socket or established TCP socket
return ready; return ready;
} }
@@ -498,7 +540,7 @@ static void bsd_close(struct mg_bsd_sock *s) {
if (t->orphan && t->listener == s) { if (t->orphan && t->listener == s) {
if (t->c != NULL) { if (t->c != NULL) {
t->c->fn_data = NULL; t->c->fn_data = NULL;
mg_close_conn(t->c); t->c->is_draining = 1;
t->c = NULL; t->c = NULL;
} }
memset(t, 0, sizeof(*t)); // Release orphan memset(t, 0, sizeof(*t)); // Release orphan
@@ -506,7 +548,7 @@ static void bsd_close(struct mg_bsd_sock *s) {
} }
if (s->c != NULL) { if (s->c != NULL) {
s->c->fn_data = NULL; s->c->fn_data = NULL;
mg_close_conn(s->c); s->c->is_draining = 1;
s->c = NULL; s->c = NULL;
} }
memset(s, 0, sizeof(*s)); // Release socket 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; cmd->result = -1, cmd->err = ECONNREFUSED;
return true; return true;
} }
if (!c->is_connecting) { if (s->is_udp || !c->is_connecting) {
cmd->result = 0; cmd->result = 0; // UDP may still resolve ARP; TCP waits for SYN/SYN-ACK
return true; return true;
} }
if (s->nonblock) { if (s->nonblock) {
@@ -722,11 +764,8 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) {
return true; return true;
} }
if (c->recv.len > 0) { if (c->recv.len > 0) {
size_t n = cmd->op_recv.len; cmd->result = (int) bsd_recv(s, cmd->op_recv.buf, cmd->op_recv.len,
if (c->recv.len < n) n = c->recv.len; cmd->op_recv.flags, NULL, NULL);
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;
return true; return true;
} }
if (s->err != 0) { 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 || } else if (s->is_shut_wr || (c = s->c) == NULL || s->err != 0 ||
c->is_closing || c->is_draining) { c->is_closing || c->is_draining) {
cmd->result = -1, cmd->err = EPIPE; 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; cmd->result = (int) cmd->op_send.len;
} else if (s->nonblock || (cmd->op_send.flags & MSG_DONTWAIT)) { } else if (s->nonblock || (cmd->op_send.flags & MSG_DONTWAIT)) {
cmd->result = -1, cmd->err = EAGAIN; 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) { if ((s = bsd_get(cmd->op_sendto.fd)) == NULL) {
cmd->result = -1, cmd->err = EBADF; 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, } else if ((err = bsd_addr4(cmd->op_sendto.addr,
cmd->op_sendto.addrlen)) != 0) { cmd->op_sendto.addrlen)) != 0) {
cmd->result = -1, cmd->err = err; cmd->result = -1, cmd->err = err;
} else if (s->is_shut_wr || (c = s->c) == NULL || s->err != 0 || } else if (s->is_shut_wr || (c = s->c) == NULL || s->err != 0 ||
c->is_closing || c->is_draining) { c->is_closing || c->is_draining) {
cmd->result = -1, cmd->err = EPIPE; cmd->result = -1, cmd->err = EPIPE;
} else if (c->is_client) {
cmd->result = -1, cmd->err = EISCONN;
} else { } else {
const struct sockaddr_in *sa = const struct sockaddr_in *sa =
(const struct sockaddr_in *) cmd->op_sendto.addr; (const struct sockaddr_in *) cmd->op_sendto.addr;
c->rem.port = sa->sin_port; if (cmd->op_sendto.len == 0) {
c->rem.addr.ip4 = sa->sin_addr.s_addr; cmd->result = 0;
c->rem.is_ip6 = false; } else if (bsd_udp_too_big(c, cmd->op_sendto.len)) {
if (mg_send(c, cmd->op_sendto.buf, cmd->op_sendto.len)) { cmd->result = -1, cmd->err = EMSGSIZE;
cmd->result = (int) cmd->op_sendto.len; } 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)) { } else if (s->nonblock || (cmd->op_sendto.flags & MSG_DONTWAIT)) {
cmd->result = -1, cmd->err = EAGAIN; cmd->result = -1, cmd->err = EAGAIN;
} else { } else {
#if MG_ENABLE_FREERTOS #if MG_ENABLE_FREERTOS
return false; // No send buffer space yet, wait return false; // One UDP datagram is pending, wait
#else #else
cmd->result = -1, cmd->err = EAGAIN; cmd->result = -1, cmd->err = EAGAIN;
#endif #endif
@@ -797,6 +878,9 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) {
if ((s = bsd_get(cmd->op_recvfrom.fd)) == NULL) { if ((s = bsd_get(cmd->op_recvfrom.fd)) == NULL) {
cmd->result = -1, cmd->err = EBADF; cmd->result = -1, cmd->err = EBADF;
return true; return true;
} else if (!s->is_udp) {
cmd->result = -1, cmd->err = EOPNOTSUPP;
return true;
} }
if (s->is_shut_rd) { if (s->is_shut_rd) {
cmd->result = 0; cmd->result = 0;
@@ -808,25 +892,11 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) {
return true; return true;
} }
if (c->recv.len > 0) { if (c->recv.len > 0) {
size_t n = cmd->op_recvfrom.len; cmd->result = (int) bsd_recv(s, cmd->op_recvfrom.buf,
cmd->op_recvfrom.len,
if (cmd->op_recvfrom.src != NULL && cmd->op_recvfrom.flags,
(cmd->op_recvfrom.addrlen == NULL || cmd->op_recvfrom.src,
*cmd->op_recvfrom.addrlen < sizeof(struct sockaddr_in))) { cmd->op_recvfrom.addrlen);
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;
return true; return true;
} }
if (s->err != 0) { 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) { static bool rx_udp(struct mg_tcpip_if *ifp, struct pkt *pkt) {
struct mg_connection *c = getpeer(ifp->mgr, pkt, true); struct mg_connection *c = getpeer(ifp->mgr, pkt, true);
struct connstate *s; struct connstate *s;
struct mg_addr rem;
uint8_t *l2addr; uint8_t *l2addr;
if (c == NULL) return false; // No UDP listener on this port 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); s = (struct connstate *) (c + 1);
c->rem.port = pkt->udp->sport;
#if MG_ENABLE_IPV6 #if MG_ENABLE_IPV6
if (c->loc.is_ip6) { // matching of v4/v6 to dest is done bt getpeer() if (c->loc.is_ip6) { // matching of v4/v6 to dest is done bt getpeer()
if (!udp6csum_ok(pkt->ip6, pkt->udp)) return false; if (!udp6csum_ok(pkt->ip6, pkt->udp)) return false;
c->rem.addr.ip6[0] = pkt->ip6->src[0], if (c->is_bsd && c->is_client &&
c->rem.addr.ip6[1] = pkt->ip6->src[1], c->rem.is_ip6 = true; (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 } else
#endif #endif
{ {
if (!udpcsum_ok(pkt->ip, pkt->udp)) return false; 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 return false; // safety net for lousy networks
memcpy(s->mac, l2addr, sizeof(s->mac)); memcpy(s->mac, l2addr, sizeof(s->mac));
if (c->recv.len >= MG_MAX_RECV_SIZE) { 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->retransmit = ifp->enable_tcp_retransmit;
s->txq.align = MG_TCPIP_TXQ_ALIGN; s->txq.align = MG_TCPIP_TXQ_ALIGN;
c->is_resolving = 0; c->is_resolving = 0;
if (ifp->eport < MG_EPHEMERAL_PORT_BASE) ifp->eport = MG_EPHEMERAL_PORT_BASE; if (c->loc.port == 0) {
c->loc.port = mg_htons(ifp->eport++); 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 MG_ENABLE_IPV6
if (c->rem.is_ip6) { 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]; 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]; 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; c->loc.is_ip6 = true;
} else } else
#endif #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, MG_DEBUG(("%lu %M -> %M", c->id, mg_print_ip_port, &c->loc, mg_print_ip_port,
&c->rem)); &c->rem));
@@ -12065,7 +12152,7 @@ void mg_connect_resolved(struct mg_connection *c) {
uint32_t rem_ip = c->rem.addr.ip4; uint32_t rem_ip = c->rem.addr.ip4;
if (ifp->ip && MG_IPISLOCAL(ifp, rem_ip) && if (ifp->ip && MG_IPISLOCAL(ifp, rem_ip) &&
rem_ip != ifp->gw) { // skip if gw (onstatechange -> ARP) 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_DEBUG(("%lu ARP lookup...", c->id));
mg_tcpip_arp_request(ifp, rem_ip, NULL); mg_tcpip_arp_request(ifp, rem_ip, NULL);
settmout(c, MIP_TTYPE_ARP); 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; tls->ca_bundle_der = all_certs;
MG_VERBOSE(("%d-cert bundle", cert_count)); MG_VERBOSE(("%d-cert bundle", cert_count));
} else if (cert_count > 0) { } else if (cert_count > 0) {
tls->ca_der.buf = all_certs[0].buf; int i;
tls->ca_der.len = all_certs[0].len; tls->ca_der = all_certs[0];
for (i = 1; i < cert_count; i++) mg_free((void *) all_certs[i].buf);
mg_free(all_certs); 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) { if (mg_parse_pem(opts->ca, mg_str_s("CERTIFICATE"), &tls->ca_der) < 0) {
mg_error(c, "Failed to load CA certificate"); mg_error(c, "Failed to load CA certificate");
return; 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 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); int cert_count = mg_parse_pem_certs(opts->cert, &all_certs);
if (cert_count > 0) { if (cert_count > 0) {
tls->cert_der.buf = all_certs[0].buf; tls->cert_der = all_certs[0];
tls->cert_der.len = all_certs[0].len;
if (cert_count > 1) { if (cert_count > 1) {
tls->chain_len = (size_t) cert_count; tls->chain_len = (size_t) cert_count;
tls->chain_der = all_certs; tls->chain_der = all_certs;
+12
View File
@@ -5065,6 +5065,18 @@ void mg_bsd_poll(struct mg_mgr *);
#ifndef ENOSPC #ifndef ENOSPC
#define ENOSPC 28 #define ENOSPC 28
#endif #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 #ifndef EPROTONOSUPPORT
#define EPROTONOSUPPORT 93 #define EPROTONOSUPPORT 93
#endif #endif
+108 -38
View File
@@ -1,5 +1,6 @@
#include "bsd.h" #include "bsd.h"
#include "dns.h" #include "dns.h"
#include "util.h"
#include <stdarg.h> #include <stdarg.h>
#if MG_ENABLE_BSD_SOCKETS && MG_ENABLE_FREERTOS #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; 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 #if MG_ENABLE_FREERTOS
// Complete operations blocked on c before Mongoose destroys it. // Complete operations blocked on c before Mongoose destroys it.
static void bsd_finish_waiters(struct mg_bsd_sock *s, bool error) { 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) if (s->is_shut_rd || s->c->recv.len > 0 || s->c->is_draining)
ready |= BSD_READ; ready |= BSD_READ;
if (s->is_shut_wr) ready |= BSD_ERROR; if (s->is_shut_wr) ready |= BSD_ERROR;
if (!s->is_shut_wr && !s->is_udp && !s->c->is_connecting && if (!s->is_shut_wr && (s->is_udp || !s->c->is_connecting) &&
!s->c->is_closing && !s->c->is_draining) !s->c->is_closing && !s->c->is_draining &&
ready |= BSD_WRITE; // Established TCP socket (!s->is_udp || s->c->send.len == 0))
ready |= BSD_WRITE; // UDP socket or established TCP socket
return ready; return ready;
} }
@@ -331,7 +373,7 @@ static void bsd_close(struct mg_bsd_sock *s) {
if (t->orphan && t->listener == s) { if (t->orphan && t->listener == s) {
if (t->c != NULL) { if (t->c != NULL) {
t->c->fn_data = NULL; t->c->fn_data = NULL;
mg_close_conn(t->c); t->c->is_draining = 1;
t->c = NULL; t->c = NULL;
} }
memset(t, 0, sizeof(*t)); // Release orphan memset(t, 0, sizeof(*t)); // Release orphan
@@ -339,7 +381,7 @@ static void bsd_close(struct mg_bsd_sock *s) {
} }
if (s->c != NULL) { if (s->c != NULL) {
s->c->fn_data = NULL; s->c->fn_data = NULL;
mg_close_conn(s->c); s->c->is_draining = 1;
s->c = NULL; s->c = NULL;
} }
memset(s, 0, sizeof(*s)); // Release socket 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; cmd->result = -1, cmd->err = ECONNREFUSED;
return true; return true;
} }
if (!c->is_connecting) { if (s->is_udp || !c->is_connecting) {
cmd->result = 0; cmd->result = 0; // UDP may still resolve ARP; TCP waits for SYN/SYN-ACK
return true; return true;
} }
if (s->nonblock) { if (s->nonblock) {
@@ -555,11 +597,8 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) {
return true; return true;
} }
if (c->recv.len > 0) { if (c->recv.len > 0) {
size_t n = cmd->op_recv.len; cmd->result = (int) bsd_recv(s, cmd->op_recv.buf, cmd->op_recv.len,
if (c->recv.len < n) n = c->recv.len; cmd->op_recv.flags, NULL, NULL);
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;
return true; return true;
} }
if (s->err != 0) { 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 || } else if (s->is_shut_wr || (c = s->c) == NULL || s->err != 0 ||
c->is_closing || c->is_draining) { c->is_closing || c->is_draining) {
cmd->result = -1, cmd->err = EPIPE; 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; cmd->result = (int) cmd->op_send.len;
} else if (s->nonblock || (cmd->op_send.flags & MSG_DONTWAIT)) { } else if (s->nonblock || (cmd->op_send.flags & MSG_DONTWAIT)) {
cmd->result = -1, cmd->err = EAGAIN; 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) { if ((s = bsd_get(cmd->op_sendto.fd)) == NULL) {
cmd->result = -1, cmd->err = EBADF; 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, } else if ((err = bsd_addr4(cmd->op_sendto.addr,
cmd->op_sendto.addrlen)) != 0) { cmd->op_sendto.addrlen)) != 0) {
cmd->result = -1, cmd->err = err; cmd->result = -1, cmd->err = err;
} else if (s->is_shut_wr || (c = s->c) == NULL || s->err != 0 || } else if (s->is_shut_wr || (c = s->c) == NULL || s->err != 0 ||
c->is_closing || c->is_draining) { c->is_closing || c->is_draining) {
cmd->result = -1, cmd->err = EPIPE; cmd->result = -1, cmd->err = EPIPE;
} else if (c->is_client) {
cmd->result = -1, cmd->err = EISCONN;
} else { } else {
const struct sockaddr_in *sa = const struct sockaddr_in *sa =
(const struct sockaddr_in *) cmd->op_sendto.addr; (const struct sockaddr_in *) cmd->op_sendto.addr;
c->rem.port = sa->sin_port; if (cmd->op_sendto.len == 0) {
c->rem.addr.ip4 = sa->sin_addr.s_addr; cmd->result = 0;
c->rem.is_ip6 = false; } else if (bsd_udp_too_big(c, cmd->op_sendto.len)) {
if (mg_send(c, cmd->op_sendto.buf, cmd->op_sendto.len)) { cmd->result = -1, cmd->err = EMSGSIZE;
cmd->result = (int) cmd->op_sendto.len; } 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)) { } else if (s->nonblock || (cmd->op_sendto.flags & MSG_DONTWAIT)) {
cmd->result = -1, cmd->err = EAGAIN; cmd->result = -1, cmd->err = EAGAIN;
} else { } else {
#if MG_ENABLE_FREERTOS #if MG_ENABLE_FREERTOS
return false; // No send buffer space yet, wait return false; // One UDP datagram is pending, wait
#else #else
cmd->result = -1, cmd->err = EAGAIN; cmd->result = -1, cmd->err = EAGAIN;
#endif #endif
@@ -630,6 +711,9 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) {
if ((s = bsd_get(cmd->op_recvfrom.fd)) == NULL) { if ((s = bsd_get(cmd->op_recvfrom.fd)) == NULL) {
cmd->result = -1, cmd->err = EBADF; cmd->result = -1, cmd->err = EBADF;
return true; return true;
} else if (!s->is_udp) {
cmd->result = -1, cmd->err = EOPNOTSUPP;
return true;
} }
if (s->is_shut_rd) { if (s->is_shut_rd) {
cmd->result = 0; cmd->result = 0;
@@ -641,25 +725,11 @@ static bool bsd_run(struct mg_bsd_cmd *cmd) {
return true; return true;
} }
if (c->recv.len > 0) { if (c->recv.len > 0) {
size_t n = cmd->op_recvfrom.len; cmd->result = (int) bsd_recv(s, cmd->op_recvfrom.buf,
cmd->op_recvfrom.len,
if (cmd->op_recvfrom.src != NULL && cmd->op_recvfrom.flags,
(cmd->op_recvfrom.addrlen == NULL || cmd->op_recvfrom.src,
*cmd->op_recvfrom.addrlen < sizeof(struct sockaddr_in))) { cmd->op_recvfrom.addrlen);
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;
return true; return true;
} }
if (s->err != 0) { if (s->err != 0) {
+12
View File
@@ -64,6 +64,18 @@ void mg_bsd_poll(struct mg_mgr *);
#ifndef ENOSPC #ifndef ENOSPC
#define ENOSPC 28 #define ENOSPC 28
#endif #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 #ifndef EPROTONOSUPPORT
#define EPROTONOSUPPORT 93 #define EPROTONOSUPPORT 93
#endif #endif
+29 -12
View File
@@ -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) { static bool rx_udp(struct mg_tcpip_if *ifp, struct pkt *pkt) {
struct mg_connection *c = getpeer(ifp->mgr, pkt, true); struct mg_connection *c = getpeer(ifp->mgr, pkt, true);
struct connstate *s; struct connstate *s;
struct mg_addr rem;
uint8_t *l2addr; uint8_t *l2addr;
if (c == NULL) return false; // No UDP listener on this port 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); s = (struct connstate *) (c + 1);
c->rem.port = pkt->udp->sport;
#if MG_ENABLE_IPV6 #if MG_ENABLE_IPV6
if (c->loc.is_ip6) { // matching of v4/v6 to dest is done bt getpeer() if (c->loc.is_ip6) { // matching of v4/v6 to dest is done bt getpeer()
if (!udp6csum_ok(pkt->ip6, pkt->udp)) return false; if (!udp6csum_ok(pkt->ip6, pkt->udp)) return false;
c->rem.addr.ip6[0] = pkt->ip6->src[0], if (c->is_bsd && c->is_client &&
c->rem.addr.ip6[1] = pkt->ip6->src[1], c->rem.is_ip6 = true; (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 } else
#endif #endif
{ {
if (!udpcsum_ok(pkt->ip, pkt->udp)) return false; 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 return false; // safety net for lousy networks
memcpy(s->mac, l2addr, sizeof(s->mac)); memcpy(s->mac, l2addr, sizeof(s->mac));
if (c->recv.len >= MG_MAX_RECV_SIZE) { 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->retransmit = ifp->enable_tcp_retransmit;
s->txq.align = MG_TCPIP_TXQ_ALIGN; s->txq.align = MG_TCPIP_TXQ_ALIGN;
c->is_resolving = 0; c->is_resolving = 0;
if (ifp->eport < MG_EPHEMERAL_PORT_BASE) ifp->eport = MG_EPHEMERAL_PORT_BASE; if (c->loc.port == 0) {
c->loc.port = mg_htons(ifp->eport++); 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 MG_ENABLE_IPV6
if (c->rem.is_ip6) { 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]; 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]; 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; c->loc.is_ip6 = true;
} else } else
#endif #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, MG_DEBUG(("%lu %M -> %M", c->id, mg_print_ip_port, &c->loc, mg_print_ip_port,
&c->rem)); &c->rem));
@@ -2389,7 +2406,7 @@ void mg_connect_resolved(struct mg_connection *c) {
uint32_t rem_ip = c->rem.addr.ip4; uint32_t rem_ip = c->rem.addr.ip4;
if (ifp->ip && MG_IPISLOCAL(ifp, rem_ip) && if (ifp->ip && MG_IPISLOCAL(ifp, rem_ip) &&
rem_ip != ifp->gw) { // skip if gw (onstatechange -> ARP) 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_DEBUG(("%lu ARP lookup...", c->id));
mg_tcpip_arp_request(ifp, rem_ip, NULL); mg_tcpip_arp_request(ifp, rem_ip, NULL);
settmout(c, MIP_TTYPE_ARP); settmout(c, MIP_TTYPE_ARP);
+9 -6
View File
@@ -13,7 +13,7 @@ else
C_WARN ?= -Wno-deprecated C_WARN ?= -Wno-deprecated
endif 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 shm_port_bridge bsd_s390 bsd_nortos_s390 clean
TEST_SOURCES = bsd_shm_test.c 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 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) ASAN_OPTIONS=$(ASAN_OPTIONS) $(RUN) ./bsd_test $(ARGS)
# also # 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) ASAN_OPTIONS=$(ASAN_OPTIONS) $(RUN) ./bsd_nortos_test $(ARGS)
# requires shm_tap_bridge to be running # requires shm_tap_bridge to be running
@@ -70,6 +70,9 @@ bsd_nortos_test:
bsd_client: bsd_client.c bsd_client: bsd_client.c
$(CC) bsd_client.c -pthread -o $@ $(CC) bsd_client.c -pthread -o $@
bsd_udp: bsd_udp.c
$(CC) bsd_udp.c -o $@
# bridge shm queue <--> TAP interface # bridge shm queue <--> TAP interface
shm_tap_bridge: shm_tap_bridge.c shm_queue.h shm_tap_bridge: shm_tap_bridge.c shm_queue.h
$(CC) shm_tap_bridge.c -pthread -o $@ $(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: ASAN=
bsd_s390: CC = $(DOCKER) mdashnet/s390 cc bsd_s390: CC = $(DOCKER) mdashnet/s390 cc
bsd_s390: RUN = $(DOCKER) --init mdashnet/s390 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' $(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 #also
@@ -87,14 +90,14 @@ bsd_nortos_s390: CFLAGS_MONGOOSE += -DMG_ENABLE_BSD_PROTOTYPES=0
bsd_nortos_s390: ASAN= bsd_nortos_s390: ASAN=
bsd_nortos_s390: CC = $(DOCKER) mdashnet/s390 cc bsd_nortos_s390: CC = $(DOCKER) mdashnet/s390 cc
bsd_nortos_s390: RUN = $(DOCKER) --init mdashnet/s390 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' $(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 shm_port_bridge: shm_port_bridge.c shm_queue.h
$(CC) shm_port_bridge.c $(CFLAGS) -pthread -o $@ $(CC) shm_port_bridge.c $(CFLAGS) -pthread -o $@
clean: # Cleanup. Delete built program and all build artifacts 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 FreeRTOS-Kernel: # FreeRTOS sources
git clone -q -c advice.detachedHead=false --depth 1 -b V11.2.0 https://github.com/FreeRTOS/FreeRTOS-Kernel $@ git clone -q -c advice.detachedHead=false --depth 1 -b V11.2.0 https://github.com/FreeRTOS/FreeRTOS-Kernel $@
+60
View File
@@ -0,0 +1,60 @@
#include <arpa/inet.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>
#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;
}
+253 -2
View File
@@ -33,6 +33,198 @@ static int s_abort = 0;
#define DASHBOARD(x) \ #define DASHBOARD(x) \
printf("HEALTH_DASHBOARD\t\"%s\": %s,\n", x, s_error ? "false" : "true") 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) { static pid_t start_client(const char *ip, const char *connections) {
char *cmd[4]; char *cmd[4];
pid_t pid; pid_t pid;
@@ -46,6 +238,18 @@ static pid_t start_client(const char *ip, const char *connections) {
return pid; 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) { static bool client_done(pid_t pid, int *status) {
pid_t r = waitpid(pid, status, WNOHANG); pid_t r = waitpid(pid, status, WNOHANG);
ASSERT(r >= 0); ASSERT(r >= 0);
@@ -60,12 +264,17 @@ static void check_client(int status) {
static int open_listener(int backlog, bool nonblock) { static int open_listener(int backlog, bool nonblock) {
int lfd = socket(AF_INET, SOCK_STREAM, 0); int lfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in sa; struct sockaddr_in sa;
char buf;
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET; sa.sin_family = AF_INET;
sa.sin_port = htons(1234); sa.sin_port = htons(1234);
sa.sin_addr.s_addr = INADDR_ANY; sa.sin_addr.s_addr = INADDR_ANY;
ASSERT(lfd >= 0); 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(bind(lfd, (struct sockaddr *) &sa, sizeof(sa)) == 0);
ASSERT(listen(lfd, backlog) == 0); ASSERT(listen(lfd, backlog) == 0);
if (nonblock) ASSERT(fcntl(lfd, F_SETFL, O_NONBLOCK) == 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_poll_waiting, s_poll_done;
static volatile bool s_ready_waiting, s_ready_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_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_waiting;
static volatile bool s_send_done, s_send_expect_error, s_send_expect_shutdown; 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_start, s_recv_waiting, s_recv_done;
static volatile bool s_recv_expect_error; static volatile bool s_recv_expect_error;
static volatile bool s_shutdown_waiting, s_shutdown_done; 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 *); static size_t (*s_tx)(const void *, size_t, struct mg_tcpip_if *);
struct client_data { struct client_data {
@@ -170,6 +380,7 @@ static void readiness_task(void *args);
static void backlog_task(void *args); static void backlog_task(void *args);
static void tx_gate_task(void *args); static void tx_gate_task(void *args);
static void shutdown_task(void *args); static void shutdown_task(void *args);
static void udp_task(void *args);
struct atask_args { struct atask_args {
bool listener_nonblock; bool listener_nonblock;
@@ -329,6 +540,21 @@ static void tx_gate_task(void *args) {
(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) { static void recv_wait_task(void *args) {
char buf; char buf;
int fd = (int) (uintptr_t) args; 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 struct mg_mgr *mgr = (struct mg_mgr *)args; // Event manager
char *ip; char *ip;
int status; int status;
pid_t first, second; pid_t first, second, udp;
vTaskDelay(pdMS_TO_TICKS(500)); // 500 ms vTaskDelay(pdMS_TO_TICKS(500)); // 500 ms
s_error = false; s_error = false;
s_wait = false; s_wait = false;
ip = mg_mprintf("%M", mg_print_ip4, &mgr->ifp->ip); 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; s_poll_waiting = s_poll_done = false;
ASSERT(xTaskCreate(poll_task, "poll", 512, NULL, ASSERT(xTaskCreate(poll_task, "poll", 512, NULL,
configMAX_PRIORITIES - 1, NULL) == pdPASS); 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); 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 void nortos_test(struct mg_mgr *mgr) {
static const char bootstrap = '\0'; static const char bootstrap = '\0';
static const char grow[512] = {0}; static const char grow[512] = {0};
@@ -1083,6 +1333,7 @@ static void nortos_test(struct mg_mgr *mgr) {
ASSERT(close(fd) == 0); ASSERT(close(fd) == 0);
mg_mgr_poll(mgr, 0); mg_mgr_poll(mgr, 0);
DASHBOARD("nortos_nonblocking_connect"); DASHBOARD("nortos_nonblocking_connect");
nortos_udp(mgr, ip);
mg_free(ip); mg_free(ip);
} }
@@ -6,7 +6,6 @@
#include "mongoose.h" #include "mongoose.h"
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
struct echo_server { struct echo_server {
@@ -43,12 +42,12 @@ int echo_init(uint16_t port) {
if (fd < 0 || !echo_nonblock(fd) || if (fd < 0 || !echo_nonblock(fd) ||
bind(fd, (struct sockaddr *) &sa, sizeof(sa)) < 0 || listen(fd, 3) < 0) { 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); if (fd >= 0) close(fd);
return 0; return 0;
} }
s_server.sock = fd; s_server.sock = fd;
printf("BSD echo server on port %hu\n", port); MG_INFO(("BSD echo server on port %hu", port));
return 1; return 1;
} }
@@ -80,7 +79,7 @@ void echo_poll(void) {
if (fd >= 0) { if (fd >= 0) {
c = (struct echo_client *) calloc(1, sizeof(*c)); c = (struct echo_client *) calloc(1, sizeof(*c));
if (c == NULL || !echo_nonblock(fd)) { 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); close(fd);
free(c); free(c);
} else { } else {