use alloc::vec::Vec;
use core::future::Future;
use crate::base::channel::ChannelId;
use crate::base::error::{Error, ProtocolError, ReverseError};
use crate::base::session::Session;
const REPLY_CAP: usize = 64 * 1024;
pub trait ReverseChannel {
type IoError;
fn open_service_channel(
&mut self,
dest: &[u8],
) -> impl Future<Output = Result<ChannelId, Error<Self::IoError>>>;
fn read_service_channel(
&mut self,
ch: ChannelId,
buf: &mut [u8],
) -> impl Future<Output = Result<usize, Error<Self::IoError>>>;
fn close_service_channel(
&mut self,
ch: ChannelId,
) -> impl Future<Output = Result<(), Error<Self::IoError>>>;
}
impl<S: Session> ReverseChannel for S {
type IoError = S::IoError;
async fn open_service_channel(
&mut self,
dest: &[u8],
) -> Result<ChannelId, Error<Self::IoError>> {
self.open_channel(dest).await
}
async fn read_service_channel(
&mut self,
ch: ChannelId,
buf: &mut [u8],
) -> Result<usize, Error<Self::IoError>> {
self.read_channel(ch, buf).await
}
async fn close_service_channel(&mut self, ch: ChannelId) -> Result<(), Error<Self::IoError>> {
self.close_channel(ch).await
}
}
#[cfg(feature = "split")]
impl<RH, WH, const MC: usize, const MP: usize, const MF: usize> ReverseChannel
for crate::split::Reader<RH, WH, MC, MP, MF>
where
RH: embedded_io_async::Read,
WH: embedded_io_async::Write<Error = <RH as embedded_io::ErrorType>::Error>,
{
type IoError = <RH as embedded_io::ErrorType>::Error;
async fn open_service_channel(
&mut self,
dest: &[u8],
) -> Result<ChannelId, Error<Self::IoError>> {
self.open_channel(dest).await
}
async fn read_service_channel(
&mut self,
ch: ChannelId,
buf: &mut [u8],
) -> Result<usize, Error<Self::IoError>> {
self.read_channel(ch, buf).await
}
async fn close_service_channel(&mut self, ch: ChannelId) -> Result<(), Error<Self::IoError>> {
self.close_channel(ch).await
}
}
pub async fn establish<C: ReverseChannel>(
conn: &mut C,
device_spec: &str,
host_spec: &str,
) -> Result<Vec<u8>, Error<C::IoError>> {
check_specs(&[device_spec, host_spec])?;
let mut dest = Vec::with_capacity(18 + device_spec.len() + host_spec.len());
dest.extend_from_slice(b"reverse:forward:");
dest.extend_from_slice(device_spec.as_bytes());
dest.push(b';');
dest.extend_from_slice(host_spec.as_bytes());
dest.push(0);
let reply = exchange(conn, &dest).await?;
parse_status(&reply).map_err(Error::Reverse)
}
pub async fn remove<C: ReverseChannel>(
conn: &mut C,
device_spec: &str,
) -> Result<(), Error<C::IoError>> {
check_specs(&[device_spec])?;
let mut dest = Vec::with_capacity(21 + device_spec.len());
dest.extend_from_slice(b"reverse:killforward:");
dest.extend_from_slice(device_spec.as_bytes());
dest.push(0);
let reply = exchange(conn, &dest).await?;
parse_status(&reply).map_err(Error::Reverse)?;
Ok(())
}
pub async fn remove_all<C: ReverseChannel>(conn: &mut C) -> Result<(), Error<C::IoError>> {
let reply = exchange(conn, b"reverse:killforward-all\0").await?;
parse_status(&reply).map_err(Error::Reverse)?;
Ok(())
}
pub async fn list<C: ReverseChannel>(conn: &mut C) -> Result<Vec<u8>, Error<C::IoError>> {
let reply = exchange(conn, b"reverse:list-forward\0").await?;
if reply.starts_with(b"FAIL") {
return Err(Error::Reverse(fail_message(&reply[4..])));
}
hex4_block(&reply).ok_or(Error::Reverse(ReverseError::UnexpectedReply))
}
fn check_specs<E>(specs: &[&str]) -> Result<(), Error<E>> {
if specs.iter().any(|s| s.contains('\0')) {
return Err(Error::Protocol(ProtocolError::InvalidDestination));
}
Ok(())
}
async fn exchange<C: ReverseChannel>(
conn: &mut C,
dest: &[u8],
) -> Result<Vec<u8>, Error<C::IoError>> {
let ch = conn.open_service_channel(dest).await?;
let mut reply = Vec::new();
let mut buf = [0u8; 512];
let result = loop {
match conn.read_service_channel(ch, &mut buf).await {
Ok(n) => {
if reply.len() + n > REPLY_CAP {
break Err(Error::Reverse(ReverseError::UnexpectedReply));
}
reply.extend_from_slice(&buf[..n]);
}
Err(Error::ChannelClosed) => break Ok(reply),
Err(e) => break Err(e),
}
};
let _ = conn.close_service_channel(ch).await;
result
}
fn parse_status(reply: &[u8]) -> Result<Vec<u8>, ReverseError> {
match reply.get(..4) {
Some(b"OKAY") => {
let rest = &reply[4..];
if rest.is_empty() {
Ok(Vec::new())
} else {
hex4_block(rest).ok_or(ReverseError::UnexpectedReply)
}
}
Some(b"FAIL") => Err(fail_message(&reply[4..])),
_ => Err(ReverseError::UnexpectedReply),
}
}
fn fail_message(rest: &[u8]) -> ReverseError {
ReverseError::Failed(hex4_block(rest).unwrap_or_else(|| rest.to_vec()))
}
fn hex4_block(b: &[u8]) -> Option<Vec<u8>> {
let prefix = b.get(..4)?;
if !prefix.iter().all(u8::is_ascii_hexdigit) {
return None;
}
let digits = core::str::from_utf8(prefix).ok()?;
let len = usize::from_str_radix(digits, 16).ok()?;
let body = b.get(4..)?;
if body.len() != len {
return None;
}
Some(body.to_vec())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn statuses_parse_as_probed_on_a_real_device() {
assert_eq!(parse_status(b"OKAY00046100").unwrap(), b"6100");
assert_eq!(parse_status(b"OKAY").unwrap(), b"");
assert_eq!(
parse_status(b"FAIL0014bad forward: garbage").unwrap_err(),
ReverseError::Failed(b"bad forward: garbage".to_vec())
);
assert_eq!(
parse_status(b"MEOW").unwrap_err(),
ReverseError::UnexpectedReply
);
assert_eq!(
parse_status(b"OKAY000461").unwrap_err(),
ReverseError::UnexpectedReply
);
assert_eq!(hex4_block(b"0000").unwrap(), b"");
assert_eq!(
hex4_block(b"001ahost-19 tcp:6100 tcp:6100\n").unwrap(),
b"host-19 tcp:6100 tcp:6100\n"
);
assert_eq!(hex4_block(b"+0011"), None);
assert_eq!(
parse_status(b"OKAY+0011").unwrap_err(),
ReverseError::UnexpectedReply
);
}
}