diff --git a/services/engine-25519/src/main.rs b/services/engine-25519/src/main.rs index f2f3294e4..dbb1730e2 100644 --- a/services/engine-25519/src/main.rs +++ b/services/engine-25519/src/main.rs @@ -795,7 +795,7 @@ fn xmain() -> ! { use crate::implementation::Engine25519Hw; log_server::init_wait().unwrap(); - log::set_max_level(log::LevelFilter::Debug); + log::set_max_level(log::LevelFilter::Info); log::info!("my PID is {}", xous::process::id()); let xns = xous_names::XousNames::new().unwrap(); diff --git a/services/net/src/main.rs b/services/net/src/main.rs index 22e5c1d99..98f6f75c1 100644 --- a/services/net/src/main.rs +++ b/services/net/src/main.rs @@ -595,6 +595,7 @@ fn xmain() -> ! { 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) { @@ -607,6 +608,7 @@ fn xmain() -> ! { 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, @@ -614,10 +616,11 @@ fn xmain() -> ! { }; 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); } - log::info!("creating listener on port {}", tcpspec.local_port); tcpspec.result = Some(NetMemResponse::Ok); } Err(e) => { @@ -644,7 +647,7 @@ fn xmain() -> ! { 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::info!("closing one listener on port {:?}", tcpspec.local_port); + 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 @@ -1063,12 +1066,13 @@ fn xmain() -> ! { // 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 - for (&local_port, tcp_state_vec) in tcp_listeners.iter_mut() { + 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 {:?} to a stream", socket.local_endpoint()); + 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, @@ -1083,10 +1087,14 @@ fn xmain() -> ! { remote_port: socket.remote_endpoint().port, local_port, }; - log::info!("Listener active, notification sent to {}: {:?}", tcp_state.cid, note); + 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 @@ -1094,7 +1102,9 @@ fn xmain() -> ! { 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. diff --git a/services/net/src/protocols/tcp_listener.rs b/services/net/src/protocols/tcp_listener.rs index 1da707d33..571f873c3 100644 --- a/services/net/src/protocols/tcp_listener.rs +++ b/services/net/src/protocols/tcp_listener.rs @@ -65,7 +65,7 @@ impl TcpListener { rx_buf.lock().unwrap().reserve(TCP_BUFFER_SIZE); let notify = Arc::new(Mutex::new(XousScalarEndpoint::new())); let listener_info = Arc::new(Mutex::new(None::)); - + log::info!("TcpListener creating first thread with listener object: {:?}", listener_info); let _handle = crate::tcp_rx_thread( cb_sid.clone(), Arc::clone(&rx_buf), @@ -78,13 +78,13 @@ impl TcpListener { local_port: socket.port(), result: None, }; - log::info!("Attempting to bind a listener to port {}", socket.port()); + log::debug!("Attempting to bind a listener to port {}", socket.port()); let mut buf = Buffer::into_buf(request) .or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?; buf.lend_mut(net.conn(), Opcode::TcpListen.to_u32().unwrap()) .or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?; let ret = buf.to_original::().unwrap(); - log::info!("Got result: {:?}", ret.result); + log::debug!("Got result: {:?}", ret.result); match ret.result { Some(NetMemResponse::Ok) => { Ok(TcpListener { @@ -116,12 +116,12 @@ impl TcpListener { } pub fn accept(&mut self) -> io::Result<(TcpStream, SocketAddr)> { - let mut prints = 0; loop { + log::trace!("listener Arc count: {}", Arc::strong_count(&self.listener_info)); let accepted = if let Some(info) = self.listener_info.lock().unwrap().take() { // 1. Create a new TcpStream object using our existing handles let remote = SocketAddr::new(IpAddr::from(info.ip_addr), info.remote_port); - log::info!("building stream to {:?}", remote); + log::info!("Incoming TCP detected, building stream to {:?}", remote); let stream = TcpStream::build_from_listener( NetConn::new(&self.xns).unwrap(), self.cb_sid, @@ -133,13 +133,13 @@ impl TcpListener { ); Some((stream, remote)) } else { + log::trace!("Accept: found no incoming TCP, waiting... {:?}, {:?}", self.listener_info, self.cb_sid); if self.nonblocking { return Err(Error::new(ErrorKind::WouldBlock, "accept would block")); } None }; if let Some((stream, remote)) = accepted { - log::info!("replenishing listener, notifier: {:?}", self.rx_notify); // 2. Replenish our Listener objects and pass a TcpListen message on to the Net manager to repeat the cycle self.listener_info = Arc::new(Mutex::new(None::)); self.cb_sid = xous::create_server().unwrap(); @@ -148,35 +148,34 @@ impl TcpListener { if self.original_notify.is_set() { let (c, o, a) = self.original_notify.get(); self.rx_notify.lock().unwrap().set(c.unwrap(), o.unwrap(), a); + log::debug!("Initializing listener with notifier: {:x?}", self.rx_notify.lock().unwrap()); } let _handle = crate::tcp_rx_thread( self.cb_sid.clone(), Arc::clone(&self.rx_buf), - // we're re-using the notifier object...is this going to be a problem? Arc::clone(&self.rx_notify), - // this is not used by TcpStream Arc::clone(&self.listener_info) ); + log::trace!("Accept created new thread with listener object: {:?}", self.listener_info); let request = NetTcpListen { cb_sid: self.cb_sid.to_array(), local_port: stream.socket_addr().unwrap().port(), result: None, }; + log::trace!("Accept is registering a new listener: {:?}", request); let mut buf = Buffer::into_buf(request) .or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?; buf.lend_mut(self.net.conn(), Opcode::TcpListen.to_u32().unwrap()) .or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?; let ret = buf.to_original::().unwrap(); + log::debug!("Listener registered with return code {:?}", ret.result); return match ret.result { Some(NetMemResponse::Ok) => Ok((stream, remote)), _ => Err(Error::new(ErrorKind::Other, "can't renew Listener with Net server")) } } - if prints < 10 { - log::info!("accept polling..."); - prints += 1; - } + self.ticktimer.sleep_ms(LISTENER_POLL_INTERVAL_MS).unwrap(); } } diff --git a/services/net/src/protocols/tcp_stream.rs b/services/net/src/protocols/tcp_stream.rs index b599ee1b4..6638f1dbb 100644 --- a/services/net/src/protocols/tcp_stream.rs +++ b/services/net/src/protocols/tcp_stream.rs @@ -511,6 +511,7 @@ impl Drop for TcpStream { } } // now we can detroy the server id of the responder thread + log::info!("destroying tcp_stream {:x?}", self.cb_sid); xous::destroy_server(self.cb_sid).ok(); } } @@ -543,13 +544,13 @@ pub(crate) fn tcp_rx_thread( let buffer = unsafe {Buffer::from_memory_message(msg.body.memory_message().unwrap())}; let incoming = buffer.to_original::().unwrap(); // notify the caller that it should pick up its state - log::info!("Setting the notifier structure from {:?} to Some({:?})", listener, incoming); + log::debug!("Setting the notifier structure from {:?} to Some({:?})", listener, incoming); *listener.lock().unwrap() = Some(incoming); - log::info!("After: {:?}", listener); + log::info!("Set listener notify {:?} with {:?}", notify.lock().unwrap(), listener); notify.lock().unwrap().notify(); // this will only notify if a destination has been set } Some(NetTcpCallback::Drop) => msg_blocking_scalar_unpack!(msg, _, _, _, _, { - log::debug!("Drop received, exiting Tcp handler"); + log::info!("Drop Tcp callback handler with notifier {:?}, listener {:?}", notify, listener); xous::return_scalar(msg.sender, 1).unwrap(); break; }), diff --git a/services/pddb/src/tests.rs b/services/pddb/src/tests.rs index 86a58f45b..5fdf240f9 100644 --- a/services/pddb/src/tests.rs +++ b/services/pddb/src/tests.rs @@ -488,7 +488,7 @@ pub(crate) fn ci_tests(pddb_os: &mut PddbOs) -> Result<()> { EXTRA_BASIS, EXTRA_BASIS_PW, BasisRetentionPolicy::Persist) { basis_cache.basis_add(basis2); } - log::set_max_level(log::LevelFilter::Debug); + log::set_max_level(log::LevelFilter::Info); log::info!("Adding keys to Basis2"); delete_add_dict_consistency(pddb_os, &mut basis_cache, Some(3), Some(15), None, None, Some(EXTRA_BASIS))?; diff --git a/services/shellchat/src/cmds/net_cmd.rs b/services/shellchat/src/cmds/net_cmd.rs index 47f4eb5b8..9603313b8 100644 --- a/services/shellchat/src/cmds/net_cmd.rs +++ b/services/shellchat/src/cmds/net_cmd.rs @@ -10,7 +10,6 @@ use std::io::Read; pub struct NetCmd { udp: Option, udp_clone: Option, - tcp_listener: Option, callback_id: Option, callback_conn: u32, udp_count: u32, @@ -22,7 +21,6 @@ impl NetCmd { NetCmd { udp: None, udp_clone: None, - tcp_listener: None, callback_id: None, callback_conn: xns.request_connection_blocking(crate::SERVER_NAME_SHELLCHAT).unwrap(), udp_count: 0, @@ -36,7 +34,6 @@ impl NetCmd { pub(crate) enum NetCmdDispatch { UdpTest1 = 0x1_0000, // we're muxing our own dispatch + ping dispatch, so we need a custom discriminant UdpTest2 = 0x1_0001, - TcpServer = 0x2_0000, } pub const UDP_TEST_SIZE: usize = 64; @@ -115,16 +112,83 @@ impl<'a> ShellCmdApi<'a> for NetCmd { } } "server" => { - let mut listener = net::TcpListener::bind_xous( - "127.0.0.1:80" - ).unwrap(); - listener.set_scalar_notification( - self.callback_conn, - self.callback_id.unwrap() as usize, - [Some(NetCmdDispatch::TcpServer.to_usize().unwrap()), None, None, None] - ); - // listener.set_nonblocking(true).unwrap(); // we shouldn't need to block because we only check once we're notified - self.tcp_listener = Some(listener); + // PLEASE NOTE: + // Trying to make a TCP server of some kind? Don't be shy to open an issue at + // https://github.com/betrusted-io/xous-core/issues. The TCP stack is very thinly + // tested. Also, this is not a "real" web server, obviously -- so it's going to have quirks, + // such as Firefox reporting that connections have been reset because this doesn't implement + // a complete HTTP life cycle. + let _ = std::thread::spawn({ + let mut listener = net::TcpListener::bind_xous( + "127.0.0.1:80" + ).unwrap(); + let ticktimer = ticktimer_server::Ticktimer::new().unwrap(); + let callback_conn = self.callback_conn.clone(); + move || { + loop { + match listener.accept() { + Ok((mut stream, addr)) => { + let test_string = std::format!("Hello from Precursor!\n\rI have been up for {} ms.\n\r", ticktimer.elapsed_ms()); + let mut request = [0u8; 1024]; + // this is probably not the "right way" to handle this -- but the "keep-alive" from the browser makes us hang on the read + // which prevents us from answering requests from other browsers (because this is a single-threaded implementation of a server) + stream.set_read_timeout(Some(Duration::from_millis(2_000))).unwrap(); + match stream.read(&mut request) { + Ok(len) => { + let r = std::string::String::from_utf8_lossy(&request[..len]); + log::info!("Request received from {:?}: {}", stream.peer_addr().unwrap(), r); + // this works because the recipient will take only one type of memory message and it's a 512-byte length string. + xous_ipc::String::<512>::from_str(&r).send(callback_conn).unwrap(); + let mut tokens = r.split(' '); + let mut valid = true; + if let Some(verb) = tokens.next() { + if verb != "GET" { + log::info!("Expected GET, got {}", verb); + valid = false; + } + } + if let Some(path) = tokens.next() { + if path != "/" { + log::info!("We only know /, got {}", path); + valid = false; + } + } + if valid { + // now send a page back... + let page = format!("HTTP/1.1 200 OK\r\nContent-Type: text/plain; charset=utf-8\n\rContent-Length: {}\n\rConnection: close\n\r\n\r{}\n\r", + test_string.len(), + test_string); + log::info!("Responding with: {}", page); + write!(stream, "{}", page).unwrap(); + stream.flush().unwrap(); + log::info!("Sent a response {:?}", addr); + xous_ipc::String::<512>::from_str(format!("Sent 200 to {:?}", addr)).send(callback_conn).unwrap(); + } else { + let errstring = "Sorry, I have only one trick, and it's pretty dumb."; + let notfound = format!("HTTP/1.1 404 Not Found\n\rConnection: close\n\rContent-Type: text/plain; charset=utf-8\n\rContent-Length: {}\n\r\n\r{}\n\r", + errstring.len(), + errstring + ); + log::info!("Responding with: {}", notfound); + write!(stream, "{}", notfound).unwrap(); + stream.flush().unwrap(); + xous_ipc::String::<512>::from_str(format!("Sent 404 to {:?}", addr)).send(callback_conn).unwrap(); + } + } + Err(e) => { + log::info!("Stream was opened, but no request received: {:?}", e); + xous_ipc::String::<512>::from_str(format!("Socket opened but no request data received: {:?}", e)).send(callback_conn).unwrap(); + } + } + // stream should close automatically as `stream` goes out of scope here and Drop is called. + } + Err(e) => { + xous_ipc::String::<512>::from_str(format!("Got error on TCP accept: {:?}", e)).send(callback_conn).unwrap(); + } + } + } + } + }); write!(ret, "TCP listener started on port 80").unwrap(); } // Testing of udp is done with netcat: @@ -244,179 +308,125 @@ impl<'a> ShellCmdApi<'a> for NetCmd { } - fn callback(&mut self, msg: &MessageEnvelope, env: &mut CommonEnv) -> Result>, xous::Error> { + fn callback(&mut self, msg: &MessageEnvelope, _env: &mut CommonEnv) -> Result>, xous::Error> { use core::fmt::Write; log::debug!("net callback"); let mut ret = String::<1024>::new(); - xous::msg_scalar_unpack!(msg, arg1, arg2, arg3, arg4, { - let dispatch = arg1; - match FromPrimitive::from_usize(dispatch) { - Some(NetCmdDispatch::UdpTest1) => { - if let Some(udp_socket) = &mut self.udp { - let mut pkt: [u8; UDP_TEST_SIZE] = [0; UDP_TEST_SIZE]; - match udp_socket.recv_from(&mut pkt) { - Ok((len, addr)) => { - write!(ret, "UDP rx {} bytes: {:?}: {}\n", len, addr, std::str::from_utf8(&pkt[..len]).unwrap()).unwrap(); - log::info!("UDP rx {} bytes: {:?}: {:?}", len, addr, &pkt[..len]); - self.udp_count += 1; + match &msg.body { + xous::Message::Scalar(xous::ScalarMessage {id: _, arg1, arg2, arg3, arg4}) => { + let dispatch = *arg1; + match FromPrimitive::from_usize(dispatch) { + Some(NetCmdDispatch::UdpTest1) => { + if let Some(udp_socket) = &mut self.udp { + let mut pkt: [u8; UDP_TEST_SIZE] = [0; UDP_TEST_SIZE]; + match udp_socket.recv_from(&mut pkt) { + Ok((len, addr)) => { + write!(ret, "UDP rx {} bytes: {:?}: {}\n", len, addr, std::str::from_utf8(&pkt[..len]).unwrap()).unwrap(); + log::info!("UDP rx {} bytes: {:?}: {:?}", len, addr, &pkt[..len]); + self.udp_count += 1; - let response_addr = SocketAddr::new( - addr.ip(), - udp_socket.socket_addr().unwrap().port() - ); - match udp_socket.send_to( - format!("Received {} packets\n\r", self.udp_count).as_bytes(), - &response_addr - ) { - Ok(len) => write!(ret, "UDP tx {} bytes", len).unwrap(), - Err(_) => write!(ret, "UDP tx err").unwrap(), + let response_addr = SocketAddr::new( + addr.ip(), + udp_socket.socket_addr().unwrap().port() + ); + match udp_socket.send_to( + format!("Received {} packets\n\r", self.udp_count).as_bytes(), + &response_addr + ) { + Ok(len) => write!(ret, "UDP tx {} bytes", len).unwrap(), + Err(_) => write!(ret, "UDP tx err").unwrap(), + } + }, + Err(e) => { + log::error!("Net UDP error: {:?}", e); + write!(ret, "UDP receive error: {:?}", e).unwrap(); } - }, - Err(e) => { - log::error!("Net UDP error: {:?}", e); - write!(ret, "UDP receive error: {:?}", e).unwrap(); } + } else { + log::error!("Got NetCmd callback from uninitialized socket"); + write!(ret, "Got NetCmd callback from uninitialized socket").unwrap(); } - } else { - log::error!("Got NetCmd callback from uninitialized socket"); - write!(ret, "Got NetCmd callback from uninitialized socket").unwrap(); - } - }, - Some(NetCmdDispatch::UdpTest2) => { - if let Some(udp_socket) = &mut self.udp_clone { - let mut pkt: [u8; UDP_TEST_SIZE] = [0; UDP_TEST_SIZE]; - match udp_socket.recv_from(&mut pkt) { - Ok((len, addr)) => { - write!(ret, "Clone UDP rx {} bytes: {:?}: {}\n", len, addr, std::str::from_utf8(&pkt[..len]).unwrap()).unwrap(); - log::info!("Clone UDP rx {} bytes: {:?}: {:?}", len, addr, &pkt[..len]); - self.udp_count += 1; + }, + Some(NetCmdDispatch::UdpTest2) => { + if let Some(udp_socket) = &mut self.udp_clone { + let mut pkt: [u8; UDP_TEST_SIZE] = [0; UDP_TEST_SIZE]; + match udp_socket.recv_from(&mut pkt) { + Ok((len, addr)) => { + write!(ret, "Clone UDP rx {} bytes: {:?}: {}\n", len, addr, std::str::from_utf8(&pkt[..len]).unwrap()).unwrap(); + log::info!("Clone UDP rx {} bytes: {:?}: {:?}", len, addr, &pkt[..len]); + self.udp_count += 1; - let response_addr = SocketAddr::new( - addr.ip(), - udp_socket.socket_addr().unwrap().port() - ); - match udp_socket.send_to( - format!("Clone received {} packets\n\r", self.udp_count).as_bytes(), - &response_addr - ) { - Ok(len) => write!(ret, "UDP tx {} bytes", len).unwrap(), - Err(e) => write!(ret, "UDP tx err: {:?}", e).unwrap(), - } - }, - Err(e) => { - log::error!("Net UDP error: {:?}", e); - write!(ret, "UDP receive error: {:?}", e).unwrap(); - } - } - } else { - log::error!("Got NetCmd callback from uninitialized socket"); - write!(ret, "Got NetCmd callback from uninitialized socket").unwrap(); - } - }, - Some(NetCmdDispatch::TcpServer) => { - if let Some(listener) = &mut self.tcp_listener { - match listener.accept() { - Ok((mut stream, addr)) => { - let test_string = std::format!("Hello from Precursor!\n\rI have been up for {} ms.\n\r", env.ticktimer.elapsed_ms()); - let mut request = [0u8; 1024]; - match stream.read(&mut request) { - Ok(len) => { - let r = std::string::String::from_utf8_lossy(&request[..len]); - log::info!("Request received from {:?}: {}", stream.peer_addr().unwrap(), r); - write!(ret, "{}\n\n", r).unwrap(); - let mut tokens = r.split(' '); - let mut valid = true; - if let Some(verb) = tokens.next() { - if verb != "GET" { - log::info!("Expected GET, got {}", verb); - valid = false; - } - } - if let Some(path) = tokens.next() { - if path != "/" { - log::info!("We only know /, got {}", path); - valid = false; - } - } - if valid { - // now send a page back... - let page = format!("HTTP/1.1 200 OK\r\nContent-Type: text/plain; charset=utf-8\n\rContent-Length: {}\n\rConnection: close\n\r\n\r{}\n\r", - test_string.len(), - test_string); - log::info!("Responding with: {}", page); - write!(stream, "{}", page).unwrap(); - log::info!("Flushing response to {:?}", addr); - stream.flush().unwrap(); - log::info!("Sent a response {:?}", addr); - write!(ret, "Sent 200 to {:?}", addr).unwrap(); - } else { - let errstring = "Sorry, I have only one trick, and it's pretty dumb."; - let notfound = format!("HTTP/1.1 404 Not Found\n\rConnection: close\n\rContent-Type: text/plain; charset=utf-8\n\rContent-Length: {}\n\r\n\r{}\n\r", - errstring.len(), - errstring - ); - log::info!("Responding with: {}", notfound); - write!(stream, "{}", notfound).unwrap(); - stream.flush().unwrap(); - write!(ret, "Sent 404 to {:?}", addr).unwrap(); - } - } - Err(e) => { - log::info!("Stream was opened, but no request received: {:?}", e); - write!(ret, "Socket opened but no request data received: {:?}", e).unwrap(); + let response_addr = SocketAddr::new( + addr.ip(), + udp_socket.socket_addr().unwrap().port() + ); + match udp_socket.send_to( + format!("Clone received {} packets\n\r", self.udp_count).as_bytes(), + &response_addr + ) { + Ok(len) => write!(ret, "UDP tx {} bytes", len).unwrap(), + Err(e) => write!(ret, "UDP tx err: {:?}", e).unwrap(), } + }, + Err(e) => { + log::error!("Net UDP error: {:?}", e); + write!(ret, "UDP receive error: {:?}", e).unwrap(); } - // stream should close automatically as `stream` goes out of scope here and Drop is called. } - Err(e) => { - write!(ret, "Got error on TCP accept: {:?}", e).unwrap(); + } else { + log::error!("Got NetCmd callback from uninitialized socket"); + write!(ret, "Got NetCmd callback from uninitialized socket").unwrap(); + } + }, + None => { + // rebind the scalar args to the Ping convention + let op = arg1; + let addr = IpAddr::from((*arg2 as u32).to_be_bytes()); + let seq_or_addr = *arg3; + let timestamp = *arg4; + match FromPrimitive::from_usize(op & 0xFF) { + Some(NetPingCallback::Drop) => { + // write!(ret, "Info: All pending pings done").unwrap(); + // ignore the message, just creates visual noise + return Ok(None); + } + Some(NetPingCallback::NoErr) => { + match addr { + IpAddr::V4(_) => { + write!(ret, "Pong from {:?} seq {} received: {} ms", + addr, + seq_or_addr, + timestamp).unwrap(); + }, + IpAddr::V6(_) => { + write!(ret, "Ipv6 pong received: {} ms", timestamp).unwrap(); + }, + } + } + Some(NetPingCallback::Timeout) => { + write!(ret, "Ping to {:?} timed out", addr).unwrap(); + } + Some(NetPingCallback::Unreachable) => { + let code = net::Icmpv4DstUnreachable::from((op >> 24) as u8); + write!(ret, "Ping to {:?} unreachable: {:?}", addr, code).unwrap(); + } + None => { + log::error!("Unknown opcode received in NetCmd callback: {:?}", op); + write!(ret, "Unknown opcode received in NetCmd callback: {:?}", op).unwrap(); } } - } else { - write!(ret, "Got NetCmd callback for uninitialized server").unwrap(); - } - }, - None => { - // rebind the scalar args to the Ping convention - let op = arg1; - let addr = IpAddr::from((arg2 as u32).to_be_bytes()); - let seq_or_addr = arg3; - let timestamp = arg4; - match FromPrimitive::from_usize(op & 0xFF) { - Some(NetPingCallback::Drop) => { - // write!(ret, "Info: All pending pings done").unwrap(); - // ignore the message, just creates visual noise - return Ok(None); - } - Some(NetPingCallback::NoErr) => { - match addr { - IpAddr::V4(_) => { - write!(ret, "Pong from {:?} seq {} received: {} ms", - addr, - seq_or_addr, - timestamp).unwrap(); - }, - IpAddr::V6(_) => { - write!(ret, "Ipv6 pong received: {} ms", timestamp).unwrap(); - }, - } - } - Some(NetPingCallback::Timeout) => { - write!(ret, "Ping to {:?} timed out", addr).unwrap(); - } - Some(NetPingCallback::Unreachable) => { - let code = net::Icmpv4DstUnreachable::from((op >> 24) as u8); - write!(ret, "Ping to {:?} unreachable: {:?}", addr, code).unwrap(); - } - None => { - log::error!("Unknown opcode received in NetCmd callback: {:?}", op); - write!(ret, "Unknown opcode received in NetCmd callback: {:?}", op).unwrap(); - } - } - }, + }, + } + }, + xous::Message::Move(m) => { + let s = xous_ipc::String::<512>::from_message(m).unwrap(); + write!(ret, "{}", s.as_str().unwrap()).unwrap(); } - }); + _ => { + log::error!("got unecognized message type in callback handler") + } + } Ok(Some(ret)) } } diff --git a/xous-ipc/src/string.rs b/xous-ipc/src/string.rs index 4db0e64ac..d53876d9c 100644 --- a/xous-ipc/src/string.rs +++ b/xous-ipc/src/string.rs @@ -76,7 +76,7 @@ impl String { /// Convert a `MemoryMessage` into a `String` pub fn from_message( - message: &mut MemoryMessage, + message: &MemoryMessage, ) -> core::result::Result, core::str::Utf8Error> { let buf = unsafe { crate::Buffer::from_memory_message(message) }; let bytes = Pin::new(buf.as_ref());