TCP listener is "working"

Good enough so that if you type `net server` and you hit the IP
address of the device, it'll respond with something like

Hello from Precursor!
I have been up for 86087 ms.

There's still all kinds of bugs, I'm sure. But ... I'm also not
sure /why/ you would want a web server on Precursor. This is more
just to make sure that the TCP stack isn't totally broken.

The "web server" as it may be is quite broken and doesn't parse
any headers and probably sends a bogus amount of data because
I can't figure out if the content length includes some new lines
or not. But really, this just isn't in scope. Works with Chrome,
Firefox shows the status page and then says "connection reset" and hides
all the information. Whatever, browser compatibility is well beyond
my pay grade!
This commit is contained in:
bunnie 2022-02-01 18:54:07 +08:00
parent 1ebd5fe397
commit 925d53f646
10 changed files with 617 additions and 72 deletions

View file

@ -30,9 +30,10 @@ locales = {path = "../../locales"}
pddb = {path = "../pddb"}
[dependencies.smoltcp]
# ugh. have to reference `main` directly because they haven't pushed a new tag in months, and none
# of the worked examples match the actual documentation now.
# pin at a commit, at least, so we aren't building on shifting sand
# ugh. we startd pulling in smoltcp as they were just fixing a bunch of bugs and getting ready for a 0.8.0 release.
# this is the last commit that doesn't break things for Xous. They pulled in some random crate that isn't compatible
# with Xous in the commit after this -- we need to look into this and maybe send a PR so we can try to work with
# the latest smoltcp. But later...let's just get things even working first with what we have.
git = "https://github.com/smoltcp-rs/smoltcp.git"
rev = "35e833e33dfd3e4efc3eb7d5de06bec17c54b011"
#path = "../../../smoltcp"

View file

