use std::fmt;
use std::io::{self, Read, Write};
use std::net::{SocketAddr, TcpStream, ToSocketAddrs};
use std::time::{Duration, Instant};
use crate::navmesh::wire::{DEFAULT_PORT, TileInput, WorldParams, encode_tile_request};
const MSG_WORLD_PARAMS_REQUEST: u32 = 2;
const MSG_TILE_REQUEST: u32 = 3;
const MSG_WORLD_PARAMS: u32 = 4;
const MSG_TILE: u32 = 5;
pub(crate) const MAX_FRAME: u32 = 1 << 30;
pub(crate) const READ_CHUNK: usize = 16 << 20;
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct RetryPolicy {
pub attempts: u32,
pub delay_unit: Duration,
pub connect_timeout: Duration,
pub recv_timeout: Duration,
}
impl Default for RetryPolicy {
fn default() -> Self {
Self {
attempts: 5,
delay_unit: Duration::from_secs(1),
connect_timeout: Duration::from_secs(10),
recv_timeout: Duration::from_secs(600),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Host {
name: String,
port: u16,
}
impl Host {
pub fn parse(text: &str) -> io::Result<Self> {
let (name, port) = match text.split_once(':') {
None => (text, DEFAULT_PORT),
Some((name, port)) => {
let port = port
.parse::<u16>()
.ok()
.filter(|p| *p != 0)
.ok_or_else(|| error!("invalid port in host \"{text}\""))?;
(name, port)
}
};
if name.is_empty() || name.contains(':') {
return Err(error!("invalid host \"{text}\""));
}
Ok(Self {
name: name.to_owned(),
port,
})
}
#[must_use]
pub fn name(&self) -> &str {
&self.name
}
#[must_use]
pub fn port(&self) -> u16 {
self.port
}
}
impl fmt::Display for Host {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}:{}", self.name, self.port)
}
}
#[derive(Debug)]
#[non_exhaustive]
pub enum FetchError {
Network(io::Error),
Wire(io::Error),
}
impl fmt::Display for FetchError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Network(e) | Self::Wire(e) => e.fmt(f),
}
}
}
impl std::error::Error for FetchError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Network(e) | Self::Wire(e) => Some(e),
}
}
}
pub(crate) fn read_chunked(r: &mut impl Read, len: usize) -> io::Result<Vec<u8>> {
let mut out = Vec::new();
while out.len() < len {
let want = (len - out.len()).min(READ_CHUNK);
let before = out.len();
let got = r
.take(u64::try_from(want).unwrap_or(u64::MAX))
.read_to_end(&mut out)?;
if got != want || out.len() != before + want {
return Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
"frame truncated",
));
}
}
Ok(out)
}
pub(crate) fn read_frame(r: &mut impl Read) -> io::Result<(u32, Vec<u8>)> {
let mut head = [0u8; 8];
r.read_exact(&mut head[..4])?;
let length = u32::from_le_bytes([head[0], head[1], head[2], head[3]]);
if !(4..=MAX_FRAME).contains(&length) {
return Err(error!("invalid frame length {length}"));
}
r.read_exact(&mut head[4..])?;
let id = u32::from_le_bytes([head[4], head[5], head[6], head[7]]);
let payload_len =
usize::try_from(length - 4).map_err(|_| error!("invalid frame length {length}"))?;
Ok((id, read_chunked(r, payload_len)?))
}
pub(crate) fn write_frame(w: &mut impl Write, id: u32, payload: &[u8]) -> io::Result<()> {
let length = payload
.len()
.checked_add(4)
.and_then(|n| u32::try_from(n).ok())
.filter(|n| *n <= MAX_FRAME)
.ok_or_else(|| error!("frame too large"))?;
let mut out = Vec::with_capacity(payload.len() + 8);
out.extend_from_slice(&length.to_le_bytes());
out.extend_from_slice(&id.to_le_bytes());
out.extend_from_slice(payload);
w.write_all(&out)?;
w.flush()
}
struct DeadlineReader<'a> {
stream: &'a TcpStream,
deadline: Option<Instant>,
}
impl Read for DeadlineReader<'_> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
if let Some(deadline) = self.deadline {
let left = deadline
.checked_duration_since(Instant::now())
.filter(|d| !d.is_zero())
.ok_or_else(|| io::Error::new(io::ErrorKind::TimedOut, "receive timed out"))?;
self.stream
.set_read_timeout(Some(at_least_a_millisecond(left)))?;
}
self.stream.read(buf).map_err(|e| match e.kind() {
io::ErrorKind::WouldBlock | io::ErrorKind::TimedOut => {
io::Error::new(io::ErrorKind::TimedOut, "receive timed out")
}
_ => e,
})
}
}
#[derive(Debug)]
pub struct Client {
host: Host,
policy: RetryPolicy,
stream: Option<TcpStream>,
answer_failed: bool,
}
fn with_host(e: &io::Error, target: &str) -> io::Error {
let kind = e.kind();
if kind == io::ErrorKind::UnexpectedEof {
io::Error::new(kind, format!("connection to {target} closed by the server"))
} else {
io::Error::new(kind, format!("{target}: {e}"))
}
}
fn at_least_a_millisecond(d: Duration) -> Duration {
d.max(Duration::from_millis(1))
}
fn open(host: &Host, policy: &RetryPolicy) -> io::Result<TcpStream> {
let target = host.to_string();
let hint = "start DayZDiag_x64.exe with -server -startNavmeshDataServer";
let addr: SocketAddr = (host.name.as_str(), host.port)
.to_socket_addrs()
.map_err(|e| error!("cannot resolve {target}: {e}"))?
.find(SocketAddr::is_ipv4)
.ok_or_else(|| error!("no IPv4 address for {target}"))?;
let stream = TcpStream::connect_timeout(&addr, at_least_a_millisecond(policy.connect_timeout))
.map_err(|e| error!("cannot connect to {target}: {e}; {hint}"))?;
stream.set_nodelay(true)?;
let t = Some(at_least_a_millisecond(policy.recv_timeout));
stream.set_read_timeout(t)?;
stream.set_write_timeout(t)?;
Ok(stream)
}
impl Client {
pub fn connect(host: &Host, policy: &RetryPolicy) -> io::Result<Self> {
Ok(Self {
host: host.clone(),
policy: policy.clone(),
stream: Some(open(host, policy)?),
answer_failed: false,
})
}
pub(crate) fn lazy(host: &Host, policy: &RetryPolicy) -> Self {
Self {
host: host.clone(),
policy: policy.clone(),
stream: None,
answer_failed: false,
}
}
pub(crate) fn last_failure_was_answer(&self) -> bool {
self.answer_failed
}
pub fn world_params(&mut self) -> io::Result<WorldParams> {
let result = self
.exchange(MSG_WORLD_PARAMS_REQUEST, &[])
.and_then(|(id, payload)| {
if id == MSG_WORLD_PARAMS {
WorldParams::parse_message(&payload)
} else {
Err(error!("expected world params, got message {id}"))
}
});
if result.is_err() {
self.stream = None;
}
result
}
pub fn tile(&mut self, x: i32, z: i32, world: &WorldParams) -> Result<TileInput, FetchError> {
let attempts = self.policy.attempts.max(1);
let mut attempt = 0u32;
loop {
match self.try_tile(x, z, world) {
Ok(t) => return Ok(t),
Err(e @ FetchError::Wire(_)) => return Err(e),
Err(FetchError::Network(e)) => {
self.stream = None;
attempt += 1;
if attempt >= attempts {
return Err(FetchError::Network(e));
}
std::thread::sleep(self.policy.delay_unit.saturating_mul(attempt));
}
}
}
}
fn try_tile(&mut self, x: i32, z: i32, world: &WorldParams) -> Result<TileInput, FetchError> {
self.answer_failed = false;
let request = encode_tile_request(x, z, &world.world);
let (id, payload) = self
.exchange(MSG_TILE_REQUEST, &request)
.map_err(FetchError::Network)?;
if id != MSG_TILE {
self.answer_failed = true;
return Err(FetchError::Network(error!(
"expected tile, got message {id}"
)));
}
let tile = TileInput::parse(&payload).map_err(FetchError::Wire)?;
if tile.x != x || tile.z != z {
self.answer_failed = true;
return Err(FetchError::Network(error!(
"the server answered with tile ({},{})",
tile.x, tile.z
)));
}
let class = usize::try_from(tile.cell_class).unwrap_or(usize::MAX);
if class >= world.cell_classes.len() {
self.answer_failed = true;
return Err(FetchError::Network(error!(
"unknown cell class {}",
tile.cell_class
)));
}
Ok(tile)
}
fn exchange(&mut self, id: u32, payload: &[u8]) -> io::Result<(u32, Vec<u8>)> {
let stream = match &mut self.stream {
Some(s) => s,
slot => slot.insert(open(&self.host, &self.policy)?),
};
let target = self.host.to_string();
write_frame(stream, id, payload).map_err(|e| with_host(&e, &target))?;
let deadline = Instant::now().checked_add(at_least_a_millisecond(self.policy.recv_timeout));
read_frame(&mut DeadlineReader { stream, deadline }).map_err(|e| with_host(&e, &target))
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
fn frame(length: u32, id: u32, payload: &[u8]) -> Vec<u8> {
let mut v = length.to_le_bytes().to_vec();
v.extend_from_slice(&id.to_le_bytes());
v.extend_from_slice(payload);
v
}
#[test]
fn the_default_backoff_is_five_tries_in_ten_seconds() {
let p = RetryPolicy::default();
assert_eq!(p.attempts, 5);
let total: Duration = (1..p.attempts).map(|n| p.delay_unit * n).sum();
assert_eq!(total, Duration::from_secs(10));
}
#[test]
fn read_frame_rules() {
let (id, p) = read_frame(&mut Cursor::new(frame(7, 5, &[1, 2, 3]))).expect("ok");
assert_eq!((id, p), (5, vec![1, 2, 3]));
let (id, p) = read_frame(&mut Cursor::new(frame(4, 9, &[]))).expect("empty");
assert_eq!((id, p), (9, vec![]));
for bad in [0u32, 3, MAX_FRAME + 1, u32::MAX] {
let e = read_frame(&mut Cursor::new(frame(bad, 5, &[0; 8]))).expect_err("bad");
assert!(e.to_string().contains("invalid frame"), "{e}");
}
}
#[test]
fn read_frame_longer_than_the_stream_is_truncated_not_allocated() {
let e = read_frame(&mut Cursor::new(frame(MAX_FRAME, 5, &[1; 5]))).expect_err("short");
assert_eq!(e.kind(), io::ErrorKind::UnexpectedEof);
}
#[test]
fn read_chunked_crosses_chunk_boundaries() {
let data = vec![7u8; READ_CHUNK + 5];
let out = read_chunked(&mut Cursor::new(&data), data.len()).expect("ok");
assert_eq!(out.len(), data.len());
assert!(read_chunked(&mut Cursor::new(&data), data.len() + 1).is_err());
}
#[test]
fn lazy_client_retries_the_first_connect() {
let port = {
let l = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
l.local_addr().expect("addr").port()
};
let policy = RetryPolicy {
attempts: 3,
delay_unit: Duration::from_millis(30),
..RetryPolicy::default()
};
let host = Host::parse(&format!("127.0.0.1:{port}")).expect("host");
let mut client = Client::lazy(&host, &policy);
let world = WorldParams::default();
let started = Instant::now();
let e = client.tile(0, 0, &world).expect_err("refused");
assert!(matches!(e, FetchError::Network(_)), "{e}");
assert!(started.elapsed() >= Duration::from_millis(90));
}
#[test]
fn write_frame_layout() {
let mut out = Vec::new();
write_frame(&mut out, 3, &[9, 8]).expect("ok");
assert_eq!(out, frame(6, 3, &[9, 8]));
}
}