a2s-protocol 0.1.1

A protocol core for building A2S server query clients
Documentation
use std::{net::UdpSocket, time::Duration};
use std::error::Error;

use a2s_protocol::{MAX_PACKET_SIZE, PacketProcessor, info_request, parse_payload, players_request, rules_request};
use a2s_protocol::Response;

#[derive(Clone, Copy)]
enum Request { Info, Players, Rules }

fn send_buf(req: Request, challenge: Option<i32>) -> Vec<u8> {
    match req {
        Request::Info => info_request(challenge),
        Request::Players => players_request(challenge),
        Request::Rules => rules_request(challenge)
    }
}

fn usage() -> ! {
    eprintln!("usage: query <addr> [info|players|rules]");
    std::process::exit(2);
}

fn main() -> Result<(), Box<dyn Error>> {
    let mut args = std::env::args().skip(1);

    let addr = args.next().unwrap_or_else(|| usage());
    let kind = args.next().unwrap_or_else(|| "info".into());

    let request = match kind.as_str() {
        "info" => Request::Info,
        "players" => Request::Players,
        "rules" => Request::Rules,
        _ => usage(),
    };

    // just some socket setup
    let socket = UdpSocket::bind("0.0.0.0:0")?;
    socket.set_read_timeout(Some(Duration::from_secs(2)))?;

    // initial request
    let mut proc = PacketProcessor::new();
    socket.send_to(&send_buf(request, None), addr)?;

    loop {
        let mut buf = [0u8; MAX_PACKET_SIZE];
        let (len, addr) = socket.recv_from(&mut buf)?;
        let buf = &buf[..len];

        // does all the work with packet assembling if requires
        // if it's still not ready, we loop again
        let Some(resp) = proc.process(addr, buf)? else {
            continue;
        };

        match parse_payload(&resp)? {
            // send challenge if demands
            Response::Challenge(num) => {
                socket.send_to(&send_buf(request, Some(num)), addr)?;
                continue;
            }
            // we got any, so print and exit
            other => {
                println!("{:#?}", other);
                break;
            }
        }
    }

    Ok(())
}