mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
strip out the legacy xous Tcp stack implementation
This commit is contained in:
parent
f2bd4a6193
commit
12190b9184
3 changed files with 8 additions and 463 deletions
|
|
@ -38,13 +38,13 @@ pub(crate) enum Opcode {
|
|||
//UdpSetTtl = 3,
|
||||
//UdpGetTtl = 4,
|
||||
|
||||
/// Calls for TCP implementation
|
||||
TcpConnect = 5,
|
||||
TcpTx = 6,
|
||||
TcpClose = 7,
|
||||
TcpManage = 8,
|
||||
TcpListen = 9,
|
||||
TcpManageListener = 10,
|
||||
/// Calls for TCP implementation (now deprecated to libstd)
|
||||
//TcpConnect = 5,
|
||||
//TcpTx = 6,
|
||||
//TcpClose = 7,
|
||||
//TcpManage = 8,
|
||||
//TcpListen = 9,
|
||||
//TcpManageListener = 10,
|
||||
|
||||
// The DNS server can hook the Net crate for notifications on config updates
|
||||
/// Adds an Ipv4 as a DNS server
|
||||
|
|
|
|||
|
|
@ -81,19 +81,6 @@ pub struct PingConnection {
|
|||
retop: usize,
|
||||
}
|
||||
|
||||
#[derive(Hash, PartialEq, Eq)]
|
||||
pub struct TcpConnection {
|
||||
remote: IpAddress,
|
||||
remote_port: u16,
|
||||
local_port: u16,
|
||||
}
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
pub struct TcpState {
|
||||
handle: SocketHandle,
|
||||
cid: CID,
|
||||
shutdown_rx: bool,
|
||||
}
|
||||
|
||||
struct WaitingSocket {
|
||||
env: xous::MessageEnvelope,
|
||||
handle: SocketHandle,
|
||||
|
|
@ -230,10 +217,6 @@ fn xmain() -> ! {
|
|||
let mut ping_destinations = HashMap::<PingConnection, HashMap<u16, u64>>::new();
|
||||
let mut ping_timeout_ms = PING_DEFAULT_TIMEOUT_MS;
|
||||
|
||||
// tcp storage
|
||||
let mut tcp_handles = HashMap::<TcpConnection, TcpState>::new();
|
||||
let mut tcp_listeners = HashMap::<u16, Vec<TcpState>>::new();
|
||||
|
||||
// other link storage
|
||||
let neighbor_cache = NeighborCache::new(BTreeMap::new());
|
||||
let ip_addrs = [IpCidr::new(Ipv4Address::UNSPECIFIED.into(), 0)];
|
||||
|
|
@ -624,7 +607,7 @@ fn xmain() -> ! {
|
|||
break;
|
||||
}
|
||||
}
|
||||
if (shutdown_code & 1) != 0 { // write shutdown
|
||||
if (shutdown_code & 2) != 0 { // write shutdown
|
||||
// search for the handle in the txwaiting set
|
||||
for tx_waiter in tcp_tx_waiting.iter_mut() {
|
||||
let WaitingSocket {
|
||||
|
|
@ -853,321 +836,6 @@ fn xmain() -> ! {
|
|||
};
|
||||
}
|
||||
|
||||
Some(Opcode::TcpConnect) => {
|
||||
let mut buf = unsafe {
|
||||
Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())
|
||||
};
|
||||
let mut tcpspec = buf.to_original::<NetTcpManage, _>().unwrap(); // need to define this
|
||||
let address = IpAddress::from(tcpspec.ip_addr);
|
||||
let remote_port = tcpspec.remote_port;
|
||||
|
||||
// initiates a new connection to a remote server consisting of an (Address:Port) tuple.
|
||||
// multiple connections can exist to a server, and they are further differentiated by the return port
|
||||
let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; TCP_BUFFER_SIZE]);
|
||||
let tcp_tx_buffer = TcpSocketBuffer::new(vec![0; TCP_BUFFER_SIZE]);
|
||||
let mut tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
|
||||
if let Some(timeout) = tcpspec.timeout_ms {
|
||||
tcp_socket.set_timeout(Some(Duration::from_millis(timeout)));
|
||||
}
|
||||
if let Some(keepalive) = tcpspec.keepalive_ms {
|
||||
tcp_socket.set_keep_alive(Some(Duration::from_millis(keepalive)));
|
||||
}
|
||||
let local_port = (49152 + trng.get_u32().unwrap() % 16384) as u16;
|
||||
match tcp_socket.connect((address, remote_port), local_port) {
|
||||
Ok(_) => {
|
||||
let connection = TcpConnection {
|
||||
remote: address,
|
||||
remote_port,
|
||||
local_port,
|
||||
};
|
||||
let handle = sockets.add(tcp_socket);
|
||||
let sid = tcpspec.cb_sid;
|
||||
let cid = xous::connect(SID::from_array(sid)).unwrap();
|
||||
let tcp_cb_state = TcpState {
|
||||
handle,
|
||||
cid,
|
||||
shutdown_rx: false,
|
||||
};
|
||||
tcp_handles.insert(connection, tcp_cb_state);
|
||||
tcpspec.local_port = Some(local_port);
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
}
|
||||
Err(e) => match e {
|
||||
smoltcp::Error::Illegal => {
|
||||
tcpspec.result = Some(NetMemResponse::SocketInUse);
|
||||
}
|
||||
smoltcp::Error::Unaddressable => {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
_ => {
|
||||
tcpspec.result = Some(NetMemResponse::LibraryError);
|
||||
}
|
||||
},
|
||||
}
|
||||
buf.replace(tcpspec).unwrap();
|
||||
}
|
||||
Some(Opcode::TcpManage) => {
|
||||
let mut buf = unsafe {
|
||||
Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())
|
||||
};
|
||||
let mut tcpspec = buf.to_original::<NetTcpManage, _>().unwrap();
|
||||
if let Some(local_port) = tcpspec.local_port {
|
||||
let connection = TcpConnection {
|
||||
remote: IpAddress::from(tcpspec.ip_addr),
|
||||
remote_port: tcpspec.remote_port,
|
||||
local_port,
|
||||
};
|
||||
if let Some(tcp_state) = tcp_handles.get_mut(&connection) {
|
||||
if let Some(code) = tcpspec.mgmt_code {
|
||||
match code {
|
||||
TcpMgmtCode::SetRxShutdown => {
|
||||
tcp_state.shutdown_rx = true;
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
}
|
||||
TcpMgmtCode::SetNoDelay(value) => {
|
||||
let mut socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
||||
socket.set_nagle_enabled(value);
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
}
|
||||
TcpMgmtCode::GetNoDelay(_) => {
|
||||
let socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
||||
let value = socket.nagle_enabled().is_some();
|
||||
tcpspec.mgmt_code = Some(TcpMgmtCode::GetNoDelay(value));
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
}
|
||||
TcpMgmtCode::SetTtl(mut ttl) => {
|
||||
let mut socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
||||
if ttl > 255 {
|
||||
ttl = 255;
|
||||
}
|
||||
if ttl > 0 {
|
||||
socket.set_hop_limit(Some(ttl as u8));
|
||||
} else {
|
||||
socket.set_hop_limit(None);
|
||||
}
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
}
|
||||
TcpMgmtCode::GetTtl(_) => {
|
||||
let socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
||||
let value = socket.hop_limit().unwrap_or(64); // because that's what smoltcp does
|
||||
tcpspec.mgmt_code = Some(TcpMgmtCode::GetTtl(value as u32));
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
}
|
||||
TcpMgmtCode::ErrorCheck(_) => {
|
||||
/* // I don't think there is actually any error check reporting available? `recv_error_check()` is a private function for smoltcp...
|
||||
let socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
||||
tcpspec.mgmt_code = Some(TcpMgmtCode::ErrorCheck(
|
||||
match socket.recv_error_check() {
|
||||
Ok(_) => NetMemResponse::Ok,
|
||||
Err(smoltcp::Error::Finished) => NetMemResponse::Finished,
|
||||
Err(smoltcp::Error::Illegal) => NetMemResponse::Invalid,
|
||||
_ => Some(NetMemResponse::LibraryError),
|
||||
}
|
||||
));*/
|
||||
tcpspec.mgmt_code =
|
||||
Some(TcpMgmtCode::ErrorCheck(NetMemResponse::Ok));
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
}
|
||||
TcpMgmtCode::Flush(_) => {
|
||||
let socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
||||
if socket.send_queue() == 0 {
|
||||
tcpspec.mgmt_code = Some(TcpMgmtCode::Flush(true));
|
||||
} else {
|
||||
tcpspec.mgmt_code = Some(TcpMgmtCode::Flush(false));
|
||||
}
|
||||
}
|
||||
TcpMgmtCode::CloseListener => {
|
||||
// this is used for listener management, should never be sent to this routine
|
||||
tcpspec.result = Some(NetMemResponse::LibraryError);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
} else {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
} else {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
buf.replace(tcpspec).unwrap();
|
||||
}
|
||||
|
||||
Some(Opcode::TcpTx) => {
|
||||
let mut buf = unsafe {
|
||||
Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())
|
||||
};
|
||||
let mut tcp_tx = buf.to_original::<NetTcpTransmit, _>().unwrap();
|
||||
let connection = TcpConnection {
|
||||
remote: IpAddress::from(tcp_tx.remote_addr),
|
||||
remote_port: tcp_tx.remote_port,
|
||||
local_port: tcp_tx.local_port,
|
||||
};
|
||||
if let Some(tcp_state) = tcp_handles.get(&connection) {
|
||||
let mut socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
||||
if socket.can_send() {
|
||||
tcp_tx.result = match socket.send_slice(&tcp_tx.data[..tcp_tx.len as usize])
|
||||
{
|
||||
Ok(octets) => {
|
||||
log::trace!("sent {}", octets);
|
||||
tcp_tx.len = octets as u16;
|
||||
Some(NetMemResponse::Sent(octets as u16))
|
||||
}
|
||||
Err(_) => Some(NetMemResponse::LibraryError),
|
||||
}
|
||||
} else {
|
||||
log::trace!("tx can't send, please retry");
|
||||
// inform the sender it should retry
|
||||
tcp_tx.result = Some(NetMemResponse::SocketInUse);
|
||||
}
|
||||
} else {
|
||||
log::trace!("tx spec invalid");
|
||||
tcp_tx.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
buf.replace(tcp_tx).unwrap();
|
||||
}
|
||||
Some(Opcode::TcpClose) => {
|
||||
let mut buf = unsafe {
|
||||
Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())
|
||||
};
|
||||
let mut tcpspec = buf.to_original::<NetTcpManage, _>().unwrap(); // need to define this
|
||||
if let Some(local_port) = tcpspec.local_port {
|
||||
let connection = TcpConnection {
|
||||
remote: IpAddress::from(tcpspec.ip_addr),
|
||||
remote_port: tcpspec.remote_port,
|
||||
local_port,
|
||||
};
|
||||
if let Some(tcp_state) = tcp_handles.remove(&connection) {
|
||||
sockets.get::<TcpSocket>(tcp_state.handle).close();
|
||||
sockets.remove(tcp_state.handle);
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
} else {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
} else {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
buf.replace(tcpspec).unwrap();
|
||||
}
|
||||
Some(Opcode::TcpListen) => {
|
||||
let mut buf = unsafe {
|
||||
Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())
|
||||
};
|
||||
let mut tcpspec = buf.to_original::<NetTcpListen, _>().unwrap();
|
||||
|
||||
let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; TCP_BUFFER_SIZE]);
|
||||
let tcp_tx_buffer = TcpSocketBuffer::new(vec![0; TCP_BUFFER_SIZE]);
|
||||
let mut tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
|
||||
log::debug!("adding listener to local port {}", tcpspec.local_port);
|
||||
match tcp_socket.listen(tcpspec.local_port) {
|
||||
Ok(_) => {
|
||||
if let Some(list) = tcp_listeners.get(&tcpspec.local_port) {
|
||||
if list.len() > 0 {
|
||||
// empty check necessary because an empty vector is left if a socket went from listening->active, or was dropped
|
||||
// guarantee that all TTLs are same even if we're inserting a new socket
|
||||
let ttl = sockets.get::<TcpSocket>(list[0].handle).hop_limit();
|
||||
tcp_socket.set_hop_limit(ttl);
|
||||
}
|
||||
}
|
||||
let handle = sockets.add(tcp_socket);
|
||||
let sid = tcpspec.cb_sid;
|
||||
let cid = xous::connect(SID::from_array(sid)).unwrap();
|
||||
log::trace!("Listener with cid {}, sid {:x?} registered", cid, sid);
|
||||
let tcp_cb_state = TcpState {
|
||||
handle,
|
||||
cid,
|
||||
shutdown_rx: false,
|
||||
};
|
||||
if let Some(list) = tcp_listeners.get_mut(&tcpspec.local_port) {
|
||||
list.push(tcp_cb_state);
|
||||
log::trace!(
|
||||
"total listeners on port {}: {}",
|
||||
tcpspec.local_port,
|
||||
list.len()
|
||||
);
|
||||
} else {
|
||||
tcp_listeners.insert(tcpspec.local_port, vec![tcp_cb_state]);
|
||||
log::trace!("creating first listener on port {}", tcpspec.local_port);
|
||||
}
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
}
|
||||
Err(e) => match e {
|
||||
smoltcp::Error::Illegal => {
|
||||
tcpspec.result = Some(NetMemResponse::SocketInUse);
|
||||
}
|
||||
smoltcp::Error::Unaddressable => {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
_ => {
|
||||
tcpspec.result = Some(NetMemResponse::LibraryError);
|
||||
}
|
||||
},
|
||||
}
|
||||
buf.replace(tcpspec).unwrap();
|
||||
}
|
||||
Some(Opcode::TcpManageListener) => {
|
||||
let mut buf = unsafe {
|
||||
Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())
|
||||
};
|
||||
let mut tcpspec = buf.to_original::<NetTcpManage, _>().unwrap();
|
||||
match tcpspec.mgmt_code {
|
||||
Some(TcpMgmtCode::CloseListener) => {
|
||||
if let Some(listener) = tcp_listeners.get_mut(&tcpspec.local_port.unwrap())
|
||||
{
|
||||
if let Some(tcp_state) = listener.pop() {
|
||||
sockets.get::<TcpSocket>(tcp_state.handle).close();
|
||||
log::debug!(
|
||||
"closing one listener on port {:?}",
|
||||
tcpspec.local_port
|
||||
);
|
||||
sockets.remove(tcp_state.handle);
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
// this may leave an empty vector in the tcp_listeners structure, but I think that's OK
|
||||
}
|
||||
} else {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
}
|
||||
Some(TcpMgmtCode::SetTtl(mut ttl)) => {
|
||||
if let Some(listener_vec) =
|
||||
tcp_listeners.get_mut(&tcpspec.local_port.unwrap())
|
||||
{
|
||||
for listener in listener_vec.iter_mut() {
|
||||
let mut socket = sockets.get::<TcpSocket>(listener.handle);
|
||||
if ttl > 255 {
|
||||
ttl = 255;
|
||||
}
|
||||
if ttl > 0 {
|
||||
socket.set_hop_limit(Some(ttl as u8));
|
||||
} else {
|
||||
socket.set_hop_limit(None);
|
||||
}
|
||||
}
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
} else {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
}
|
||||
Some(TcpMgmtCode::GetTtl(_)) => {
|
||||
if let Some(listener) = tcp_listeners.get(&tcpspec.local_port.unwrap()) {
|
||||
if listener.len() > 0 {
|
||||
// all listeners "should" have an identical setting, so, just return the setting of the 0th one
|
||||
let socket = sockets.get::<TcpSocket>(listener[0].handle);
|
||||
let value = socket.hop_limit().unwrap_or(64); // because that's what smoltcp does
|
||||
tcpspec.mgmt_code = Some(TcpMgmtCode::GetTtl(value as u32));
|
||||
tcpspec.result = Some(NetMemResponse::Ok);
|
||||
} else {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
} else {
|
||||
tcpspec.result = Some(NetMemResponse::Invalid);
|
||||
}
|
||||
}
|
||||
_ => tcpspec.result = Some(NetMemResponse::LibraryError),
|
||||
}
|
||||
buf.replace(tcpspec).unwrap();
|
||||
}
|
||||
|
||||
Some(Opcode::StdUdpBind) => {
|
||||
let pid = msg.sender.pid();
|
||||
std_udp_bind(
|
||||
|
|
@ -1412,47 +1080,6 @@ fn xmain() -> ! {
|
|||
}
|
||||
}
|
||||
|
||||
// this block handles TCP rx
|
||||
{
|
||||
for (_connection, tcp_state) in tcp_handles.iter() {
|
||||
if !tcp_state.shutdown_rx {
|
||||
let mut socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
||||
if socket.can_recv() {
|
||||
match socket.recv(|data| {
|
||||
let mut response = NetTcpResponse {
|
||||
len: data.len() as u16,
|
||||
data: [0; TCP_BUFFER_SIZE],
|
||||
};
|
||||
for (&src, dst) in data.iter().zip(response.data.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
let buf = Buffer::into_buf(response)
|
||||
.expect("couldn't convert TCP response to memory message");
|
||||
buf.send(
|
||||
tcp_state.cid,
|
||||
NetTcpCallback::RxData.to_u32().unwrap(),
|
||||
)
|
||||
.expect("couldn't send TCP response");
|
||||
(data.len(), ())
|
||||
}) {
|
||||
Ok(_) => (),
|
||||
Err(e) => match e {
|
||||
smoltcp::Error::Illegal => {
|
||||
log::warn!("TCP fast open not supported");
|
||||
}
|
||||
smoltcp::Error::Finished => {
|
||||
log::warn!("TCP packet received after close");
|
||||
}
|
||||
_ => {
|
||||
log::warn!("Unknown TCP error");
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Connect calls take time to establish. This block checks to see if connections
|
||||
// have been made and issues callbacks as necessary.
|
||||
for connection in tcp_connect_waiting.iter_mut() {
|
||||
|
|
@ -1619,74 +1246,6 @@ fn xmain() -> ! {
|
|||
tcp_accept_success(buf, fd as u16, ep);
|
||||
}
|
||||
|
||||
// this block handles TCP listeners
|
||||
// There is no lock on sending Rx messages to the listener as it is being transformed
|
||||
// because all messages come from *this thread* and by definition it is not re-entrant.
|
||||
// If you end up splitting the Tcp Rx task and the Tcp Listener tasks into separate threads,
|
||||
// Then you must worry about the possibility of a race condition between the transition of a
|
||||
// TcpListener to a regular TcpStream client (that is, an Rx packet forwarded before the
|
||||
// TcpStream is fully built).
|
||||
if tcp_listeners.len() > 0 {
|
||||
// skip the whole chunk if we don't have any tcp listeners
|
||||
log::trace!("checking {} TCP listener sockets", tcp_listeners.len());
|
||||
for (&local_port, tcp_state_vec) in tcp_listeners.iter_mut() {
|
||||
let mut remove_indices = Vec::<usize>::new();
|
||||
for (index, tcp_state) in tcp_state_vec.iter().enumerate() {
|
||||
let socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
||||
if socket.is_active() {
|
||||
log::info!(
|
||||
"Promoting a Listener on port {:?} from {:?} to a Stream",
|
||||
socket.local_endpoint(),
|
||||
socket.remote_endpoint()
|
||||
);
|
||||
// 1. promote this socket to a TCP rx socket (this creates a double-entry that is cleaned up in step 3)
|
||||
let connection = TcpConnection {
|
||||
remote: socket.remote_endpoint().addr,
|
||||
remote_port: socket.remote_endpoint().port,
|
||||
local_port,
|
||||
};
|
||||
tcp_handles.insert(connection, *tcp_state);
|
||||
|
||||
// 2. notify the listener
|
||||
let note = NetTcpListenCallback {
|
||||
ip_addr: NetIpAddr::from(socket.remote_endpoint().addr),
|
||||
remote_port: socket.remote_endpoint().port,
|
||||
local_port,
|
||||
};
|
||||
log::debug!(
|
||||
"Listener active, notification sent to {}: {:x?}",
|
||||
tcp_state.cid,
|
||||
note
|
||||
);
|
||||
let buf =
|
||||
Buffer::into_buf(note).expect("can't transform memory message");
|
||||
buf.send(
|
||||
tcp_state.cid,
|
||||
NetTcpCallback::ListenerActive.to_u32().unwrap(),
|
||||
)
|
||||
.expect("can't inform callback of active status");
|
||||
log::trace!("listener index {} to remove", index);
|
||||
remove_indices.push(index);
|
||||
break;
|
||||
} else {
|
||||
log::trace!("socket not active: {:?}", socket.remote_endpoint());
|
||||
}
|
||||
}
|
||||
// 3. now cleanup and remove the ports from the listeners status
|
||||
remove_indices.sort(); // this should be in ascending order, but let's do this just to be sure.
|
||||
remove_indices.reverse();
|
||||
for index in remove_indices {
|
||||
tcp_state_vec.remove(index);
|
||||
log::trace!("removing listener index {}", index);
|
||||
}
|
||||
log::trace!("listeners remaining: {}", tcp_state_vec.len());
|
||||
// 4. At this point, the Listener is no more. However, the caller side will "renew" the
|
||||
// listener if the TcpListener is being used in an `incoming` loop.
|
||||
|
||||
// 5. Side note: an empty vector could be left in the tcp_listeners array. 🔥This is fine🔥.
|
||||
}
|
||||
}
|
||||
|
||||
// this block handles StdUdp
|
||||
for connection in udp_rx_waiting.iter_mut() {
|
||||
let mut socket;
|
||||
|
|
|
|||
|
|
@ -9,17 +9,3 @@ pub use dns_hosted::*;
|
|||
|
||||
pub mod ping;
|
||||
pub use ping::*;
|
||||
|
||||
#[cfg(any(target_os = "none", target_os = "xous"))]
|
||||
pub mod tcp_stream;
|
||||
#[cfg(any(target_os = "none", target_os = "xous"))]
|
||||
pub use tcp_stream::*;
|
||||
#[cfg(any(target_os = "none", target_os = "xous"))]
|
||||
pub mod tcp_listener;
|
||||
#[cfg(any(target_os = "none", target_os = "xous"))]
|
||||
pub use tcp_listener::*;
|
||||
|
||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
pub mod tcp_hosted;
|
||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
pub use tcp_hosted::*;
|
||||
|
|
|
|||
Loading…
Reference in a new issue