@ -41,6 +41,8 @@ pub(crate) enum Opcode {
TcpTx,
TcpClose,
TcpManage,
TcpListen,
TcpManageListener,
// The DNS server can hook the Net crate for notifications on config updates
/// Adds an Ipv4 as a DNS server
@ -290,6 +292,7 @@ impl fmt::Debug for NetIpAddr {
/// spaces: this is not the right object for passing messages from a remote server
/// in a potentially hostile foreign process into your local memory space.
/// See XousPrivateScalarHook for that function.
#[derive(Debug)]
pub(crate) struct XousScalarEndpoint {
cid: Option<xous::CID>,
op: Option<usize>,
@ -304,6 +307,9 @@ impl XousScalarEndpoint {
args: [None; 4]
}
}
pub(crate) fn get(&self) -> (Option<xous::CID>, Option<usize>, [Option<usize>; 4]) {
(self.cid, self.op, self.args)
}
pub(crate) fn set(&mut self, cid: xous::CID, op: usize, args: [Option<usize>; 4]) {
self.cid = Some(cid);
self.op = Some(op);

View file

@ -17,6 +17,20 @@ pub(crate) struct NetTcpManage {
pub(crate) mgmt_code: Option<TcpMgmtCode>,
}
#[derive(Debug, Archive, Serialize, Deserialize, Copy, Clone)]
pub(crate) struct NetTcpListen {
pub(crate) cb_sid: [u32; 4],
pub(crate) local_port: u16,
pub(crate) result: Option<NetMemResponse>,
}
#[derive(Debug, Archive, Serialize, Deserialize, Copy, Clone)]
pub(crate) struct NetTcpListenCallback {
pub(crate) ip_addr: NetIpAddr,
pub(crate) remote_port: u16,
pub(crate) local_port: u16,
}
#[derive(Debug, Archive, Serialize, Deserialize, Copy, Clone, PartialEq, Eq)]
pub(crate) enum TcpMgmtCode {
SetRxShutdown,
@ -26,11 +40,13 @@ pub(crate) enum TcpMgmtCode {
GetTtl(u32),
ErrorCheck(NetMemResponse),
Flush(bool),
CloseListener,
}
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
pub(crate) enum NetTcpCallback {
RxData,
ListenerActive,
Drop,
}

View file

@ -85,6 +85,7 @@ pub struct TcpConnection {
remote_port: u16,
local_port: u16,
}
#[derive(Copy, Clone, Debug)]
pub struct TcpState {
handle: SocketHandle,
cid: CID,
@ -178,6 +179,7 @@ fn xmain() -> ! {
// tcp storage
let mut tcp_handles = HashMap::<TcpConnection, TcpState>::new();
let mut tcp_listeners = HashMap::<u16, Vec::<TcpState>>::new();
// other link storage
let neighbor_cache = NeighborCache::new(BTreeMap::new());
@ -408,7 +410,7 @@ fn xmain() -> ! {
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 furhte differentiated by the return port
// 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);
@ -519,6 +521,10 @@ fn xmain() -> ! {
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);
@ -572,6 +578,7 @@ fn xmain() -> ! {
};
if let Some(tcp_state) = tcp_handles.remove(&connection) {
sockets.get::<TcpSocket>(tcp_state.handle).close();
sockets.remove(tcp_state.handle);
tcpspec.result = Some(NetMemResponse::Ok);
} else {
tcpspec.result = Some(NetMemResponse::Invalid);
@ -581,6 +588,106 @@ fn xmain() -> ! {
}
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::<NetTcpListen, _>().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);
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::<TcpSocket>(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();
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);
} else {
tcp_listeners.insert(tcpspec.local_port, vec![tcp_cb_state]);
}
log::info!("creating 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::<NetTcpManage, _>().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::<TcpSocket>(tcp_state.handle).close();
log::info!("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::<TcpSocket>(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::<TcpSocket>(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::UdpBind) => {
let mut buf = unsafe{Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())};
let udpspec = buf.to_original::<NetUdpBind, _>().unwrap();
@ -660,6 +767,7 @@ fn xmain() -> ! {
// if the clone map is nil, close the socket, we're done
None => {
sockets.get::<UdpSocket>(udpstate.handle).close();
sockets.remove(udpstate.handle);
buf.replace(NetMemResponse::Ok).unwrap();
}
// if the clone map has entries, promote an arbitrary map entry to the primary handle
@ -668,6 +776,7 @@ fn xmain() -> ! {
// removing SIDs doesn't remove the map, so it's possible to have an empty mapping. Get rid of it, and we're done.
udp_clones.remove(&udpspec.port);
sockets.get::<UdpSocket>(udpstate.handle).close();
sockets.remove(udpstate.handle);
buf.replace(NetMemResponse::Ok).unwrap();
} else {
// take an arbitrary key, re-insert it into the handles map.
@ -946,6 +1055,53 @@ fn xmain() -> ! {
}
}
// 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
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());
// 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::info!("Listener active, notification sent to {}: {:?}", 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");
remove_indices.push(index);
}
}
// 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);
}
// 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 UDP
{
for (port, udpstate) in udp_handles.iter() {

View file

@ -5,4 +5,6 @@ pub use dns::*;
pub mod ping;
pub use ping::*;
pub mod tcp_stream;
pub use tcp_stream::*;
pub use tcp_stream::*;
pub mod tcp_listener;
pub use tcp_listener::*;

View file

@ -1,52 +1,281 @@
use std::net::{IpAddr, Ipv4Addr, SocketAddr, ToSocketAddrs};
use std::unimplemented;
use std::io;
use std::io::{Error, ErrorKind, Result};
use std::sync::{Arc, Mutex};
use std::sync::atomic::{AtomicU32, Ordering};
use std::fmt;
use std::collections::VecDeque;
// this is if we need to be a server. implement this second.
pub struct TcpListener(!);
use xous::{Message, SID, CID};
use xous_ipc::Buffer;
use crate::TcpStream;
use crate::NetConn;
use crate::api::*;
use num_traits::*;
const LISTENER_POLL_INTERVAL_MS: usize = 250;
pub struct TcpListener {
net: NetConn,
cb_sid: SID,
ticktimer: ticktimer_server::Ticktimer,
xns: xous_names::XousNames,
refcount: Arc<AtomicU32>,
port: u16,
nonblocking: bool,
original_notify: XousScalarEndpoint,
// reserved for when the responder thread is "promoted" to active status
rx_buf: Arc::<Mutex::<VecDeque::<u8>>>,
/// xous-specific feature that allows for more efficent Rx than blocking. Caller must set_scalar_notification() to use it.
rx_notify: Arc<Mutex<XousScalarEndpoint>>,
listener_info: Arc<Mutex<Option<NetTcpListenCallback>>>,
}
impl TcpListener {
pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
unsupported()
pub fn bind(maybe_socket: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
TcpListener::bind_inner(maybe_socket)
}
pub fn socket_addr(&self) -> io::Result<SocketAddr> {
self.0
pub fn bind_xous<A: ToSocketAddrs>(addr: A) -> Result<TcpListener> {
match addr.to_socket_addrs() {
Ok(socks) => {
match socks.into_iter().next() {
Some(socket_addr) => {
TcpListener::bind_inner(
Ok(&socket_addr),
)
}
_ => Err(Error::new(ErrorKind::InvalidInput, "IP address invalid"))
}
}
_ => Err(Error::new(ErrorKind::InvalidInput, "IP address invalid"))
}
}
pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
self.0
pub fn bind_inner(maybe_socket: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
let socket = maybe_socket?;
let xns = xous_names::XousNames::new().unwrap();
let net = NetConn::new(&xns).unwrap();
let cb_sid = xous::create_server().unwrap();
let ticktimer = ticktimer_server::Ticktimer::new().unwrap();
let rx_buf = Arc::new(Mutex::new(VecDeque::<u8>::new()));
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>));
let _handle = crate::tcp_rx_thread(
cb_sid.clone(),
Arc::clone(&rx_buf),
Arc::clone(&notify),
// this is not used by TcpStream
Arc::clone(&listener_info)
);
let request = NetTcpListen {
cb_sid: cb_sid.to_array(),
local_port: socket.port(),
result: None,
};
log::info!("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);
match ret.result {
Some(NetMemResponse::Ok) => {
Ok(TcpListener {
net,
cb_sid,
ticktimer,
xns,
refcount: Arc::new(AtomicU32::new(1)), // one instance, that's me!
port: socket.port(),
rx_buf,
rx_notify: notify,
listener_info,
nonblocking: false,
original_notify: XousScalarEndpoint::new(),
})
}
_ => {
Err(Error::new(ErrorKind::Other, "can't create Listener with Net server"))
}
}
}
pub fn set_scalar_notification(&mut self, cid: CID, op: usize, args: [Option<usize>; 4]) {
self.original_notify.set(cid, op, args);
self.rx_notify.lock().unwrap().set(cid, op, args);
}
pub fn clear_scalar_notification(&mut self) {
self.original_notify.clear();
self.rx_notify.lock().unwrap().clear();
}
pub fn duplicate(&self) -> io::Result<TcpListener> {
self.0
pub fn accept(&mut self) -> io::Result<(TcpStream, SocketAddr)> {
let mut prints = 0;
loop {
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);
let stream = TcpStream::build_from_listener(
NetConn::new(&self.xns).unwrap(),
self.cb_sid,
remote,
info.local_port,
std::mem::replace(&mut self.rx_buf, Arc::new(Mutex::new(VecDeque::<u8>::new()))),
// we keep our notifier for ourself, create a new one for the passed-on thread
Arc::new(Mutex::new(XousScalarEndpoint::new())),
);
Some((stream, remote))
} else {
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();
// create a new notify arc/mutex, then copy the master notification settings there
self.rx_notify = Arc::new(Mutex::new(XousScalarEndpoint::new()));
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);
}
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)
);
let request = NetTcpListen {
cb_sid: self.cb_sid.to_array(),
local_port: stream.socket_addr().unwrap().port(),
result: None,
};
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();
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();
}
}
pub fn set_ttl(&self, _: u32) -> io::Result<()> {
self.0
pub fn local_addr(&self) -> io::Result<SocketAddr> {
Ok(SocketAddr::new(
IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
self.port
))
}
pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
self.tcp_manage(TcpMgmtCode::SetTtl(ttl)).map(|_| ())
}
pub fn ttl(&self) -> io::Result<u32> {
self.0
}
pub fn set_only_v6(&self, _: bool) -> io::Result<()> {
self.0
}
pub fn only_v6(&self) -> io::Result<bool> {
self.0
match self.tcp_manage(TcpMgmtCode::GetTtl(0)) {
Ok(TcpMgmtCode::GetTtl(value)) => Ok(value),
_ => Err(Error::new(ErrorKind::Other, "Internal error")),
}
}
/// I'm not really sure what this does on Xous, as we don't have a SO_ERROR value in our OS.
/// Just returning Ok(None) for now.
pub fn take_error(&self) -> io::Result<Option<io::Error>> {
self.0
Ok(None)
}
pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {
self.0
pub fn set_nonblocking(&mut self, setting: bool) -> io::Result<()> {
self.nonblocking = setting;
Ok(())
}
pub fn duplicate(&self) -> io::Result<TcpListener> {
Err(Error::new(ErrorKind::Other, "Xous does not support cloned listeners"))
}
fn tcp_manage(&self, code: TcpMgmtCode) -> io::Result<TcpMgmtCode> {
// only local_port is needed
let request = NetTcpManage {
cb_sid: self.cb_sid.to_array(),
ip_addr: NetIpAddr::Ipv4([127, 0, 0, 1]),
remote_port: 0,
local_port: Some(self.port),
timeout_ms: None,
keepalive_ms: None,
result: None,
mgmt_code: Some(code),
};
let mut buf = Buffer::into_buf(request)
.or(Err(Error::new(ErrorKind::Other, "can't manage TCP")))?;
buf.lend_mut(self.net.conn(), Opcode::TcpManageListener.to_u32().unwrap())
.or(Err(Error::new(ErrorKind::Other, "can't manage TCP")))?;
let ret = buf.to_original::<NetTcpManage, _>().unwrap();
if let Some(code) = ret.mgmt_code {
Ok(code)
} else {
Err(Error::new(ErrorKind::Other, "Internal error"))
}
}
}
impl fmt::Debug for TcpListener {
fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0
unimplemented!()
}
}
impl Drop for TcpListener {
fn drop(&mut self) {
if self.refcount.fetch_sub(1, Ordering::SeqCst) == 1 {
// the only thing we really need from the management structure for this call is the local port...
let request = NetTcpManage {
ip_addr: NetIpAddr::from(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))),
remote_port: 0, // bogus port
local_port: Some(self.port),
cb_sid: self.cb_sid.to_array(),
timeout_ms: None,
keepalive_ms: None,
result: None,
mgmt_code: Some(TcpMgmtCode::CloseListener),
};
let mut buf = Buffer::into_buf(request).expect("can't unregister with Net server");
buf.lend_mut(self.net.conn(), Opcode::TcpManageListener.to_u32().unwrap()).expect("can't unregister with Net server");
match buf.to_original().unwrap() {
NetMemResponse::Ok => {
let drop_cid = xous::connect(self.cb_sid).unwrap();
xous::send_message(
drop_cid,
Message::new_blocking_scalar(NetTcpCallback::Drop.to_usize().unwrap(), 0, 0, 0, 0)
).expect("couldn't send Drop to our repsonding server");
unsafe{xous::disconnect(drop_cid).ok()}; // should be safe because we're the only connection and the previous was a blocking scalar
},
_ => {
panic!("Couldn't unregister with net server");
}
}
// now we can detroy the server id of the responder thread
xous::destroy_server(self.cb_sid).ok();
}
}
}

