diff --git a/services/net/src/main.rs b/services/net/src/main.rs index 7deb704f4..5179d4f90 100644 --- a/services/net/src/main.rs +++ b/services/net/src/main.rs @@ -235,6 +235,7 @@ fn main() -> ! { // When a TCP client issues a Receive request, it will get placed here while the packet data // is being accumulated. let mut tcp_rx_waiting: Vec> = Vec::new(); + let mut tcp_peek_waiting: Vec> = Vec::new(); // When a client issues a Send request, it will get placed here while the packet data // is being accumulated. @@ -244,7 +245,7 @@ fn main() -> ! { let mut tcp_tx_closing: Vec<(SocketHandle, xous::MessageSender)> = Vec::new(); // socket handles waiting to enter the closed state - let mut tcp_tx_wait_fin: Vec<(SocketHandle, xous::MessageSender)> = Vec::new(); + let mut tcp_tx_wait_fin: Vec<(SocketHandle, xous::MessageSender, u32)> = Vec::new(); // socket handles corresponding to servers that could be closed by clients let mut tcp_server_remote_close_poll: Vec = Vec::new(); @@ -415,7 +416,8 @@ fn main() -> ! { } } } - let op = FromPrimitive::from_usize(msg.body.id() & 0xffff); + let op = FromPrimitive::from_usize(msg.body.id() & 0x7fff); + let nonblocking = (msg.body.id() & NONBLOCKING_FLAG) != 0; log::debug!("{:?}", op); match op { Some(Opcode::Ping) => { @@ -637,7 +639,14 @@ fn main() -> ! { Some(Opcode::StdTcpPeek) => { log::debug!("StdTcpPeek"); let pid = msg.sender.pid(); - std_tcp_peek(msg, &mut iface, process_sockets.entry(pid).or_default()); + std_tcp_peek( + msg, + &timer, + &mut iface, + process_sockets.entry(pid).or_default(), + &mut tcp_peek_waiting, + nonblocking, + ); xous::try_send_message( net_conn, Message::new_scalar( @@ -656,6 +665,7 @@ fn main() -> ! { &mut iface, &mut tcp_rx_waiting, process_sockets.entry(pid).or_default(), + nonblocking, ); xous::try_send_message( net_conn, @@ -693,7 +703,9 @@ fn main() -> ! { if socket.may_send() && socket.send_queue() == 0 { log::trace!("imm"); socket.close(); - tcp_tx_wait_fin.push((handle, msg.sender)); + tcp_tx_wait_fin.push((handle, msg.sender, 0)); + //log::info!("EARLY CLOSE"); + //xous::return_scalar(msg.sender, 0).ok(); // ack early so we don't block other processes waiting to close } else { log::trace!("def2"); tcp_tx_closing.push((handle, msg.sender)); @@ -748,6 +760,35 @@ fn main() -> ! { // in theory, there should be no more matching handles as they should be all unique, so we can abort the search. break; } + for rx_waiter in tcp_peek_waiting.iter_mut() { + let WaitingSocket { + env: mut msg, + handle, + expiry: _, + } = match rx_waiter { + &mut None => continue, + Some(s) => { + if s.handle == *connection { + rx_waiter.take().unwrap() // removes the message from the waiting queue + } else { + continue + } + } + }; + // if we got here, we found a message that needs to be aborted + log::info!("TcpShutdown: aborting peek waiting handle: {:?}", handle); + match msg.body.memory_message_mut() { + Some(body) => { + // u32::MAX indicates a zero-length receive + body.valid = xous::MemorySize::new(u32::MAX as usize); + }, + None => { + respond_with_error(msg, NetError::LibraryError); + } + } + // in theory, there should be no more matching handles as they should be all unique, so we can abort the search. + break; + } } if (shutdown_code & 2) != 0 { // write shutdown // search for the handle in the txwaiting set @@ -805,6 +846,7 @@ fn main() -> ! { msg, &mut iface, process_sockets.entry(pid).or_default(), + &trng, ); xous::try_send_message( net_conn, @@ -942,9 +984,14 @@ fn main() -> ! { .get_mut(connection_idx) { let socket = iface.get_socket::(*connection); + // this is actually broken right now; it's fixed in https://github.com/smoltcp-rs/smoltcp/commit/8090469c2a1456b87a3e277e5b2f2e34e4f7555b + // not worth forking over this, though. We'll leave this as an erratum. + let nagle_enabled = socket.nagle_enabled().is_some(); // this return type will turn to bool on the next release. + log::warn!("Issue #210: nagle value read is always incorrect. Setting works, however. Returning nagle value of {}", nagle_enabled); + let no_delay = !nagle_enabled; xous::return_scalar( msg.sender, - if socket.nagle_enabled().is_some() { + if no_delay { 1 } else { 0 @@ -972,7 +1019,9 @@ fn main() -> ! { { let socket = iface.get_socket::(*connection); let args = msg.body.scalar_message().unwrap(); - socket.set_nagle_enabled(args.arg1 != 0); + let no_delay = args.arg1 != 0; + log::info!("setting nagle to {}", !no_delay); + socket.set_nagle_enabled(!no_delay); xous::return_scalar(msg.sender, 0).ok(); } else { respond_with_error(msg, NetError::Invalid); @@ -1353,7 +1402,12 @@ fn main() -> ! { } let body = env.body.memory_message_mut().unwrap(); - match socket.recv_slice(body.buf.as_slice_mut()) { + let buflen = if let Some(valid) = body.valid { + valid.get() + } else { + 0 + }; + match socket.recv_slice(&mut body.buf.as_slice_mut()[..buflen]) { Ok(count) => { log::debug!("rxrcv of {}", count); body.valid = xous::MemorySize::new(count); @@ -1367,6 +1421,79 @@ fn main() -> ! { } } + // This block handles TCP Peek for libstd callers + log::trace!("pump: tcp peek"); + for connection in tcp_peek_waiting.iter_mut() { + let socket; + let WaitingSocket { + mut env, + handle: _, + expiry: _, + } = { + match connection { + &mut None => continue, + Some(s) => { + socket = iface.get_socket::(s.handle); + log::debug!("peek_state: {:?} {:?}", socket.state(), socket.local_endpoint()); + if !socket.can_recv() { + if let Some(trigger) = s.expiry { + log::debug!("rx peek {:?}", trigger.get()); + if trigger.get() < now { + // timer expired + } else { + continue; + } + } else if socket.state() == smoltcp::socket::TcpState::CloseWait + // this state added to handle the auto-close edge case on a remote hang-up + || socket.state() == smoltcp::socket::TcpState::Closed { + // stop waiting if we're in CloseWait, as we don't plan to transmit + } else { + continue; + } + } + } + } + connection.take().unwrap() + }; + + // If it can't receive, then the only explanation was that it timed out + if !socket.can_recv() { + if socket.state() == smoltcp::socket::TcpState::CloseWait + // this state added to handle the auto-close edge case on a remote hang-up + || socket.state() == smoltcp::socket::TcpState::Closed { + log::debug!("peekrcv connection closed"); + let body = env.body.memory_message_mut().unwrap(); + log::debug!("peekrcv of {}", 0); + body.valid = xous::MemorySize::new(0); + body.offset = xous::MemoryAddress::new(1); + continue; + } else { + log::debug!("peekrcv timed out"); + respond_with_error(env, NetError::TimedOut); + continue; + } + } + + let body = env.body.memory_message_mut().unwrap(); + let buflen = if let Some(valid) = body.valid { + valid.get() + } else { + 0 + }; + match socket.peek_slice(&mut body.buf.as_slice_mut()[..buflen]) { + Ok(count) => { + log::debug!("peekrcv of {}", count); + body.valid = xous::MemorySize::new(count); + body.offset = xous::MemoryAddress::new(1); + } + Err(e) => { + log::debug!("unable to peek: {:?}", e); + body.offset = None; + body.valid = None; + } + } + } + // This block handles TCP Tx for libstd callers log::trace!("pump: tcp tx"); for connection in tcp_tx_waiting.iter_mut() { @@ -1543,7 +1670,9 @@ fn main() -> ! { // when either condition is met. if !socket.may_send() || socket.send_queue() == 0 { socket.close(); - tcp_tx_wait_fin.push((*handle, *sender)); + tcp_tx_wait_fin.push((*handle, *sender, 0)); + //log::info!("EARLY CLOSE"); + //xous::return_scalar(*sender, 0).ok(); // ack early so we don't block other processes waiting to close false } else { true @@ -1553,18 +1682,31 @@ fn main() -> ! { } }); - tcp_tx_wait_fin.retain(|(handle, sender)| { + tcp_tx_wait_fin.retain_mut(|(handle, sender, count)| { let socket = iface.get_socket::(*handle); - if !socket.is_open() { + // count is a heuristic to stop TcpClose from blocking too long + // most implementations are fully non-blocking, we need to block on Xous + // to allow smoltcp to process correctly. However, the socket will stick + // around forever if the final ack doesn't arrive, and this gums up the works. + // FORCE_CLOSE_COUNT is an arbitrary threshold where we just decide to stop waiting for the other + // side to send the final ack: it's long enough that it almost never times out + // incorrectly, but short enough that we're not keeping around baggage forever. + const FORCE_CLOSE_COUNT: u32 = 8; + if !socket.is_open() || *count > FORCE_CLOSE_COUNT { + if *count > FORCE_CLOSE_COUNT { + log::warn!("forced close on {:?}", socket.local_endpoint()); + } log::debug!("socket closed {:?}", socket.local_endpoint()); iface.remove_socket(*handle); tcp_server_remote_close_poll.retain(|x| { *x != *handle }); + log::info!("would return_scalar now"); xous::return_scalar(*sender, 0).ok(); false } else { - log::debug!("socket waiting to close: {:?} {:?}->{:?}", socket.state(), socket.local_endpoint(), socket.remote_endpoint()); + *count += 1; + log::debug!("socket waiting to close({}): {:?} {:?}->{:?}", count, socket.state(), socket.local_endpoint(), socket.remote_endpoint()); true } });