rust raknet

Rostraknet

Implementierung des RakNet-Protokolls durch Rust.

Raknet ist ein zuverlässiges UDP-Transportprotokoll, das im Allgemeinen für die Kommunikation zwischen Spielclients und Servern verwendet wird und von Minecraft Bedrock Edition für die zugrunde liegende Kommunikation verwendet wird.

Das Raknet-Protokoll unterstützt verschiedene Zuverlässigkeitsoptionen und bietet in instabilen Netzwerkumgebungen eine bessere Übertragungsleistung als TCP. Bei diesem Projekt handelt es sich um eine unvollständige Implementierung des Protokolls durch Reverse Engineering.

Erfordert >= Tokio 1.x asynchrone Laufzeitunterstützung.

Referenz: http://www.jenkinssoftware.com/raknet/manual/index.html

Dieses Projekt ist weder mit Jenkins Software LLC noch mit RakNet verbunden.

Merkmale

• Asynchron
• MIT-Lizenz
• Reine Rust-Implementierung
• Schnelle Weiterübertragung
• Selektive Neuübertragung (TCP/Vollständige Neuübertragung)
• Unverzögertes ACK (TCP/verzögertes ACK)
• RTO nicht verdoppelt (TCP/RTO verdoppelt)
• Linux/Windows/Mac/BSD-Unterstützung
• Kompatibel mit Minecraft

Legen Sie los

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

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

Zuverlässigkeit

• unzuverlässig
• unzuverlässig sequenziert
• zuverlässig
• zuverlässig bestellt
• zuverlässig sequenziert

Beispiel

 //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 ( ) ;
}

Benchmark

Verwenden Sie TCP zum Vergleich mit diesem Projekt. Stellen Sie die Paketverlustrate des Servers auf 50 % ein, der Client stellt eine Verbindung zum Server her und der Server sendet alle 30 ms ein 800-Byte-Paket, insgesamt 100 Mal. Der Client zählt die Verzögerungszeit aller empfangenen Daten und berechnet die durchschnittliche Empfangszeit von 100 Malen. Die folgenden Ergebnisse werden erhalten.

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

Ergebnis:

(12. Juni 2022)

In einer Netzwerkumgebung mit hoher Paketverlustrate kann dieses Projekt die Verzögerungszeit im Vergleich zu TCP um etwa 50 % reduzieren.

Mitwirken

Optionen:

• Melden Sie einen Fehler
• Reichen Sie eine PROBLEMBERICHT zu Ihrem Vorschlag ein
• Reichen Sie eine verbesserte PR ein
• Fügen Sie ein Beispiel für die Verwendung von Rust-Raknet hinzu
• Ergänzen Sie die Dokumentation zur Verwendung von rust-raknet

Der Dank geht an diese wunderbaren Menschen.

b23r0

Substantivfve

Beiträge jeglicher Art sind willkommen! Wenn Sie schon immer einen Beitrag zu Open Source und einem guten Zweck leisten wollten, ist jetzt Ihre Chance!

Spende

BTC: 1HeroYcNYMhjsq8RYCx1stSaRZnQd9B9Eq

ETH: 0x9999997B3deF7b69c09D7a9CA65E5242fb04a764