use std::net::{SocketAddr, UdpSocket};
use std::time::Duration;
use serde_json::{json, Value};
use crate::{io_err, reply_from, Arg, Error, Reply};
use std::io;
const MAX_DGRAM: usize = 65535;
fn named(args: &[(&str, Arg<'_>)]) -> Value {
if args.iter().any(|(k, _)| k.is_empty()) {
return Value::Array(args.iter().map(|(_, v)| v.json()).collect());
}
Value::Object(
args.iter()
.map(|(k, v)| ((*k).to_string(), v.json()))
.collect(),
)
}
pub(crate) struct Udp {
sock: UdpSocket,
rx: Vec<u8>,
}
impl Udp {
pub(crate) fn connect(peer: SocketAddr, timeout: Duration) -> Result<Udp, Error> {
let sock = UdpSocket::bind(bind_any(peer)).map_err(Error::Io)?;
sock.set_read_timeout(Some(timeout)).map_err(Error::Io)?;
sock.connect(peer).map_err(Error::Io)?;
Ok(Udp {
sock,
rx: vec![0u8; MAX_DGRAM],
})
}
fn rpc(&mut self, req: &Value) -> Result<usize, Error> {
let out = serde_json::to_vec(req)
.map_err(|e| io_err(io::ErrorKind::InvalidData, e.to_string()))?;
self.sock.send(&out).map_err(Error::Io)?;
match self.sock.recv(&mut self.rx) {
Ok(n) => Ok(n),
Err(e) => Err(crate::io_or_timeout(e)),
}
}
fn rpc_json(&mut self, req: &Value) -> Result<Value, Error> {
let n = self.rpc(req)?;
let v: Value = serde_json::from_slice(&self.rx[..n]).map_err(|e| {
io_err(
io::ErrorKind::InvalidData,
format!("undecodable reply: {e}"),
)
})?;
if let Some(t) = v.get("err").and_then(Value::as_str) {
return Err(io_err(
io::ErrorKind::InvalidData,
format!("device refused {}: {t}", req["op"]),
));
}
Ok(v)
}
pub(crate) fn discover(&mut self) -> Result<Value, Error> {
self.rpc_json(&json!({"op": "discover"}))
}
pub(crate) fn reg_read(&mut self, name: &str) -> Result<u32, Error> {
let v = self.rpc_json(&json!({"op": "reg_read", "name": name}))?;
v.get("value")
.and_then(Value::as_u64)
.map(|x| x as u32)
.ok_or_else(|| {
io_err(
io::ErrorKind::InvalidData,
format!("reg_read {name}: reply carries no integer `value`"),
)
})
}
pub(crate) fn reg_write(&mut self, name: &str, value: u32) -> Result<(), Error> {
self.rpc_json(&json!({"op": "reg_write", "name": name, "value": value}))?;
Ok(())
}
pub(crate) fn stream_read(&mut self, name: &str, buf: &mut [u8]) -> Result<usize, Error> {
let want = buf.len().min(MAX_DGRAM - 1);
if want == 0 {
return Ok(0);
}
let n = self.rpc(&json!({"op": "stream_read", "name": name, "max_bytes": want}))?;
let data = &self.rx[..n];
match data.first() {
Some(1) => {
let body = &data[1..];
if body.len() > buf.len() {
return Err(io_err(
io::ErrorKind::InvalidData,
format!(
"stream_read returned {} B for a {want} B request",
body.len()
),
));
}
buf[..body.len()].copy_from_slice(body);
Ok(body.len())
}
_ => {
let token = serde_json::from_slice::<Value>(data)
.ok()
.and_then(|v| v.get("err").and_then(Value::as_str).map(str::to_owned))
.unwrap_or_else(|| "unframed stream reply".to_string());
Err(io_err(
io::ErrorKind::InvalidData,
format!("stream_read {name}: {token}"),
))
}
}
}
pub(crate) fn message(
&mut self,
id: &str,
name: &str,
args: &[(&str, Arg<'_>)],
token: &str,
) -> Result<Reply, Error> {
let v = self.rpc_json(&json!({
"op": "message",
"req": {"id": id, "name": name, "args": named(args), "token": token},
}))?;
let resp = v.get("resp").cloned().ok_or_else(|| {
io_err(
io::ErrorKind::InvalidData,
format!("message {name}: reply carries no `resp`"),
)
})?;
let reply = reply_from(resp)?;
if reply.id != id {
return Err(io_err(
io::ErrorKind::InvalidData,
format!("reply id {:?} does not match request {id:?}", reply.id),
));
}
Ok(reply)
}
}
pub(crate) fn probe(addr: SocketAddr, timeout: Duration) -> Result<Value, Error> {
let mut u = Udp::connect(addr, timeout)?;
u.discover()
}
fn bind_any(peer: SocketAddr) -> SocketAddr {
if peer.is_ipv4() {
SocketAddr::from(([0, 0, 0, 0], 0))
} else {
SocketAddr::from(([0u16; 8], 0))
}
}