use super::*;
pub struct AsyncDatagram<B: Backend> {
io: AsyncIo<B>,
}
impl<B: Backend> ExecutorHandle<B> {
pub fn datagram(&self, handle: Handle) -> AsyncDatagram<B> {
AsyncDatagram {
io: self.io(handle),
}
}
}
impl<B: Backend> AsyncDatagram<B> {
pub fn handle(&self) -> Handle {
self.io.handle()
}
pub fn poll_recv_from(
&mut self,
cx: &mut Context<'_>,
buf: &mut [u8],
) -> Poll<io::Result<(usize, SocketAddr)>> {
let this = &mut self.io;
if this.closed {
return Poll::Ready(Err(io::ErrorKind::NotConnected.into()));
}
let key = match this.read {
Some(key) => key,
None => {
let key = this.shared.reserve(cx).map_err(io_error)?;
let buffer = {
let mut slots = this.shared.slots.borrow_mut();
let bytes = &mut slots[key.index].bytes;
ReadBuf::Provided(unsafe {
IoBufMut::from_raw_parts(bytes.as_mut_ptr(), bytes.len())
})
};
let result = this
.shared
.driver
.borrow_mut()
.recv(this.handle, buffer, key.token());
match result {
Ok(op) => {
this.shared.slots.borrow_mut()[key.index].op = Some(op);
this.read = Some(key);
key
}
Err(error) => {
this.shared.free(key);
return Poll::Ready(Err(io_error(error)));
}
}
}
};
let Some(result) = this.shared.result(key, cx) else {
return Poll::Pending;
};
let result = match result {
OpResult::RecvFrom { n, from, .. } => {
let slots = this.shared.slots.borrow();
let bytes = &slots[key.index].bytes;
let take = buf.len().min(n);
buf[..take].copy_from_slice(&bytes[..take]);
Ok((take, from))
}
OpResult::Err(error) => Err(io_error(error)),
OpResult::Cancelled => Err(io_error(Error::new(ErrorKind::Cancelled))),
_ => Err(io::Error::other("unexpected datagram receive completion")),
};
this.shared.free(key);
this.read = None;
Poll::Ready(result)
}
pub fn poll_send_to(
&mut self,
cx: &mut Context<'_>,
buf: &[u8],
to: SocketAddr,
) -> Poll<io::Result<usize>> {
if self.io.closed {
return Poll::Ready(Err(io::ErrorKind::NotConnected.into()));
}
std::task::ready!(self.poll_flush(cx))?;
let this = &mut self.io;
let key = this.shared.reserve(cx).map_err(io_error)?;
let buffer = {
let mut slots = this.shared.slots.borrow_mut();
let bytes = &mut slots[key.index].bytes;
if buf.len() > bytes.len() {
drop(slots);
this.shared.free(key);
return Poll::Ready(Err(io::Error::new(
io::ErrorKind::InvalidInput,
"datagram exceeds executor buffer",
)));
}
bytes[..buf.len()].copy_from_slice(buf);
WriteBuf::Provided(unsafe { IoBuf::from_raw_parts(bytes.as_ptr(), buf.len()) })
};
let result = this
.shared
.driver
.borrow_mut()
.send_to(this.handle, buffer, to, key.token());
match result {
Ok(op) => {
this.shared.slots.borrow_mut()[key.index].op = Some(op);
this.write = Some(key);
Poll::Ready(Ok(buf.len()))
}
Err(error) => {
this.shared.free(key);
Poll::Ready(Err(io_error(error)))
}
}
}
pub fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
Pin::new(&mut self.io).poll_flush(cx)
}
pub fn cancel_receive(&mut self) {
if let Some(key) = self.io.read.take() {
self.io.shared.abandon(key);
}
}
pub fn poll_close(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
std::task::ready!(self.poll_flush(cx))?;
self.cancel_receive();
Pin::new(&mut self.io).poll_close(cx)
}
}