rust raknet

filet de rouille

Implémentation du protocole RakNet par Rust.

Raknet est un protocole de transport UDP fiable qui est généralement utilisé pour la communication entre les clients et les serveurs du jeu, et est utilisé par Minecraft Bedrock Edtion pour la communication sous-jacente.

Le protocole Raknet prend en charge diverses options de fiabilité et offre de meilleures performances de transmission que TCP dans des environnements réseau instables. Ce projet est une implémentation incomplète du protocole par rétro-ingénierie.

Nécessite >= Prise en charge du runtime asynchrone Tokio 1.x.

Référence : http://www.jenkinssoftware.com/raknet/manual/index.html

Ce projet n'est pas affilié à Jenkins Software LLC ni à RakNet.

Caractéristiques

• Asynchrone
• Licence MIT
• Implémentation de Pure Rust
• Retransmission rapide
• Retransmission sélective (TCP/Retransmission complète)
• ACK non retardé (TCP/ACK retardé)
• RTO non doublé (TCP/RTO doublé)
• Prise en charge Linux/Windows/Mac/BSD
• Compatible avec Minecraft

Commencer

 # Cargo.toml
[ dependencies ]
rust-raknet = " * "

Documentation : https://docs.rs/rust-raknet/latest/rust_raknet/

Fiabilité

• peu fiable
• séquencé peu fiable
• fiable
• fiable commandé
• séquencé fiable

Exemple

 //server

async fn serve ( ) {
    let mut listener = RaknetListener :: bind ( "127.0.0.1:19132" . parse ( ) . unwrap ( ) ) . await . unwrap ( ) ;
    listener . listen ( ) . await ;
    loop {
        let socket = listener . accept ( ) . await . unwrap ( ) ;
        let buf = socket . recv ( ) . await . unwrap ( ) ;
        if buf [ 0 ] == 0xfe {
            //do something
        }
    }
    listener . close ( ) . await . unwrap ( ) ;
} 

 //client

async fn connect ( ) {
    let socket = RaknetSocket :: connect ( "127.0.0.1:19132" . parse ( ) . unwrap ( ) ) . await . unwrap ( ) ;
    socket . send ( & [ 0xfe ] , Reliability :: ReliableOrdered ) . await . unwrap ( ) ;
    let buf = socket . recv ( ) . await . unwrap ( ) ;
    if buf [ 0 ] == 0xfe {
        //do something
    }
    socket . close ( ) . await . unwrap ( ) ;
}

Référence

Utilisez TCP pour comparer avec ce projet. Définissez le taux de perte de paquets du serveur sur 50 %, le client se connecte au serveur et le serveur envoie un paquet de 800 octets toutes les 30 ms, soit un total de 100 fois. Le client compte le temps de retard de chaque donnée reçue et calcule le temps moyen de réception 100 fois. Les résultats suivants sont obtenus.

Code de test : https://github.com/b23r0/rust-raknet/blob/main/example/test_benchmark/src/main.rs

Résultat:

(12 juin 2022)

Dans un environnement réseau avec un taux de perte de paquets élevé, ce projet peut réduire le temps de retard d'environ 50 % par rapport à TCP.

Contribuer

Possibilités :

• Signaler un BUG
• Soumettre un PROBLÈME concernant une suggestion
• Soumettre un PR amélioré
• Ajouter un exemple d'utilisation de rust-raknet
• Compléter la documentation sur l'utilisation de rust-raknet

Merci à ces personnes merveilleuses.

b23r0

nomfve

Les contributions de toute nature sont les bienvenues ! Si vous avez toujours voulu contribuer à l'open source et à une bonne cause, c'est votre chance !

Donation

BTC : 1HeroYcNYMhjsq8RYCx1stSaRZnQd9B9Eq

ETH : 0x9999997B3deF7b69c09D7a9CA65E5242fb04a764