From 12190b91847478fc54928560efced7b40bf6218f Mon Sep 17 00:00:00 2001 From: bunnie Date: Sun, 17 Apr 2022 04:59:10 +0800 Subject: [PATCH] strip out the legacy xous Tcp stack implementation --- services/net/src/api.rs | 14 +- services/net/src/main.rs | 443 +--------------------------------- services/net/src/protocols.rs | 14 -- 3 files changed, 8 insertions(+), 463 deletions(-) diff --git a/services/net/src/api.rs b/services/net/src/api.rs index 217fc8537..777ba74b4 100644 --- a/services/net/src/api.rs +++ b/services/net/src/api.rs @@ -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 diff --git a/services/net/src/main.rs b/services/net/src/main.rs index 8662daf3b..0a128c84d 100644 --- a/services/net/src/main.rs +++ b/services/net/src/main.rs @@ -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::>::new(); let mut ping_timeout_ms = PING_DEFAULT_TIMEOUT_MS; - // tcp storage - let mut tcp_handles = HashMap::::new(); - let mut tcp_listeners = HashMap::>::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::().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::().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::(tcp_state.handle); - socket.set_nagle_enabled(value); - tcpspec.result = Some(NetMemResponse::Ok); - } - TcpMgmtCode::GetNoDelay(_) => { - let socket = sockets.get::(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::(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::(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::(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::(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::().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::(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::().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::(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::().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::(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::().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::(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::(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::(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::(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::::new(); - for (index, tcp_state) in tcp_state_vec.iter().enumerate() { - let socket = sockets.get::(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; diff --git a/services/net/src/protocols.rs b/services/net/src/protocols.rs index 274531806..8d4aa21d8 100644 --- a/services/net/src/protocols.rs +++ b/services/net/src/protocols.rs @@ -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::*;