Function query_server

mserver/Client/src/query.rs:22–74

Probe one server. `Ok(Some(_))` if it answered with a well-formed status within `timeout`; `Ok(None)` if it did not respond (unreachable / wrong protocol).

(
    addr: A,
    timeout: Duration,
)

/// Probe one server. `Ok(Some(_))` if it answered with a well-formed status within
/// `timeout`; `Ok(None)` if it did not respond (unreachable / wrong protocol).
pub fn query_server<A: ToSocketAddrs>(
    addr: A,
    timeout: Duration,
) -> io::Result<Option<ServerStatus>> {
    let target = addr
        .to_socket_addrs()?
        .next()
        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "no address resolved"))?;

    let bind_any: SocketAddr = if target.is_ipv6() {
        "[::]:0".parse()
    } else {
        "0.0.0.0:0".parse()
    }
    .expect("static bind address");
    let socket = UdpSocket::bind(bind_any)?;
    socket.set_read_timeout(Some(timeout))?;

    let request = framing::frame_request(&codec::encode_enum_request(codec::MAGIC_APP), 1);
    let sent = Instant::now();
    socket.send_to(&request, target)?;

    let deadline = sent + timeout;
    let mut buf = [0u8; MSG_HEADER_LEN + SESSION_PACKET_4];
    loop {
        match socket.recv_from(&mut buf) {
            Ok((n, from)) => {
                // Ignore datagrams from a different host (basic anti-spoofing) or that
                // are not a valid response; keep waiting until the deadline.
                if from.ip() == target.ip() {
                    if let Some(session) = framing::unframe_response(&buf[..n])
                        .and_then(codec::decode_session_response)
                    {
                        let ping_ms = u32::try_from(sent.elapsed().as_millis()).unwrap_or(u32::MAX);
                        return Ok(Some(ServerStatus { session, ping_ms }));
                    }
                }
                match deadline.checked_duration_since(Instant::now()) {
                    Some(remaining) if !remaining.is_zero() => {
                        socket.set_read_timeout(Some(remaining))?;
                    }
                    _ => return Ok(None),
                }
            }
            Err(e)
                if e.kind() == io::ErrorKind::WouldBlock || e.kind() == io::ErrorKind::TimedOut =>
            {
                return Ok(None);
            }
            Err(e) => return Err(e),
        }
    }
}

#[cfg(test)]
mod tests {