View file

@ -13,7 +13,6 @@ use xous::{CID, Message, SID, msg_blocking_scalar_unpack};
use xous_ipc::Buffer;
use crate::NetConn;
use crate::api::*;
//use crate::api::udp::*;
use num_traits::*;
use std::net::Shutdown;
@ -45,6 +44,33 @@ pub struct TcpStream {
}
impl TcpStream {
/// This is routine that allows a TcpListener to create a TcpStream object. The following must be observed:
/// 1. The `cb_sid`, `rx_buf` and `rx_notify` are the memory locations mapped into the already-allocated Rx thread
/// 2. These fields are not to be re-used in the Listener object that succeeds the current one
pub(crate) fn build_from_listener(
net: NetConn,
cb_sid: SID,
remote: SocketAddr,
local_port: u16,
rx_buf: Arc::<Mutex::<VecDeque::<u8>>>,
rx_notify: Arc<Mutex<XousScalarEndpoint>>,
) -> TcpStream {
TcpStream {
net,
cb_sid,
socket_addr: remote,
local_port,
rx_buf,
rx_notify,
read_timeout: None,
write_timeout: None,
ticktimer: ticktimer_server::Ticktimer::new().unwrap(),
nonblocking: false,
rx_shutdown: false,
tx_shutdown: false,
rx_refcount: Arc::new(AtomicU32::new(1)),
}
}
pub fn connect(maybe_socket: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
TcpStream::connect_inner(maybe_socket, None, None)
}
@ -85,38 +111,13 @@ impl TcpStream {
rx_buf.lock().unwrap().reserve(TCP_BUFFER_SIZE);
let notify = Arc::new(Mutex::new(XousScalarEndpoint::new()));
let _handle = thread::spawn({
let cb_sid_clone = cb_sid.clone();
let rx_buf = Arc::clone(&rx_buf);
let notify = Arc::clone(&notify);
move || {
loop {
let msg = xous::receive_message(cb_sid_clone).unwrap();
match FromPrimitive::from_usize(msg.body.id()) {
Some(NetTcpCallback::RxData) => {
let buffer = unsafe {Buffer::from_memory_message(msg.body.memory_message().unwrap())};
let incoming = buffer.as_flat::<NetTcpResponse, _>().unwrap();
log::trace!("rx data({})", incoming.len);
{ // grab the lock once for better efficiency
let mut rx_locked = rx_buf.lock().unwrap();
for &d in incoming.data[..incoming.len as usize].iter() {
rx_locked.push_back(d);
}
}
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");
xous::return_scalar(msg.sender, 1).unwrap();
break;
}),
None => {
log::error!("got unknown message type on Tcp callback: {:?}", msg);
}
}
}
}
});
let _handle = tcp_rx_thread(
cb_sid.clone(),
Arc::clone(&rx_buf),
Arc::clone(&notify),
// this is not used by TcpStream
Arc::new(Mutex::new(None::<NetTcpListenCallback>)),
);
let request = NetTcpManage {
cb_sid: cb_sid.to_array(),
@ -321,8 +322,17 @@ impl TcpStream {
Ok(cloned_stream)
}
pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {
unimplemented!()
pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
if self.rx_buf.lock().unwrap().len() == 0 {
return Ok(0)
} else {
let rx_buf = self.rx_buf.lock().unwrap();
let readlen = rx_buf.len().min(buf.len());
for (&src, dst) in rx_buf.range(..readlen).zip(buf.iter_mut()) {
*dst = src;
}
return Ok(readlen)
}
}
}
@ -504,4 +514,50 @@ impl Drop for TcpStream {
xous::destroy_server(self.cb_sid).ok();
}
}
}
pub(crate) fn tcp_rx_thread(
cb_sid_clone: SID,
rx_buf: Arc::<Mutex::<VecDeque::<u8>>>,
notify: Arc::<Mutex::<XousScalarEndpoint>>,
listener: Arc::<Mutex::<Option<NetTcpListenCallback>>>,
) -> std::thread::JoinHandle<()> {
thread::spawn({
move || {
loop {
let msg = xous::receive_message(cb_sid_clone).unwrap();
match FromPrimitive::from_usize(msg.body.id()) {
Some(NetTcpCallback::RxData) => {
let buffer = unsafe {Buffer::from_memory_message(msg.body.memory_message().unwrap())};
let incoming = buffer.as_flat::<NetTcpResponse, _>().unwrap();
log::trace!("rx data({})", incoming.len);
{ // grab the lock once for better efficiency
let mut rx_locked = rx_buf.lock().unwrap();
for &d in incoming.data[..incoming.len as usize].iter() {
rx_locked.push_back(d);
}
}
notify.lock().unwrap().notify(); // this will only notify if a destination has been set
}
Some(NetTcpCallback::ListenerActive) => {
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);
*listener.lock().unwrap() = Some(incoming);
log::info!("After: {:?}", 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");
xous::return_scalar(msg.sender, 1).unwrap();
break;
}),
None => {
log::error!("got unknown message type on Tcp callback: {:?}", msg);
}
}
}
}
})
}

