mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-18 08:52:45 +00:00
Merge branch 'bunnie-dev' into main
This commit is contained in:
commit
f3e3c5cc18
7 changed files with 214 additions and 194 deletions
|
|
@ -795,7 +795,7 @@ fn xmain() -> ! {
|
||||||
use crate::implementation::Engine25519Hw;
|
use crate::implementation::Engine25519Hw;
|
||||||
|
|
||||||
log_server::init_wait().unwrap();
|
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());
|
log::info!("my PID is {}", xous::process::id());
|
||||||
|
|
||||||
let xns = xous_names::XousNames::new().unwrap();
|
let xns = xous_names::XousNames::new().unwrap();
|
||||||
|
|
|
||||||
|
|
@ -595,6 +595,7 @@ fn xmain() -> ! {
|
||||||
let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; TCP_BUFFER_SIZE]);
|
let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; TCP_BUFFER_SIZE]);
|
||||||
let tcp_tx_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);
|
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) {
|
match tcp_socket.listen(tcpspec.local_port) {
|
||||||
Ok(_) => {
|
Ok(_) => {
|
||||||
if let Some(list) = tcp_listeners.get(&tcpspec.local_port) {
|
if let Some(list) = tcp_listeners.get(&tcpspec.local_port) {
|
||||||
|
|
@ -607,6 +608,7 @@ fn xmain() -> ! {
|
||||||
let handle = sockets.add(tcp_socket);
|
let handle = sockets.add(tcp_socket);
|
||||||
let sid = tcpspec.cb_sid;
|
let sid = tcpspec.cb_sid;
|
||||||
let cid = xous::connect(SID::from_array(sid)).unwrap();
|
let cid = xous::connect(SID::from_array(sid)).unwrap();
|
||||||
|
log::trace!("Listener with cid {}, sid {:x?} registered", cid, sid);
|
||||||
let tcp_cb_state = TcpState {
|
let tcp_cb_state = TcpState {
|
||||||
handle,
|
handle,
|
||||||
cid,
|
cid,
|
||||||
|
|
@ -614,10 +616,11 @@ fn xmain() -> ! {
|
||||||
};
|
};
|
||||||
if let Some(list) = tcp_listeners.get_mut(&tcpspec.local_port) {
|
if let Some(list) = tcp_listeners.get_mut(&tcpspec.local_port) {
|
||||||
list.push(tcp_cb_state);
|
list.push(tcp_cb_state);
|
||||||
|
log::trace!("total listeners on port {}: {}", tcpspec.local_port, list.len());
|
||||||
} else {
|
} else {
|
||||||
tcp_listeners.insert(tcpspec.local_port, vec![tcp_cb_state]);
|
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);
|
tcpspec.result = Some(NetMemResponse::Ok);
|
||||||
}
|
}
|
||||||
Err(e) => {
|
Err(e) => {
|
||||||
|
|
@ -644,7 +647,7 @@ fn xmain() -> ! {
|
||||||
if let Some(listener) = tcp_listeners.get_mut(&tcpspec.local_port.unwrap()) {
|
if let Some(listener) = tcp_listeners.get_mut(&tcpspec.local_port.unwrap()) {
|
||||||
if let Some(tcp_state) = listener.pop() {
|
if let Some(tcp_state) = listener.pop() {
|
||||||
sockets.get::<TcpSocket>(tcp_state.handle).close();
|
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);
|
sockets.remove(tcp_state.handle);
|
||||||
tcpspec.result = Some(NetMemResponse::Ok);
|
tcpspec.result = Some(NetMemResponse::Ok);
|
||||||
// this may leave an empty vector in the tcp_listeners structure, but I think that's 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
|
// TcpListener to a regular TcpStream client (that is, an Rx packet forwarded before the
|
||||||
// TcpStream is fully built).
|
// TcpStream is fully built).
|
||||||
if tcp_listeners.len() > 0 { // skip the whole chunk if we don't have any tcp listeners
|
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();
|
let mut remove_indices = Vec::<usize>::new();
|
||||||
for (index, tcp_state) in tcp_state_vec.iter().enumerate() {
|
for (index, tcp_state) in tcp_state_vec.iter().enumerate() {
|
||||||
let socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
let socket = sockets.get::<TcpSocket>(tcp_state.handle);
|
||||||
if socket.is_active() {
|
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)
|
// 1. promote this socket to a TCP rx socket (this creates a double-entry that is cleaned up in step 3)
|
||||||
let connection = TcpConnection {
|
let connection = TcpConnection {
|
||||||
remote: socket.remote_endpoint().addr,
|
remote: socket.remote_endpoint().addr,
|
||||||
|
|
@ -1083,10 +1087,14 @@ fn xmain() -> ! {
|
||||||
remote_port: socket.remote_endpoint().port,
|
remote_port: socket.remote_endpoint().port,
|
||||||
local_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");
|
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");
|
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);
|
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
|
// 3. now cleanup and remove the ports from the listeners status
|
||||||
|
|
@ -1094,7 +1102,9 @@ fn xmain() -> ! {
|
||||||
remove_indices.reverse();
|
remove_indices.reverse();
|
||||||
for index in remove_indices {
|
for index in remove_indices {
|
||||||
tcp_state_vec.remove(index);
|
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
|
// 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.
|
// listener if the TcpListener is being used in an `incoming` loop.
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -65,7 +65,7 @@ impl TcpListener {
|
||||||
rx_buf.lock().unwrap().reserve(TCP_BUFFER_SIZE);
|
rx_buf.lock().unwrap().reserve(TCP_BUFFER_SIZE);
|
||||||
let notify = Arc::new(Mutex::new(XousScalarEndpoint::new()));
|
let notify = Arc::new(Mutex::new(XousScalarEndpoint::new()));
|
||||||
let listener_info = Arc::new(Mutex::new(None::<NetTcpListenCallback>));
|
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(
|
let _handle = crate::tcp_rx_thread(
|
||||||
cb_sid.clone(),
|
cb_sid.clone(),
|
||||||
Arc::clone(&rx_buf),
|
Arc::clone(&rx_buf),
|
||||||
|
|
@ -78,13 +78,13 @@ impl TcpListener {
|
||||||
local_port: socket.port(),
|
local_port: socket.port(),
|
||||||
result: None,
|
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)
|
let mut buf = Buffer::into_buf(request)
|
||||||
.or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?;
|
.or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?;
|
||||||
buf.lend_mut(net.conn(), Opcode::TcpListen.to_u32().unwrap())
|
buf.lend_mut(net.conn(), Opcode::TcpListen.to_u32().unwrap())
|
||||||
.or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?;
|
.or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?;
|
||||||
let ret = buf.to_original::<NetTcpListen, _>().unwrap();
|
let ret = buf.to_original::<NetTcpListen, _>().unwrap();
|
||||||
log::info!("Got result: {:?}", ret.result);
|
log::debug!("Got result: {:?}", ret.result);
|
||||||
match ret.result {
|
match ret.result {
|
||||||
Some(NetMemResponse::Ok) => {
|
Some(NetMemResponse::Ok) => {
|
||||||
Ok(TcpListener {
|
Ok(TcpListener {
|
||||||
|
|
@ -116,12 +116,12 @@ impl TcpListener {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn accept(&mut self) -> io::Result<(TcpStream, SocketAddr)> {
|
pub fn accept(&mut self) -> io::Result<(TcpStream, SocketAddr)> {
|
||||||
let mut prints = 0;
|
|
||||||
loop {
|
loop {
|
||||||
|
log::trace!("listener Arc count: {}", Arc::strong_count(&self.listener_info));
|
||||||
let accepted = if let Some(info) = self.listener_info.lock().unwrap().take() {
|
let accepted = if let Some(info) = self.listener_info.lock().unwrap().take() {
|
||||||
// 1. Create a new TcpStream object using our existing handles
|
// 1. Create a new TcpStream object using our existing handles
|
||||||
let remote = SocketAddr::new(IpAddr::from(info.ip_addr), info.remote_port);
|
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(
|
let stream = TcpStream::build_from_listener(
|
||||||
NetConn::new(&self.xns).unwrap(),
|
NetConn::new(&self.xns).unwrap(),
|
||||||
self.cb_sid,
|
self.cb_sid,
|
||||||
|
|
@ -133,13 +133,13 @@ impl TcpListener {
|
||||||
);
|
);
|
||||||
Some((stream, remote))
|
Some((stream, remote))
|
||||||
} else {
|
} else {
|
||||||
|
log::trace!("Accept: found no incoming TCP, waiting... {:?}, {:?}", self.listener_info, self.cb_sid);
|
||||||
if self.nonblocking {
|
if self.nonblocking {
|
||||||
return Err(Error::new(ErrorKind::WouldBlock, "accept would block"));
|
return Err(Error::new(ErrorKind::WouldBlock, "accept would block"));
|
||||||
}
|
}
|
||||||
None
|
None
|
||||||
};
|
};
|
||||||
if let Some((stream, remote)) = accepted {
|
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
|
// 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.listener_info = Arc::new(Mutex::new(None::<NetTcpListenCallback>));
|
||||||
self.cb_sid = xous::create_server().unwrap();
|
self.cb_sid = xous::create_server().unwrap();
|
||||||
|
|
@ -148,35 +148,34 @@ impl TcpListener {
|
||||||
if self.original_notify.is_set() {
|
if self.original_notify.is_set() {
|
||||||
let (c, o, a) = self.original_notify.get();
|
let (c, o, a) = self.original_notify.get();
|
||||||
self.rx_notify.lock().unwrap().set(c.unwrap(), o.unwrap(), a);
|
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(
|
let _handle = crate::tcp_rx_thread(
|
||||||
self.cb_sid.clone(),
|
self.cb_sid.clone(),
|
||||||
Arc::clone(&self.rx_buf),
|
Arc::clone(&self.rx_buf),
|
||||||
// we're re-using the notifier object...is this going to be a problem?
|
|
||||||
Arc::clone(&self.rx_notify),
|
Arc::clone(&self.rx_notify),
|
||||||
// this is not used by TcpStream
|
|
||||||
Arc::clone(&self.listener_info)
|
Arc::clone(&self.listener_info)
|
||||||
);
|
);
|
||||||
|
log::trace!("Accept created new thread with listener object: {:?}", self.listener_info);
|
||||||
let request = NetTcpListen {
|
let request = NetTcpListen {
|
||||||
cb_sid: self.cb_sid.to_array(),
|
cb_sid: self.cb_sid.to_array(),
|
||||||
local_port: stream.socket_addr().unwrap().port(),
|
local_port: stream.socket_addr().unwrap().port(),
|
||||||
result: None,
|
result: None,
|
||||||
};
|
};
|
||||||
|
log::trace!("Accept is registering a new listener: {:?}", request);
|
||||||
let mut buf = Buffer::into_buf(request)
|
let mut buf = Buffer::into_buf(request)
|
||||||
.or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?;
|
.or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?;
|
||||||
buf.lend_mut(self.net.conn(), Opcode::TcpListen.to_u32().unwrap())
|
buf.lend_mut(self.net.conn(), Opcode::TcpListen.to_u32().unwrap())
|
||||||
.or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?;
|
.or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?;
|
||||||
let ret = buf.to_original::<NetTcpListen, _>().unwrap();
|
let ret = buf.to_original::<NetTcpListen, _>().unwrap();
|
||||||
|
log::debug!("Listener registered with return code {:?}", ret.result);
|
||||||
return
|
return
|
||||||
match ret.result {
|
match ret.result {
|
||||||
Some(NetMemResponse::Ok) => Ok((stream, remote)),
|
Some(NetMemResponse::Ok) => Ok((stream, remote)),
|
||||||
_ => Err(Error::new(ErrorKind::Other, "can't renew Listener with Net server"))
|
_ => 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();
|
self.ticktimer.sleep_ms(LISTENER_POLL_INTERVAL_MS).unwrap();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -511,6 +511,7 @@ impl Drop for TcpStream {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// now we can detroy the server id of the responder thread
|
// 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();
|
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 buffer = unsafe {Buffer::from_memory_message(msg.body.memory_message().unwrap())};
|
||||||
let incoming = buffer.to_original::<NetTcpListenCallback, _>().unwrap();
|
let incoming = buffer.to_original::<NetTcpListenCallback, _>().unwrap();
|
||||||
// notify the caller that it should pick up its state
|
// 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);
|
*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
|
notify.lock().unwrap().notify(); // this will only notify if a destination has been set
|
||||||
}
|
}
|
||||||
Some(NetTcpCallback::Drop) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
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();
|
xous::return_scalar(msg.sender, 1).unwrap();
|
||||||
break;
|
break;
|
||||||
}),
|
}),
|
||||||
|
|
|
||||||
|
|
@ -488,7 +488,7 @@ pub(crate) fn ci_tests(pddb_os: &mut PddbOs) -> Result<()> {
|
||||||
EXTRA_BASIS, EXTRA_BASIS_PW, BasisRetentionPolicy::Persist) {
|
EXTRA_BASIS, EXTRA_BASIS_PW, BasisRetentionPolicy::Persist) {
|
||||||
basis_cache.basis_add(basis2);
|
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");
|
log::info!("Adding keys to Basis2");
|
||||||
delete_add_dict_consistency(pddb_os, &mut basis_cache, Some(3),
|
delete_add_dict_consistency(pddb_os, &mut basis_cache, Some(3),
|
||||||
Some(15), None, None, Some(EXTRA_BASIS))?;
|
Some(15), None, None, Some(EXTRA_BASIS))?;
|
||||||
|
|
|
||||||
|
|
@ -10,7 +10,6 @@ use std::io::Read;
|
||||||
pub struct NetCmd {
|
pub struct NetCmd {
|
||||||
udp: Option<net::UdpSocket>,
|
udp: Option<net::UdpSocket>,
|
||||||
udp_clone: Option<net::UdpSocket>,
|
udp_clone: Option<net::UdpSocket>,
|
||||||
tcp_listener: Option<net::TcpListener>,
|
|
||||||
callback_id: Option<u32>,
|
callback_id: Option<u32>,
|
||||||
callback_conn: u32,
|
callback_conn: u32,
|
||||||
udp_count: u32,
|
udp_count: u32,
|
||||||
|
|
@ -22,7 +21,6 @@ impl NetCmd {
|
||||||
NetCmd {
|
NetCmd {
|
||||||
udp: None,
|
udp: None,
|
||||||
udp_clone: None,
|
udp_clone: None,
|
||||||
tcp_listener: None,
|
|
||||||
callback_id: None,
|
callback_id: None,
|
||||||
callback_conn: xns.request_connection_blocking(crate::SERVER_NAME_SHELLCHAT).unwrap(),
|
callback_conn: xns.request_connection_blocking(crate::SERVER_NAME_SHELLCHAT).unwrap(),
|
||||||
udp_count: 0,
|
udp_count: 0,
|
||||||
|
|
@ -36,7 +34,6 @@ impl NetCmd {
|
||||||
pub(crate) enum NetCmdDispatch {
|
pub(crate) enum NetCmdDispatch {
|
||||||
UdpTest1 = 0x1_0000, // we're muxing our own dispatch + ping dispatch, so we need a custom discriminant
|
UdpTest1 = 0x1_0000, // we're muxing our own dispatch + ping dispatch, so we need a custom discriminant
|
||||||
UdpTest2 = 0x1_0001,
|
UdpTest2 = 0x1_0001,
|
||||||
TcpServer = 0x2_0000,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub const UDP_TEST_SIZE: usize = 64;
|
pub const UDP_TEST_SIZE: usize = 64;
|
||||||
|
|
@ -115,16 +112,83 @@ impl<'a> ShellCmdApi<'a> for NetCmd {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
"server" => {
|
"server" => {
|
||||||
let mut listener = net::TcpListener::bind_xous(
|
// PLEASE NOTE:
|
||||||
"127.0.0.1:80"
|
// Trying to make a TCP server of some kind? Don't be shy to open an issue at
|
||||||
).unwrap();
|
// https://github.com/betrusted-io/xous-core/issues. The TCP stack is very thinly
|
||||||
listener.set_scalar_notification(
|
// tested. Also, this is not a "real" web server, obviously -- so it's going to have quirks,
|
||||||
self.callback_conn,
|
// such as Firefox reporting that connections have been reset because this doesn't implement
|
||||||
self.callback_id.unwrap() as usize,
|
// a complete HTTP life cycle.
|
||||||
[Some(NetCmdDispatch::TcpServer.to_usize().unwrap()), None, None, None]
|
let _ = std::thread::spawn({
|
||||||
);
|
let mut listener = net::TcpListener::bind_xous(
|
||||||
// listener.set_nonblocking(true).unwrap(); // we shouldn't need to block because we only check once we're notified
|
"127.0.0.1:80"
|
||||||
self.tcp_listener = Some(listener);
|
).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();
|
write!(ret, "TCP listener started on port 80").unwrap();
|
||||||
}
|
}
|
||||||
// Testing of udp is done with netcat:
|
// 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;
|
use core::fmt::Write;
|
||||||
|
|
||||||
log::debug!("net callback");
|
log::debug!("net callback");
|
||||||
let mut ret = String::<1024>::new();
|
let mut ret = String::<1024>::new();
|
||||||
xous::msg_scalar_unpack!(msg, arg1, arg2, arg3, arg4, {
|
match &msg.body {
|
||||||
let dispatch = arg1;
|
xous::Message::Scalar(xous::ScalarMessage {id: _, arg1, arg2, arg3, arg4}) => {
|
||||||
match FromPrimitive::from_usize(dispatch) {
|
let dispatch = *arg1;
|
||||||
Some(NetCmdDispatch::UdpTest1) => {
|
match FromPrimitive::from_usize(dispatch) {
|
||||||
if let Some(udp_socket) = &mut self.udp {
|
Some(NetCmdDispatch::UdpTest1) => {
|
||||||
let mut pkt: [u8; UDP_TEST_SIZE] = [0; UDP_TEST_SIZE];
|
if let Some(udp_socket) = &mut self.udp {
|
||||||
match udp_socket.recv_from(&mut pkt) {
|
let mut pkt: [u8; UDP_TEST_SIZE] = [0; UDP_TEST_SIZE];
|
||||||
Ok((len, addr)) => {
|
match udp_socket.recv_from(&mut pkt) {
|
||||||
write!(ret, "UDP rx {} bytes: {:?}: {}\n", len, addr, std::str::from_utf8(&pkt[..len]).unwrap()).unwrap();
|
Ok((len, addr)) => {
|
||||||
log::info!("UDP rx {} bytes: {:?}: {:?}", len, addr, &pkt[..len]);
|
write!(ret, "UDP rx {} bytes: {:?}: {}\n", len, addr, std::str::from_utf8(&pkt[..len]).unwrap()).unwrap();
|
||||||
self.udp_count += 1;
|
log::info!("UDP rx {} bytes: {:?}: {:?}", len, addr, &pkt[..len]);
|
||||||
|
self.udp_count += 1;
|
||||||
|
|
||||||
let response_addr = SocketAddr::new(
|
let response_addr = SocketAddr::new(
|
||||||
addr.ip(),
|
addr.ip(),
|
||||||
udp_socket.socket_addr().unwrap().port()
|
udp_socket.socket_addr().unwrap().port()
|
||||||
);
|
);
|
||||||
match udp_socket.send_to(
|
match udp_socket.send_to(
|
||||||
format!("Received {} packets\n\r", self.udp_count).as_bytes(),
|
format!("Received {} packets\n\r", self.udp_count).as_bytes(),
|
||||||
&response_addr
|
&response_addr
|
||||||
) {
|
) {
|
||||||
Ok(len) => write!(ret, "UDP tx {} bytes", len).unwrap(),
|
Ok(len) => write!(ret, "UDP tx {} bytes", len).unwrap(),
|
||||||
Err(_) => write!(ret, "UDP tx err").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");
|
Some(NetCmdDispatch::UdpTest2) => {
|
||||||
write!(ret, "Got NetCmd callback from uninitialized socket").unwrap();
|
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) {
|
||||||
Some(NetCmdDispatch::UdpTest2) => {
|
Ok((len, addr)) => {
|
||||||
if let Some(udp_socket) = &mut self.udp_clone {
|
write!(ret, "Clone UDP rx {} bytes: {:?}: {}\n", len, addr, std::str::from_utf8(&pkt[..len]).unwrap()).unwrap();
|
||||||
let mut pkt: [u8; UDP_TEST_SIZE] = [0; UDP_TEST_SIZE];
|
log::info!("Clone UDP rx {} bytes: {:?}: {:?}", len, addr, &pkt[..len]);
|
||||||
match udp_socket.recv_from(&mut pkt) {
|
self.udp_count += 1;
|
||||||
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(
|
let response_addr = SocketAddr::new(
|
||||||
addr.ip(),
|
addr.ip(),
|
||||||
udp_socket.socket_addr().unwrap().port()
|
udp_socket.socket_addr().unwrap().port()
|
||||||
);
|
);
|
||||||
match udp_socket.send_to(
|
match udp_socket.send_to(
|
||||||
format!("Clone received {} packets\n\r", self.udp_count).as_bytes(),
|
format!("Clone received {} packets\n\r", self.udp_count).as_bytes(),
|
||||||
&response_addr
|
&response_addr
|
||||||
) {
|
) {
|
||||||
Ok(len) => write!(ret, "UDP tx {} bytes", len).unwrap(),
|
Ok(len) => write!(ret, "UDP tx {} bytes", len).unwrap(),
|
||||||
Err(e) => write!(ret, "UDP tx err: {:?}", e).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();
|
|
||||||
}
|
}
|
||||||
|
},
|
||||||
|
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) => {
|
} else {
|
||||||
write!(ret, "Got error on TCP accept: {:?}", e).unwrap();
|
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();
|
}
|
||||||
}
|
},
|
||||||
},
|
xous::Message::Move(m) => {
|
||||||
None => {
|
let s = xous_ipc::String::<512>::from_message(m).unwrap();
|
||||||
// rebind the scalar args to the Ping convention
|
write!(ret, "{}", s.as_str().unwrap()).unwrap();
|
||||||
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();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
}
|
}
|
||||||
});
|
_ => {
|
||||||
|
log::error!("got unecognized message type in callback handler")
|
||||||
|
}
|
||||||
|
}
|
||||||
Ok(Some(ret))
|
Ok(Some(ret))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -76,7 +76,7 @@ impl<const N: usize> String<N> {
|
||||||
|
|
||||||
/// Convert a `MemoryMessage` into a `String`
|
/// Convert a `MemoryMessage` into a `String`
|
||||||
pub fn from_message(
|
pub fn from_message(
|
||||||
message: &mut MemoryMessage,
|
message: &MemoryMessage,
|
||||||
) -> core::result::Result<String<N>, core::str::Utf8Error> {
|
) -> core::result::Result<String<N>, core::str::Utf8Error> {
|
||||||
let buf = unsafe { crate::Buffer::from_memory_message(message) };
|
let buf = unsafe { crate::Buffer::from_memory_message(message) };
|
||||||
let bytes = Pin::new(buf.as_ref());
|
let bytes = Pin::new(buf.as_ref());
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue