mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
implement UDP rx
This commit is contained in:
parent
3cf1cbaeb6
commit
e6643e725d
9 changed files with 696 additions and 19 deletions
3
Cargo.lock
generated
3
Cargo.lock
generated
|
|
@ -1246,12 +1246,13 @@ dependencies = [
|
|||
"log-server",
|
||||
"num-derive",
|
||||
"num-traits",
|
||||
"rkyv 0.7.18",
|
||||
"rkyv 0.4.3",
|
||||
"smoltcp",
|
||||
"susres",
|
||||
"ticktimer-server",
|
||||
"utralib",
|
||||
"xous",
|
||||
"xous-ipc",
|
||||
"xous-names",
|
||||
]
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,8 @@
|
|||
pub(crate) const SERVER_NAME_COM: &str = "_COM manager_";
|
||||
pub use com_rs_ref::serdes::Ipv4Conf;
|
||||
|
||||
pub const NET_MTU: usize = 1500;
|
||||
// extra 30 bytes for the header over 1500
|
||||
pub const NET_MTU: usize = 1530;
|
||||
#[derive(Debug, Default, Copy, Clone, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
|
||||
pub struct BattStats {
|
||||
/// instantaneous voltage in mV
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ description = "Network middleware"
|
|||
|
||||
[dependencies]
|
||||
xous = { path = "../../xous-rs" }
|
||||
xous-ipc = {path="../../xous-ipc"}
|
||||
log-server = { path = "../log-server" }
|
||||
ticktimer-server = { path = "../ticktimer-server" }
|
||||
xous-names = { path = "../xous-names" }
|
||||
|
|
@ -14,7 +15,8 @@ log = "0.4"
|
|||
num-derive = {version = "0.3", default-features = false}
|
||||
num-traits = {version = "0.2", default-features = false}
|
||||
susres = {path = "../susres"}
|
||||
rkyv = "0.7.18"
|
||||
#rkyv = "0.7.18"
|
||||
rkyv = {version = "0.4.3", features = ["const_generics"], default-features = false}
|
||||
llio = {path = "../llio"}
|
||||
com = {path = "../com"}
|
||||
byteorder = { version = "1.0", default-features = false }
|
||||
|
|
|
|||
|
|
@ -1,7 +1,20 @@
|
|||
use rkyv::{Archive, Deserialize, Serialize};
|
||||
use std::net::SocketAddr;
|
||||
use smoltcp::wire::IpAddress;
|
||||
|
||||
pub(crate) const SERVER_NAME_NET: &str = "_Middleware Network Server_";
|
||||
|
||||
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
||||
pub(crate) enum Opcode {
|
||||
UdpBind,
|
||||
UdpClose,
|
||||
|
||||
/// initiates a ping packet
|
||||
//PingSend,
|
||||
|
||||
/// subscription for network responses
|
||||
//NetCallbackSubscribe,
|
||||
|
||||
/// [Internal] com llio interrupt callback
|
||||
ComInterrupt,
|
||||
|
||||
|
|
@ -11,3 +24,144 @@ pub(crate) enum Opcode {
|
|||
/// Suspend/resume callback
|
||||
SuspendResume,
|
||||
}
|
||||
|
||||
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
|
||||
pub(crate) enum NetCallback {
|
||||
Ping,
|
||||
Drop,
|
||||
}
|
||||
|
||||
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
|
||||
pub(crate) enum NetUdpCallback {
|
||||
RxData,
|
||||
Drop,
|
||||
}
|
||||
|
||||
#[derive(Debug, Archive, Serialize, Deserialize, Copy, Clone)]
|
||||
pub(crate) enum NetIpAddr {
|
||||
Ipv4([u8; 4]),
|
||||
Ipv6([u8; 16]),
|
||||
}
|
||||
impl From<SocketAddr> for NetIpAddr {
|
||||
fn from(other: SocketAddr) -> NetIpAddr {
|
||||
match other {
|
||||
SocketAddr::V4(sav4) => {
|
||||
NetIpAddr::Ipv4(sav4.ip().octets())
|
||||
},
|
||||
SocketAddr::V6(sav6) => {
|
||||
NetIpAddr::Ipv6(sav6.ip().octets())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
impl From<IpAddress> for NetIpAddr {
|
||||
fn from(other: IpAddress) -> NetIpAddr {
|
||||
match other {
|
||||
IpAddress::Ipv4(ipv4) => {
|
||||
NetIpAddr::Ipv4(ipv4.0)
|
||||
},
|
||||
IpAddress::Ipv6(ipv6) => {
|
||||
NetIpAddr::Ipv6(ipv6.0)
|
||||
},
|
||||
_ => {
|
||||
panic!("Invalid IpAddress")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The data field for a UDP response is limited to less than the theoretical
|
||||
/// size of 64k. While UDP allows for a 64k packet, it seems no protoctols
|
||||
/// in practice utilize such a length (about 512 bytes is the biggest), due
|
||||
/// to MTU limitations downstream. Within Xous, memory is shared on a page-basis,
|
||||
/// which is 4096 bytes, so the cost to share a page is almost the same regardless
|
||||
/// of its size, as long as it is smaller than 4096 bytes. Hence, the number
|
||||
/// 1800 bytes is picked to be a bit larger than our wifi MTU, but small
|
||||
/// enough to fit in a page of RAM. Why not make it even bigger? Mainly to save
|
||||
/// on the cost to repeatedly zeroize parts of RAM that are never used.
|
||||
#[derive(Debug, Archive, Serialize, Deserialize, Copy, Clone)]
|
||||
pub(crate) struct NetUdpResponse {
|
||||
pub endpoint_ip_addr: NetIpAddr,
|
||||
pub len: u16,
|
||||
pub endpoint_port: u16,
|
||||
pub data: [u8; 1800],
|
||||
}
|
||||
|
||||
#[derive(Debug, Archive, Serialize, Deserialize, Copy, Clone)]
|
||||
pub(crate) struct ScalarHook {
|
||||
pub sid: (u32, u32, u32, u32),
|
||||
pub id: u32, // ID of the scalar message to send through (e.g. the discriminant of the Enum on the caller's side API)
|
||||
pub cid: xous::CID, // caller-side connection ID for the scalar message to route to. Created by the caller before hooking.
|
||||
pub token: Option<[u32; 4]>, // 128-bit random token used to identify a connection to the net crate
|
||||
}
|
||||
|
||||
#[derive(Debug, Archive, Serialize, Deserialize, Copy, Clone)]
|
||||
pub(crate) struct NetUdpBind {
|
||||
pub(crate) cb_sid: [u32; 4],
|
||||
pub(crate) ip_addr: NetIpAddr,
|
||||
pub(crate) port: u16,
|
||||
pub(crate) max_payload: Option<u16>, // defaults to MTU if not specified
|
||||
}
|
||||
|
||||
#[derive(Debug, Archive, Serialize, Deserialize, Copy, Clone)]
|
||||
pub(crate) enum NetMemResponse {
|
||||
Ok,
|
||||
OutOfMemory,
|
||||
SocketInUse,
|
||||
AccessDenied,
|
||||
Invalid,
|
||||
}
|
||||
|
||||
/// This defines a Xous Scalar message endpoint. Used for defining
|
||||
/// notification messages for incoming packets, for main loops that want to be
|
||||
/// able to process both events from Xous and from the network.
|
||||
pub struct XousScalarEndpoint {
|
||||
cid: Option<xous::CID>,
|
||||
op: Option<usize>,
|
||||
args: [Option<usize>; 4],
|
||||
}
|
||||
#[allow(dead_code)]
|
||||
impl XousScalarEndpoint {
|
||||
pub fn new() -> Self {
|
||||
XousScalarEndpoint {
|
||||
cid: None,
|
||||
op: None,
|
||||
args: [None; 4]
|
||||
}
|
||||
}
|
||||
pub fn set(&mut self, cid: xous::CID, op: usize, args: [Option<usize>; 4]) {
|
||||
self.cid = Some(cid);
|
||||
self.op = Some(op);
|
||||
self.args = args;
|
||||
}
|
||||
pub fn clear(&mut self) {
|
||||
self.cid = None;
|
||||
self.op = None;
|
||||
self.args = [None; 4];
|
||||
}
|
||||
pub fn is_set(&self) -> bool {
|
||||
self.cid.is_some() && self.op.is_some()
|
||||
}
|
||||
pub fn notify(&mut self) {
|
||||
if let Some(cid) = self.cid {
|
||||
if let Some(op) = self.op {
|
||||
match xous::send_message(
|
||||
cid,
|
||||
xous::Message::new_scalar(
|
||||
op,
|
||||
if let Some(a) = self.args[0] {a} else {0},
|
||||
if let Some(a) = self.args[1] {a} else {0},
|
||||
if let Some(a) = self.args[2] {a} else {0},
|
||||
if let Some(a) = self.args[3] {a} else {0},
|
||||
)
|
||||
) {
|
||||
Ok(_) => (),
|
||||
Err(e) => {
|
||||
log::error!("Couldn't send scalar notification, unmapping: {:?}", e);
|
||||
self.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
3
services/net/src/backend.rs
Normal file
3
services/net/src/backend.rs
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
//pub mod lookup;
|
||||
pub mod udp;
|
||||
pub use udp::*;
|
||||
31
services/net/src/backend/lookup.rs
Normal file
31
services/net/src/backend/lookup.rs
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
|
||||
pub struct LookupHost(!);
|
||||
|
||||
impl LookupHost {
|
||||
pub fn port(&self) -> u16 {
|
||||
self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Iterator for LookupHost {
|
||||
type Item = SocketAddr;
|
||||
fn next(&mut self) -> Option<SocketAddr> {
|
||||
self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<&str> for LookupHost {
|
||||
type Error = io::Error;
|
||||
|
||||
fn try_from(_v: &str) -> io::Result<LookupHost> {
|
||||
unsupported()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TryFrom<(&'a str, u16)> for LookupHost {
|
||||
type Error = io::Error;
|
||||
|
||||
fn try_from(_v: (&'a str, u16)) -> io::Result<LookupHost> {
|
||||
unsupported()
|
||||
}
|
||||
}
|
||||
373
services/net/src/backend/udp.rs
Normal file
373
services/net/src/backend/udp.rs
Normal file
|
|
@ -0,0 +1,373 @@
|
|||
use std::convert::TryInto;
|
||||
use std::net::{SocketAddr, SocketAddrV4, Ipv4Addr, Ipv6Addr, IpAddr};
|
||||
use std::unimplemented;
|
||||
use std::io;
|
||||
use std::io::{Error, ErrorKind, Result};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::thread;
|
||||
use std::thread::JoinHandle;
|
||||
|
||||
use smoltcp::socket::UdpPacketMetadata;
|
||||
use smoltcp::wire::{Ipv4Address, Ipv6Address, IpAddress};
|
||||
use smoltcp::{
|
||||
wire::IpEndpoint,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use xous::{CID, SID, Message, msg_blocking_scalar_unpack};
|
||||
use xous_ipc::Buffer;
|
||||
use crate::NetConn;
|
||||
use crate::api::*;
|
||||
use num_traits::*;
|
||||
|
||||
pub struct UdpRx {
|
||||
pub endpoint: IpEndpoint,
|
||||
pub data: Vec<u8>,
|
||||
}
|
||||
pub struct UdpSocket{
|
||||
net: NetConn,
|
||||
cb_sid: SID,
|
||||
socket_addr: SocketAddr,
|
||||
rx_buf: Arc<Mutex<Vec<UdpRx>>>,
|
||||
handle: Option<JoinHandle::<()>>,
|
||||
notify: Arc<Mutex<XousScalarEndpoint>>,
|
||||
read_timeout: Option<Duration>,
|
||||
write_timeout: Option<Duration>,
|
||||
ticktimer: ticktimer_server::Ticktimer,
|
||||
}
|
||||
|
||||
// next steps: build this stub, and figure out how to clean up the error handling code.
|
||||
impl UdpSocket {
|
||||
pub fn bind(maybe_socket: Result<&SocketAddr>, max_payload: Option<u16>) -> Result<UdpSocket> {
|
||||
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 rx_buf = Arc::new(Mutex::new(Vec::new()));
|
||||
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(¬ify);
|
||||
move || {
|
||||
loop {
|
||||
let msg = xous::receive_message(cb_sid_clone).unwrap();
|
||||
match FromPrimitive::from_usize(msg.body.id()) {
|
||||
Some(NetUdpCallback::RxData) => {
|
||||
let buffer = unsafe {Buffer::from_memory_message(msg.body.memory_message().unwrap())};
|
||||
let incoming = buffer.as_flat::<NetUdpResponse, _>().unwrap();
|
||||
let endpoint = match incoming.endpoint_ip_addr {
|
||||
ArchivedNetIpAddr::Ipv4(v4_octets) => {
|
||||
IpEndpoint::new(
|
||||
IpAddress::Ipv4(Ipv4Address::from_bytes(&v4_octets)),
|
||||
incoming.endpoint_port as u16,
|
||||
)
|
||||
},
|
||||
ArchivedNetIpAddr::Ipv6(v6_octets) => {
|
||||
IpEndpoint::new(
|
||||
IpAddress::Ipv6(Ipv6Address::from_bytes(&v6_octets)),
|
||||
incoming.endpoint_port as u16,
|
||||
)
|
||||
},
|
||||
};
|
||||
let mut rx = UdpRx {
|
||||
endpoint,
|
||||
data: Vec::new(),
|
||||
};
|
||||
for (&src, dst) in incoming.data.iter().zip(rx.data.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
rx_buf.lock().unwrap().push(rx);
|
||||
notify.lock().unwrap().notify(); // this will only notify if a destination has been set
|
||||
},
|
||||
Some(NetUdpCallback::Drop) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
|
||||
log::debug!("Drop received, exiting Udp handler");
|
||||
xous::return_scalar(msg.sender, 1).unwrap(); // actual return value doesn't matter -- it's that there is a return value
|
||||
break;
|
||||
}),
|
||||
None => {
|
||||
log::error!("got unknown message type on Udp callback: {:?}", msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let request = NetUdpBind {
|
||||
ip_addr: NetIpAddr::from(*socket),
|
||||
port: socket.port(),
|
||||
cb_sid: cb_sid.to_array(),
|
||||
max_payload,
|
||||
};
|
||||
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::UdpBind.to_u32().unwrap())
|
||||
.or(Err(Error::new(ErrorKind::Other, "can't register with Net server")))?;
|
||||
match buf.to_original().unwrap() {
|
||||
NetMemResponse::Ok => {
|
||||
Ok(UdpSocket {
|
||||
net,
|
||||
cb_sid,
|
||||
socket_addr: *socket,
|
||||
rx_buf,
|
||||
handle: Some(handle),
|
||||
notify,
|
||||
read_timeout: None,
|
||||
write_timeout: None,
|
||||
ticktimer: ticktimer_server::Ticktimer::new().unwrap(),
|
||||
})
|
||||
},
|
||||
_ => {
|
||||
Err(Error::new(ErrorKind::Other, "can't register with Net server"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_scalar_notification(&mut self, cid: xous::CID, op: usize, args: [Option<usize>; 4]) {
|
||||
self.notify.lock().unwrap().set(cid, op, args);
|
||||
}
|
||||
pub fn clear_scalar_notification(&mut self) {
|
||||
self.notify.lock().unwrap().clear();
|
||||
}
|
||||
|
||||
pub fn set_read_timeout(&mut self, timeout: Option<Duration>) -> io::Result<()> {
|
||||
if let Some(duration) = timeout {
|
||||
if duration.total_millis() == 0 {
|
||||
Err(Error::new(ErrorKind::InvalidInput, "zero duration is not valid"))
|
||||
} else {
|
||||
self.read_timeout = Some(duration);
|
||||
Ok(())
|
||||
}
|
||||
} else {
|
||||
self.read_timeout = None;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_write_timeout(&mut self, timeout: Option<Duration>) -> io::Result<()> {
|
||||
if let Some(duration) = timeout {
|
||||
if duration.total_millis() == 0 {
|
||||
Err(Error::new(ErrorKind::InvalidInput, "zero duration is not valid"))
|
||||
} else {
|
||||
self.write_timeout = Some(duration);
|
||||
Ok(())
|
||||
}
|
||||
} else {
|
||||
self.write_timeout = None;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
|
||||
Ok(self.read_timeout)
|
||||
}
|
||||
|
||||
pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
|
||||
Ok(self.write_timeout)
|
||||
}
|
||||
|
||||
pub fn recv(&self, pkt: &mut [u8]) -> io::Result<usize> {
|
||||
let timeout = if let Some(to) = self.read_timeout {
|
||||
to.total_millis() + self.ticktimer.elapsed_ms()
|
||||
} else {
|
||||
u64::MAX
|
||||
};
|
||||
loop {
|
||||
if self.rx_buf.lock().unwrap().len() > 0 {
|
||||
let rx_pkt = self.rx_buf.lock().unwrap().remove(0); // safe b/c len > 1, checked above
|
||||
for (&src, dst) in rx_pkt.data.iter().zip(pkt.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
return Ok(rx_pkt.data.len());
|
||||
}
|
||||
if timeout > self.ticktimer.elapsed_ms() {
|
||||
return Err(Error::new(ErrorKind::WouldBlock, "UDP Rx timeout reached"));
|
||||
}
|
||||
xous::yield_slice();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn recv_from(&self, pkt: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
|
||||
let timeout = if let Some(to) = self.read_timeout {
|
||||
to.total_millis() + self.ticktimer.elapsed_ms()
|
||||
} else {
|
||||
u64::MAX
|
||||
};
|
||||
loop {
|
||||
if self.rx_buf.lock().unwrap().len() > 0 {
|
||||
let rx_pkt = self.rx_buf.lock().unwrap().remove(0); // safe b/c len > 1, checked above
|
||||
for (&src, dst) in rx_pkt.data.iter().zip(pkt.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
let addr = match rx_pkt.endpoint.addr {
|
||||
IpAddress::Ipv4(ipv4) => {
|
||||
IpAddr::V4(Ipv4Addr::new(ipv4.0[0], ipv4.0[1], ipv4.0[2], ipv4.0[3]))
|
||||
},
|
||||
IpAddress::Ipv6(ipv6) => {
|
||||
IpAddr::V6(Ipv6Addr::new(
|
||||
u16::from_be_bytes(ipv6.0[0..1].try_into().unwrap()),
|
||||
u16::from_be_bytes(ipv6.0[2..3].try_into().unwrap()),
|
||||
u16::from_be_bytes(ipv6.0[4..5].try_into().unwrap()),
|
||||
u16::from_be_bytes(ipv6.0[6..7].try_into().unwrap()),
|
||||
u16::from_be_bytes(ipv6.0[8..9].try_into().unwrap()),
|
||||
u16::from_be_bytes(ipv6.0[10..11].try_into().unwrap()),
|
||||
u16::from_be_bytes(ipv6.0[12..13].try_into().unwrap()),
|
||||
u16::from_be_bytes(ipv6.0[14..15].try_into().unwrap()),
|
||||
))
|
||||
},
|
||||
_ => {
|
||||
panic!("malformed endpoint record");
|
||||
}
|
||||
};
|
||||
return Ok((
|
||||
rx_pkt.data.len(),
|
||||
SocketAddr::new(
|
||||
addr,
|
||||
rx_pkt.endpoint.port,
|
||||
)
|
||||
));
|
||||
}
|
||||
if timeout > self.ticktimer.elapsed_ms() {
|
||||
return Err(Error::new(ErrorKind::WouldBlock, "UDP Rx timeout reached"));
|
||||
}
|
||||
xous::yield_slice();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn send(&self, _: &[u8]) -> io::Result<usize> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn peer_addr(&self) -> io::Result<SocketAddr> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn socket_addr(&self) -> io::Result<SocketAddr> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn peek_from(&self, _: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn send_to(&self, _: &[u8], _: &SocketAddr) -> io::Result<usize> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn duplicate(&self) -> io::Result<UdpSocket> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn set_broadcast(&self, _: bool) -> io::Result<()> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn broadcast(&self) -> io::Result<bool> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn set_multicast_loop_v4(&self, _: bool) -> io::Result<()> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn multicast_loop_v4(&self) -> io::Result<bool> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn set_multicast_ttl_v4(&self, _: u32) -> io::Result<()> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn join_multicast_v4(&self, _: &Ipv4Addr, _: &Ipv4Addr) -> io::Result<()> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn leave_multicast_v4(&self, _: &Ipv4Addr, _: &Ipv4Addr) -> io::Result<()> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn set_ttl(&self, _: u32) -> io::Result<()> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn ttl(&self) -> io::Result<u32> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn take_error(&self) -> io::Result<Option<io::Error>> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn connect(&self, _: io::Result<&SocketAddr>) -> io::Result<()> {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
|
||||
pub fn set_multicast_loop_v6(&self, _: bool) -> io::Result<()> {
|
||||
unimplemented!("ipv6 not implemented")
|
||||
}
|
||||
|
||||
pub fn multicast_loop_v6(&self) -> io::Result<bool> {
|
||||
unimplemented!("ipv6 not implemented")
|
||||
}
|
||||
|
||||
pub fn join_multicast_v6(&self, _: &Ipv6Addr, _: u32) -> io::Result<()> {
|
||||
unimplemented!("ipv6 not implemented")
|
||||
}
|
||||
|
||||
pub fn leave_multicast_v6(&self, _: &Ipv6Addr, _: u32) -> io::Result<()> {
|
||||
unimplemented!("ipv6 not implemented")
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for UdpSocket {
|
||||
fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
unimplemented!("work in progress")
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for UdpSocket {
|
||||
fn drop(&mut self) {
|
||||
let request = NetUdpBind {
|
||||
ip_addr: NetIpAddr::from(self.socket_addr),
|
||||
port: self.socket_addr.port(),
|
||||
cb_sid: self.cb_sid.to_array(),
|
||||
max_payload: None,
|
||||
};
|
||||
let mut buf = Buffer::into_buf(request).expect("can't unregister with Net server");
|
||||
buf.lend_mut(self.net.conn(), Opcode::UdpClose.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(NetUdpCallback::Drop.to_usize().unwrap(), 0, 0, 0, 0)
|
||||
).expect("couldn't send Drop to our repsonding server");
|
||||
unsafe{xous::disconnect(drop_cid).unwrap()}; // should be safe because we're the only connection and the previous was a blocking scalar
|
||||
},
|
||||
_ => {
|
||||
panic!("Couldn't unregister with net server");
|
||||
}
|
||||
}
|
||||
// this will block until the responder thread exits, which it should because it received the Drop message
|
||||
if let Some(handle) = self.handle.take() {
|
||||
handle.join().unwrap();
|
||||
}
|
||||
// now we can detroy the server id of the responder thread
|
||||
xous::destroy_server(self.cb_sid).unwrap();
|
||||
}
|
||||
}
|
||||
|
|
@ -1,25 +1,64 @@
|
|||
#![cfg_attr(target_os = "none", no_std)]
|
||||
|
||||
pub mod api;
|
||||
use api::*;
|
||||
use xous::{CID, send_message};
|
||||
use xous_ipc::Buffer;
|
||||
use num_traits::*;
|
||||
|
||||
pub struct Net {
|
||||
pub mod backend;
|
||||
pub use backend::*;
|
||||
|
||||
/// NetConn is a crate-level structure that just counts the number of connections from this process to
|
||||
/// the Net server. It's not mean to be created by user-facing code, so the visibility is (crate).
|
||||
pub(crate) struct NetConn {
|
||||
conn: CID,
|
||||
//cb_sid: Option<xous::SID>,
|
||||
//token: Option<[u32; 4]>,
|
||||
}
|
||||
impl Net {
|
||||
pub fn new(xns: &xous_names::XousNames) -> Result<Self, xous::Error> {
|
||||
impl NetConn {
|
||||
pub(crate) fn new(xns: &xous_names::XousNames) -> Result<Self, xous::Error> {
|
||||
REFCOUNT.store(REFCOUNT.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
|
||||
let conn = xns.request_connection_blocking(api::SERVER_NAME_NET).expect("Can't connect to Net server");
|
||||
Ok(Net {
|
||||
conn
|
||||
Ok(NetConn {
|
||||
conn,
|
||||
//cb_sid: None,
|
||||
//token: None,
|
||||
})
|
||||
}
|
||||
pub(crate) fn conn(&self) -> CID {
|
||||
self.conn
|
||||
}
|
||||
// `cid` is the connection ID for the callback. The calling function would use `xous::connect(my_private_SID).unwrap()` to generate this number.
|
||||
// The SID should never be disclosed to another crate, as it is private to each server, which is why the CID creation call must exist in the caller's code.
|
||||
/*
|
||||
pub fn hook_ping_callback(&mut self, id: u32, cid: CID) -> Result<(), xous::Error> {
|
||||
if self.cb_sid.is_none() {
|
||||
let sid = xous::create_server().unwrap();
|
||||
self.cb_sid = Some(sid);
|
||||
let sid_tuple = sid.to_u32();
|
||||
xous::create_thread_4(net_cb_server, sid_tuple.0 as usize, sid_tuple.1 as usize, sid_tuple.2 as usize, sid_tuple.3 as usize).unwrap();
|
||||
let hookdata = ScalarHook {
|
||||
sid: sid_tuple,
|
||||
id,
|
||||
cid,
|
||||
token: None,
|
||||
};
|
||||
let mut buf = Buffer::into_buf(hookdata).or(Err(xous::Error::InternalError))?;
|
||||
buf.lend_mut(self.conn, Opcode::NetCallbackSubscribe.to_u32().unwrap()).map(|_|())
|
||||
let retdata = buf.to_original::<ScalarHook, _>().unwrap();
|
||||
self.token = retdata.token;
|
||||
Ok(())
|
||||
} else {
|
||||
Err(xous::Error::MemoryInUse) // can't hook it twice
|
||||
}
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
use core::sync::atomic::{AtomicU32, Ordering};
|
||||
static REFCOUNT: AtomicU32 = AtomicU32::new(0);
|
||||
impl Drop for Net {
|
||||
impl Drop for NetConn {
|
||||
fn drop(&mut self) {
|
||||
// the connection to the server side must be reference counted, so that multiple instances of this object within
|
||||
// a single process do not end up de-allocating the CID on other threads before they go out of scope.
|
||||
|
|
@ -30,4 +69,26 @@ impl Drop for Net {
|
|||
// if there was object-specific state (such as a one-time use server for async callbacks, specific to the object instance),
|
||||
// de-allocate those items here. They don't need a reference count because they are object-specific
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
/// handles callback messages that indicate an net packet has been returned, in the caller's process space
|
||||
fn net_cb_server(sid0: usize, sid1: usize, sid2: usize, sid3: usize) {
|
||||
let sid = xous::SID::from_u32(sid0 as u32, sid1 as u32, sid2 as u32, sid3 as u32);
|
||||
loop {
|
||||
let msg = xous::receive_message(sid).unwrap();
|
||||
match FromPrimitive::from_usize(msg.body.id()) {
|
||||
Some(EventCallback::Event) => xous::msg_scalar_unpack!(msg, cid, id, free_play, avail_rec, {
|
||||
// directly pass the scalar message onto the CID with the ID memorized in the original hook
|
||||
send_message(cid as u32,
|
||||
Message::new_scalar(id, free_play, avail_rec, 0, 0)
|
||||
).unwrap();
|
||||
}),
|
||||
Some(EventCallback::Drop) => {
|
||||
break; // this exits the loop and kills the thread
|
||||
}
|
||||
None => (),
|
||||
}
|
||||
}
|
||||
xous::destroy_server(sid).unwrap();
|
||||
}
|
||||
*/
|
||||
|
|
@ -22,7 +22,7 @@ use smoltcp::socket::{IcmpEndpoint, IcmpPacketMetadata, IcmpSocket, IcmpSocketBu
|
|||
use smoltcp::wire::{
|
||||
EthernetAddress, Icmpv4Packet, Icmpv4Repr, IpAddress, IpCidr, Ipv4Address, Ipv4Cidr,
|
||||
};
|
||||
use smoltcp::socket::{UdpPacketMetadata, UdpSocket, UdpSocketBuffer};
|
||||
use smoltcp::socket::{UdpPacketMetadata, UdpSocket, UdpSocketBuffer, SocketHandle};
|
||||
use smoltcp::{
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
|
@ -178,7 +178,7 @@ fn xmain() -> ! {
|
|||
|
||||
let mut sockets = SocketSet::new(vec![]);
|
||||
let icmp_handle = sockets.add(icmp_socket);
|
||||
let mut handles = vec![];
|
||||
let mut udp_handles = HashMap::<u16, SocketHandle>::new();
|
||||
|
||||
let mut send_at = Instant::from_millis(0);
|
||||
let mut seq_no = 0;
|
||||
|
|
@ -220,19 +220,44 @@ fn xmain() -> ! {
|
|||
match FromPrimitive::from_usize(msg.body.id()) {
|
||||
Some(Opcode::UdpBind) => {
|
||||
let mut buf = unsafe{Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())};
|
||||
let udpspec = buf.to_original::<NetUdpBindIpv4, _>().unwrap();
|
||||
let udpspec = buf.to_original::<NetUdpBind, _>().unwrap();
|
||||
|
||||
let buflen = if let Some(maxlen) = udpspec.max_payload {
|
||||
maxlen as usize
|
||||
} else {
|
||||
NET_MTU as usize
|
||||
};
|
||||
let udp_rx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY], vec![0; buflen]);
|
||||
let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY], vec![0; buflen]);
|
||||
let udp_socket = UdpSocket::new(udp_rx_buffer, udp_tx_buffer);
|
||||
handles.push(sockets.add(udp_socket));
|
||||
|
||||
// TODO: add return code stuff, but let's see how much the borrow checker hates this code so far...
|
||||
if udp_handles.contains_key(&udpspec.port) {
|
||||
log::error!("Attempt to bind to udp:{}, already in use.", udpspec.port);
|
||||
buf.replace(NetMemResponse::SocketInUse).unwrap();
|
||||
} else {
|
||||
let udp_rx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY], vec![0; buflen]);
|
||||
let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY], vec![0; buflen]);
|
||||
let mut udp_socket = UdpSocket::new(udp_rx_buffer, udp_tx_buffer);
|
||||
match udp_socket.bind(udpspec.port) {
|
||||
Ok(_) => {
|
||||
udp_handles.insert(udpspec.port, sockets.add(udp_socket));
|
||||
buf.replace(NetMemResponse::Ok).unwrap();
|
||||
}
|
||||
Err(e) => {
|
||||
log::error!("Udp couldn't bind to socket: {:?}", e);
|
||||
buf.replace(NetMemResponse::Invalid).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
Some(Opcode::UdpClose) => {
|
||||
let mut buf = unsafe{Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())};
|
||||
let udpspec = buf.to_original::<NetUdpBind, _>().unwrap();
|
||||
match udp_handles.remove(&udpspec.port) {
|
||||
Some(handle) => {
|
||||
sockets.get::<UdpSocket>(handle).close();
|
||||
buf.replace(NetMemResponse::Ok).unwrap()
|
||||
}
|
||||
_ => {
|
||||
buf.replace(NetMemResponse::Invalid).unwrap()
|
||||
}
|
||||
}
|
||||
},
|
||||
Some(Opcode::ComInterrupt) => {
|
||||
com_int_list.clear();
|
||||
|
|
@ -331,6 +356,32 @@ fn xmain() -> ! {
|
|||
log::debug!("poll error: {}", e);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
for (port, &handle) in udp_handles.iter() {
|
||||
let mut socket = sockets.get::<UdpSocket>(handle);
|
||||
match socket.recv() {
|
||||
Ok((data, endpoint)) => {
|
||||
log::info!(
|
||||
"udp:{} recv data: {:?} from {}",
|
||||
port,
|
||||
std::str::from_utf8(data).unwrap(),
|
||||
endpoint
|
||||
);
|
||||
// return the data/endpoint tuple to the caller
|
||||
// TODO
|
||||
|
||||
}
|
||||
Err(_) => {
|
||||
// do nothing
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// this enclosure contains an ICMP implementation that needs to be deconstructed
|
||||
// at the moment it bakes in a pinger and ping responder -- we need to remove the pinger
|
||||
// and expose it to a generic interface. Once we figure out what that is.
|
||||
{
|
||||
let timestamp = timer.now();
|
||||
let mut socket = sockets.get::<IcmpSocket>(icmp_handle);
|
||||
|
|
|
|||
Loading…
Reference in a new issue