View file

@ -4,10 +4,13 @@ use net::{Duration, XousServerId, NetPingCallback};
use xous::MessageEnvelope;
use num_traits::*;
use std::net::{SocketAddr, IpAddr};
use std::io::Write;
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,
@ -19,6 +22,7 @@ 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,
@ -30,8 +34,9 @@ impl NetCmd {
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
pub(crate) enum NetCmdDispatch {
UdpTest1 = 0x1_0000, // we're muxing our own dispatch + ping dispatch, so we need a custom discriminant
UdpTest2 = 0x1_0001,
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;
@ -54,8 +59,6 @@ impl<'a> ShellCmdApi<'a> for NetCmd {
if let Some(sub_cmd) = tokens.next() {
match sub_cmd {
"tcpget" => {
use std::io::Write;
use std::io::Read;
// note: to keep shellchat lightweight, we do a very minimal parsing of the URL. We assume it always has
// a form such as:
// bunniefoo.com./bunnie/test.txt
@ -111,6 +114,19 @@ impl<'a> ShellCmdApi<'a> for NetCmd {
write!(ret, "Usage: tcpget bunniefoo.com/bunnie/test.txt").unwrap();
}
}
"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);
write!(ret, "TCP listener started on port 80").unwrap();
}
// Testing of udp is done with netcat:
// to send packets run `netcat -u <precursor ip address> 6502` on a remote host, and then type some data
// to receive packets, use `netcat -u -l 6502`, on the same remote host, and it should show a packet of counts received
@ -228,7 +244,7 @@ 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");
@ -298,6 +314,69 @@ impl<'a> ShellCmdApi<'a> for NetCmd {
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();
}
}
// 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 {
write!(ret, "Got NetCmd callback for uninitialized server").unwrap();
}
},
None => {
// rebind the scalar args to the Ping convention
let op = arg1;

View file

@ -6,7 +6,7 @@
"en-audio": "Measuring..."
},
"stats.disconnected": {
"ja": "接続されていません",
"ja": "接続不可",
"en": "Not connected",
"zh": "没有连接",
"en-audio": "Not connected"

View file

@ -475,7 +475,7 @@ fn xmain() -> ! {
log::info!("****************************************************************");
log::info!("Welcome to Xous {}", version::SEMVER);
log::info!("Built at {}", version::TIMESTAMP);
log::info!("Built on {}", version::TIMESTAMP);
log::info!("****************************************************************");
let ticktimer_server = xous::create_server_with_address(b"ticktimer-server")