use std::io;
use std::mem;
use std::net::SocketAddr;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::Duration;
use async_trait::async_trait;
use futures_io::{AsyncRead, AsyncWrite};
use futures_util::stream::Stream;
use futures_util::{self, future::Future, ready, FutureExt};
use log::debug;
use crate::error::*;
use crate::xfer::{BufStreamHandle, SerialMessage, StreamReceiver};
use crate::Time;
pub trait DnsTcpStream: AsyncRead + AsyncWrite + Unpin + Send + Sync + Sized + 'static {
type Time: Time;
}
#[async_trait]
pub trait Connect: DnsTcpStream {
async fn connect(addr: SocketAddr) -> io::Result<Self>;
}
enum WriteTcpState {
LenBytes {
pos: usize,
length: [u8; 2],
bytes: Vec<u8>,
},
Bytes {
pos: usize,
bytes: Vec<u8>,
},
Flushing,
}
pub enum ReadTcpState {
LenBytes {
pos: usize,
bytes: [u8; 2],
},
Bytes {
pos: usize,
bytes: Vec<u8>,
},
}
#[must_use = "futures do nothing unless polled"]
pub struct TcpStream<S: DnsTcpStream> {
socket: S,
outbound_messages: StreamReceiver,
send_state: Option<WriteTcpState>,
read_state: ReadTcpState,
peer_addr: SocketAddr,
}
impl<S: Connect> TcpStream<S> {
#[allow(clippy::new_ret_no_self, clippy::type_complexity)]
pub fn new<E>(
name_server: SocketAddr,
) -> (
impl Future<Output = Result<TcpStream<S>, io::Error>> + Send,
BufStreamHandle,
)
where
E: FromProtoError,
{
Self::with_timeout(name_server, Duration::from_secs(5))
}
#[allow(clippy::type_complexity)]
pub fn with_timeout(
name_server: SocketAddr,
timeout: Duration,
) -> (
impl Future<Output = Result<TcpStream<S>, io::Error>> + Send,
BufStreamHandle,
) {
let (message_sender, outbound_messages) = BufStreamHandle::create();
let stream_fut = Self::connect(name_server, timeout, outbound_messages);
(stream_fut, message_sender)
}
async fn connect(
name_server: SocketAddr,
timeout: Duration,
outbound_messages: StreamReceiver,
) -> Result<TcpStream<S>, io::Error> {
let tcp = S::connect(name_server);
S::Time::timeout(timeout, tcp)
.map(move |tcp_stream: Result<Result<S, io::Error>, _>| {
tcp_stream
.and_then(|tcp_stream| tcp_stream)
.map(|tcp_stream| {
debug!("TCP connection established to: {}", name_server);
TcpStream {
socket: tcp_stream,
outbound_messages,
send_state: None,
read_state: ReadTcpState::LenBytes {
pos: 0,
bytes: [0u8; 2],
},
peer_addr: name_server,
}
})
})
.await
}
}
impl<S: DnsTcpStream> TcpStream<S> {
pub fn peer_addr(&self) -> SocketAddr {
self.peer_addr
}
fn pollable_split(
&mut self,
) -> (
&mut S,
&mut StreamReceiver,
&mut Option<WriteTcpState>,
&mut ReadTcpState,
) {
(
&mut self.socket,
&mut self.outbound_messages,
&mut self.send_state,
&mut self.read_state,
)
}
pub fn from_stream(stream: S, peer_addr: SocketAddr) -> (Self, BufStreamHandle) {
let (message_sender, outbound_messages) = BufStreamHandle::create();
let stream = Self::from_stream_with_receiver(stream, peer_addr, outbound_messages);
(stream, message_sender)
}
pub fn from_stream_with_receiver(
socket: S,
peer_addr: SocketAddr,
outbound_messages: StreamReceiver,
) -> Self {
TcpStream {
socket,
outbound_messages,
send_state: None,
read_state: ReadTcpState::LenBytes {
pos: 0,
bytes: [0u8; 2],
},
peer_addr,
}
}
}
impl<S: DnsTcpStream> Stream for TcpStream<S> {
type Item = io::Result<SerialMessage>;
#[allow(clippy::cognitive_complexity)]
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let peer = self.peer_addr;
let (socket, outbound_messages, send_state, read_state) = self.pollable_split();
let mut socket = Pin::new(socket);
let mut outbound_messages = Pin::new(outbound_messages);
loop {
if send_state.is_some() {
match send_state {
Some(WriteTcpState::LenBytes {
ref mut pos,
ref length,
..
}) => {
let wrote = ready!(socket.as_mut().poll_write(cx, &length[*pos..]))?;
*pos += wrote;
}
Some(WriteTcpState::Bytes {
ref mut pos,
ref bytes,
}) => {
let wrote = ready!(socket.as_mut().poll_write(cx, &bytes[*pos..]))?;
*pos += wrote;
}
Some(WriteTcpState::Flushing) => {
ready!(socket.as_mut().poll_flush(cx))?;
}
_ => (),
}
let current_state = send_state.take();
match current_state {
Some(WriteTcpState::LenBytes { pos, length, bytes }) => {
if pos < length.len() {
*send_state = Some(WriteTcpState::LenBytes { pos, length, bytes });
} else {
*send_state = Some(WriteTcpState::Bytes { pos: 0, bytes });
}
}
Some(WriteTcpState::Bytes { pos, bytes }) => {
if pos < bytes.len() {
*send_state = Some(WriteTcpState::Bytes { pos, bytes });
} else {
*send_state = Some(WriteTcpState::Flushing);
}
}
Some(WriteTcpState::Flushing) => {
send_state.take();
}
None => (),
};
} else {
match outbound_messages.as_mut().poll_next(cx)
{
Poll::Ready(Some(message)) => {
let (buffer, dst) = message.into_parts();
if peer != dst {
return Poll::Ready(Some(Err(io::Error::new(
io::ErrorKind::InvalidData,
format!("mismatched peer: {} and dst: {}", peer, dst),
))));
}
let len: [u8; 2] = [
(buffer.len() >> 8 & 0xFF) as u8,
(buffer.len() & 0xFF) as u8,
];
debug!("sending message len: {} to: {}", buffer.len(), dst);
*send_state = Some(WriteTcpState::LenBytes {
pos: 0,
length: len,
bytes: buffer,
});
}
Poll::Pending => break,
Poll::Ready(None) => {
debug!("no messages to send");
break;
}
}
}
}
let mut ret_buf: Option<Vec<u8>> = None;
while ret_buf.is_none() {
let new_state: Option<ReadTcpState> = match read_state {
ReadTcpState::LenBytes {
ref mut pos,
ref mut bytes,
} => {
let read = ready!(socket.as_mut().poll_read(cx, &mut bytes[*pos..]))?;
if read == 0 {
debug!("zero bytes read, stream closed?");
if *pos == 0 {
return Poll::Ready(None);
} else {
return Poll::Ready(Some(Err(io::Error::new(
io::ErrorKind::BrokenPipe,
"closed while reading length",
))));
}
}
debug!("in ReadTcpState::LenBytes: {}", pos);
*pos += read;
if *pos < bytes.len() {
debug!("remain ReadTcpState::LenBytes: {}", pos);
None
} else {
let length =
u16::from(bytes[0]) << 8 & 0xFF00 | u16::from(bytes[1]) & 0x00FF;
debug!("got length: {}", length);
let mut bytes = vec![0; length as usize];
bytes.resize(length as usize, 0);
debug!("move ReadTcpState::Bytes: {}", bytes.len());
Some(ReadTcpState::Bytes { pos: 0, bytes })
}
}
ReadTcpState::Bytes {
ref mut pos,
ref mut bytes,
} => {
let read = ready!(socket.as_mut().poll_read(cx, &mut bytes[*pos..]))?;
if read == 0 {
debug!("zero bytes read for message, stream closed?");
return Poll::Ready(Some(Err(io::Error::new(
io::ErrorKind::BrokenPipe,
"closed while reading message",
))));
}
debug!("in ReadTcpState::Bytes: {}", bytes.len());
*pos += read;
if *pos < bytes.len() {
debug!("remain ReadTcpState::Bytes: {}", bytes.len());
None
} else {
debug!("reset ReadTcpState::LenBytes: {}", 0);
Some(ReadTcpState::LenBytes {
pos: 0,
bytes: [0u8; 2],
})
}
}
};
if let Some(state) = new_state {
if let ReadTcpState::Bytes { pos, bytes } = mem::replace(read_state, state) {
debug!("returning bytes");
assert_eq!(pos, bytes.len());
ret_buf = Some(bytes);
}
}
}
if let Some(buffer) = ret_buf {
debug!("returning buffer");
let src_addr = self.peer_addr;
Poll::Ready(Some(Ok(SerialMessage::new(buffer, src_addr))))
} else {
debug!("bottomed out");
Poll::Pending
}
}
}
#[cfg(test)]
#[cfg(feature = "tokio-runtime")]
mod tests {
#[cfg(not(target_os = "linux"))]
use std::net::Ipv6Addr;
use std::net::{IpAddr, Ipv4Addr};
use tokio::net::TcpStream as TokioTcpStream;
use tokio::runtime::Runtime;
use crate::iocompat::AsyncIoTokioAsStd;
use crate::TokioTime;
use crate::tests::tcp_stream_test;
#[test]
fn test_tcp_stream_ipv4() {
let io_loop = Runtime::new().expect("failed to create tokio runtime");
tcp_stream_test::<AsyncIoTokioAsStd<TokioTcpStream>, Runtime, TokioTime>(
IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
io_loop,
)
}
#[test]
#[cfg(not(target_os = "linux"))]
fn test_tcp_stream_ipv6() {
let io_loop = Runtime::new().expect("failed to create tokio runtime");
tcp_stream_test::<AsyncIoTokioAsStd<TokioTcpStream>, Runtime, TokioTime>(
IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)),
io_loop,
)
}
}