TcpListener debugging, just a little bit

Spent a couple hours chasing down a "bug" which is acutally just
something about how http works that I don't understand. TCP was
working just fine but there is ... idk some sort of keep alive
thing that occupies a socket so the "web server" blocks waiting
for a read. Anyways, I guess the "right" way to solve that would
be to make a multi-threaded web server

OH GOD STOP

right. it's just a demo to prove that TCP works. done.

Open an issue if you find a problem with TCP kthx!
This commit is contained in:
bunnie 2022-02-02 00:23:14 +08:00
parent 925d53f646
commit 13de52fa8d
7 changed files with 214 additions and 194 deletions

View file

@ -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();

View file

@ -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::<TcpSocket>(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::<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 {:?} 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.

View file

@ -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::<NetTcpListenCallback>));
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::<NetTcpListen, _>().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::<NetTcpListenCallback>));
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::<NetTcpListen, _>().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();
}
}

View file

@ -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::<NetTcpListenCallback, _>().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;
}),

View file

@ -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))?;

View file

@ -10,7 +10,6 @@ use std::io::Read;
pub struct NetCmd {
udp: Option<net::UdpSocket>,
udp_clone: Option<net::UdpSocket>,
tcp_listener: Option<net::TcpListener>,
callback_id: Option<u32>,
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<Option<String::<1024>>, xous::Error> {
fn callback(&mut self, msg: &MessageEnvelope, _env: &mut CommonEnv) -> Result<Option<String::<1024>>, 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))
}
}

View file

@ -76,7 +76,7 @@ impl<const N: usize> String<N> {
/// Convert a `MemoryMessage` into a `String`
pub fn from_message(
message: &mut MemoryMessage,
message: &MemoryMessage,
) -> core::result::Result<String<N>, core::str::Utf8Error> {
let buf = unsafe { crate::Buffer::from_memory_message(message) };
let bytes = Pin::new(buf.as_ref());