use crate::internal::protocol::checked_count;
use crate::{EncodeError, NsUpdateError, ParseError};
use std::io;
use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpStream, ToSocketAddrs, UdpSocket, lookup_host};
const UDP_LIMIT: usize = 512;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Transport {
#[default]
Auto,
Udp,
Tcp,
}
impl Transport {
pub(crate) fn uses_tcp(self, length: usize) -> Result<bool, EncodeError> {
match self {
Self::Auto => Ok(length > UDP_LIMIT),
Self::Tcp => Ok(true),
Self::Udp if length <= UDP_LIMIT => Ok(false),
Self::Udp => Err(EncodeError::LengthExceeded {
field: "UDP message",
length,
max: UDP_LIMIT,
}),
}
}
}
async fn connect_udp(server: &str) -> io::Result<UdpSocket> {
let addresses = lookup_host(server).await?;
let mut last_error = io::Error::new(
io::ErrorKind::InvalidInput,
"Server address resolved to no socket addresses",
);
for address in addresses {
let local = match address {
SocketAddr::V4(_) => SocketAddr::from((Ipv4Addr::UNSPECIFIED, 0)),
SocketAddr::V6(_) => SocketAddr::from((Ipv6Addr::UNSPECIFIED, 0)),
};
let connect = async {
let socket = UdpSocket::bind(local).await?;
socket.connect(address).await?;
Ok(socket)
};
match connect.await {
Ok(socket) => return Ok(socket),
Err(error) => last_error = error,
}
}
Err(last_error)
}
pub(crate) struct UdpExchange {
socket: UdpSocket,
response: Vec<u8>,
}
impl UdpExchange {
pub(crate) async fn send(server: &str, request: &[u8]) -> io::Result<Self> {
let socket = connect_udp(server).await?;
if socket.send(request).await? != request.len() {
return Err(io::Error::new(
io::ErrorKind::WriteZero,
"Incomplete UDP send",
));
}
Ok(Self {
socket,
response: vec![0; 65536],
})
}
pub(crate) async fn receive(&mut self) -> io::Result<&[u8]> {
let length = self.socket.recv(&mut self.response).await?;
Ok(&self.response[..length])
}
pub(crate) fn peer_addr(&self) -> io::Result<SocketAddr> {
self.socket.peer_addr()
}
}
pub(crate) async fn exchange_tcp(
server: impl ToSocketAddrs,
request: &[u8],
) -> Result<Vec<u8>, NsUpdateError> {
let length = checked_count("DNS message", request.len())?;
let mut stream = TcpStream::connect(server).await?;
let mut frame = Vec::with_capacity(request.len() + 2);
frame.extend_from_slice(&length.to_be_bytes());
frame.extend_from_slice(request);
stream.write_all(&frame).await?;
let mut prefix = [0; 2];
stream.read_exact(&mut prefix).await?;
let length = usize::from(u16::from_be_bytes(prefix));
if length < 12 {
return Err(ParseError::InvalidMessage("TCP frame is shorter than a DNS header").into());
}
let mut response = vec![0; length];
stream.read_exact(&mut response).await?;
Ok(response)
}