use crate::transport::CONNECTIONLESS_HEADER;
use crate::obsolete::{CHALLENGE_RESPONSE_HEADER, PING_RESPONSE_HEADER};
use crate::cursor::{Cursor};
pub use transport::packet_processor::PacketProcessor;
pub use transport::MAX_PACKET_SIZE;
pub use transport::Error as TransportError;
pub use info::Error as InfoError;
pub use player::Error as PlayersError;
pub use rules::Error as RulesError;
mod cursor;
mod transport;
mod the_ship;
mod info;
mod player;
mod rules;
pub mod obsolete;
const EMPTY_CHALLENGE: i32 = -1;
#[derive(Debug)]
pub enum Response<'a> {
Challenge(i32),
Info(info::Info<'a>),
ObsoleteInfo(obsolete::GoldSrcInfo<'a>),
Players(player::Players<'a>),
Rules(rules::Rules<'a>),
Ping,
}
#[derive(Clone, Copy, PartialEq)]
pub(crate) enum RequestType {
Info,
Players,
Rules,
Ping,
Challenge,
}
#[derive(thiserror::Error, Debug)]
pub enum PayloadError {
#[error(transparent)]
Read(#[from] cursor::Error),
#[error("invalid header: {0}")]
InvalidHeader(u8),
#[error(transparent)]
Info(#[from] info::Error),
#[error(transparent)]
Players(#[from] player::Error),
#[error(transparent)]
Rules(#[from] rules::Error)
}
pub fn parse_payload(payload: &[u8]) -> Result<Response<'_>, PayloadError> {
let mut cur = Cursor::new(payload);
cur.read_long()?;
let header = cur.read_byte()?;
let payload = cur.as_slice();
match header {
CHALLENGE_RESPONSE_HEADER => Ok(Response::Challenge(cur.read_long()?)),
info::RESPONSE_HEADER => Ok(Response::Info(info::parse(payload)?)),
player::RESPONSE_HEADER => Ok(Response::Players(player::Players::parse(payload)?)),
rules::RESPONSE_HEADER => Ok(Response::Rules(rules::Rules::parse(payload)?)),
obsolete::INFO_RESPONSE_HEADER => Ok(Response::ObsoleteInfo(obsolete::parse_info(payload)?)),
PING_RESPONSE_HEADER => Ok(Response::Ping),
other => Err(PayloadError::InvalidHeader(other)),
}
}
fn request(req: RequestType, challenge: Option<i32>) -> Vec<u8> {
let challenge = challenge.unwrap_or(EMPTY_CHALLENGE);
let header = match req {
RequestType::Info => info::REQUEST_HEADER,
RequestType::Players => player::REQUEST_HEADER,
RequestType::Rules => rules::REQUEST_HEADER,
RequestType::Ping => obsolete::PING_REQUEST_HEADER,
RequestType::Challenge => obsolete::CHALLENGE_REQUEST_HEADER,
};
let mut request = Vec::new();
request.extend_from_slice(&CONNECTIONLESS_HEADER.to_le_bytes());
request.extend_from_slice(header);
if req == RequestType::Players || req == RequestType::Rules || (req == RequestType::Info && challenge != EMPTY_CHALLENGE) {
request.extend_from_slice(&challenge.to_le_bytes());
}
request
}
pub fn info_request(challenge: Option<i32>) -> Vec<u8> {
request(RequestType::Info, challenge)
}
pub fn players_request(challenge: Option<i32>) -> Vec<u8> {
request(RequestType::Players, challenge)
}
pub fn rules_request(challenge: Option<i32>) -> Vec<u8> {
request(RequestType::Rules, challenge)
}