Struct ConnectToken

pub struct ConnectToken {
    pub client_id: u64,
    pub version_info: [u8; 13],
    pub protocol_id: u64,
    pub create_timestamp: u64,
    pub expire_timestamp: u64,
    pub xnonce: [u8; 24],
    pub server_addresses: [Option<SocketAddr>; 32],
    pub client_to_server_key: [u8; 32],
    pub server_to_client_key: [u8; 32],
    pub private_data: [u8; 1024],
    pub timeout_seconds: i32,
}

A public connect token that the client receives to start connecting to the server. How the client receives ConnectToken is up to you, could be from a matchmaking system or from a call to a REST API as an example.

Fields

client_id: u64

version_info: [u8; 13]

protocol_id: u64

create_timestamp: u64

expire_timestamp: u64

xnonce: [u8; 24]

server_addresses: [Option<SocketAddr>; 32]

client_to_server_key: [u8; 32]

server_to_client_key: [u8; 32]

private_data: [u8; 1024]

timeout_seconds: i32

Implementations

impl ConnectToken

pub fn generate( current_time: Duration, protocol_id: u64, expire_seconds: u64, client_id: u64, timeout_seconds: i32, server_addresses: Vec<SocketAddr>, user_data: Option<&[u8; 256]>, private_key: &[u8; 32], ) -> Result<Self, TokenGenerationError>

Generate a token to be sent to an client. The user data is available to the server after an successfull conection. The private key and the protocol id must be the same used in server.

Examples found in repository

examples/echo.rs (lines 58-67)

fn main() {
    println!("Usage: server [SERVER_PORT] or client [SERVER_PORT] [USER_NAME]");
    let args: Vec<String> = std::env::args().collect();
    let private_key = b"an example very very secret key."; // 32-bytes

    let exec_type = &args[1];
    match exec_type.as_str() {
        "client" => {
            let server_addr: SocketAddr = format!("127.0.0.1:{}", args[2]).parse().unwrap();
            let username = Username(args[3].clone());
            let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
            println!("Stating connecting at {:?} with username {}", now, username.0,);
            let client_id = now.as_millis() as u64;
            let connect_token = ConnectToken::generate(
                now,
                PROTOCOL_ID,
                300,
                client_id,
                15,
                vec![server_addr],
                Some(&username.to_netcode_user_data()),
                private_key,
            )
            .unwrap();
            let auth = ClientAuthentication::Secure { connect_token };
            client(auth);
        }
        "server" => {
            let server_addr: SocketAddr = format!("127.0.0.1:{}", args[2]).parse().unwrap();
            server(server_addr, *private_key);
        }
        _ => {
            println!("Invalid argument, first one must be \"client\" or \"server\".");
        }
    }
}

pub fn write(&self, writer: &mut impl Write) -> Result<(), Error>

pub fn read(src: &mut impl Read) -> Result<Self, NetcodeError>

Trait Implementations

impl Clone for ConnectToken

fn clone(&self) -> ConnectToken

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ConnectToken

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for ConnectToken

fn eq(&self, other: &ConnectToken) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ConnectToken

impl StructuralPartialEq for ConnectToken