Struct rust_raknet::RaknetSocket

pub struct RaknetSocket { /* private fields */ }

Raknet socket wrapper with local and remote.

Implementations

impl RaknetSocket

pub fn from(
    addr: &SocketAddr,
    s: &Arc<UdpSocket>,
    receiver: Receiver<Vec<u8>>,
    mtu: u16,
    collecter: Arc<Mutex<Sender<SocketAddr>>>
) -> Self

Create a Raknet Socket from a UDP socket with an established Raknet connection

This method is used for RaknetListener, users of the library should not care about it.

pub async fn connect(addr: &SocketAddr) -> Result<Self, RaknetError>

Connect to a Raknet server and return a Raknet socket

Example

let mut 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
}

pub async fn close(&mut self) -> Result<(), RaknetError>

Close Raknet Socket. Normally you don’t need to call this method, the RaknetSocket will be closed automatically when it is released. This method can be called repeatedly.

Example

let (latency, motd) = socket::RaknetSocket::ping("127.0.0.1:19132".parse().unwrap()).await.unwrap();
assert!((0..10).contains(&latency));

pub async fn ping(addr: &SocketAddr) -> Result<(i64, String), RaknetError>

Unconnected ping a Raknet Server and return latency and motd.

Example

let (latency, motd) = socket::RaknetSocket::ping("127.0.0.1:19132".parse().unwrap()).await.unwrap();
assert!((0..10).contains(&latency));

pub async fn send(
    &mut self,
    buf: &[u8],
    r: Reliability
) -> Result<(), RaknetError>

Send a packet

packet must be 0xfe as the first byte, using other values of bytes may cause unexpected errors.

Except Reliability::ReliableOrdered, all other reliability packets must be less than MTU - 60 (default 1340 bytes), otherwise RaknetError::PacketSizeExceedMTU will be returned

Example

let mut socket = RaknetSocket::connect("127.0.0.1:19132".parse().unwrap()).await.unwrap();
socket.send(&[0xfe], Reliability::ReliableOrdered).await.unwrap();

pub async fn recv(&mut self) -> Result<Vec<u8>, RaknetError>

Recv a packet

Example

let mut socket = RaknetSocket::connect("127.0.0.1:19132".parse().unwrap()).await.unwrap();
let buf = socket.recv().await.unwrap();
if buf[0] == 0xfe{
   //do something
}

pub fn peer_addr(&self) -> Result<SocketAddr, RaknetError>

Returns the socket address of the remote peer of this Raknet connection.

Example

let socket = RaknetSocket::connect("127.0.0.1:19132".parse().unwrap()).await.unwrap();
assert_eq!(socket.peer_addr().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 19132)));

pub fn local_addr(&self) -> Result<SocketAddr, RaknetError>

Returns the socket address of the local half of this Raknet connection.

Example

let mut socket = RaknetSocket::connect("127.0.0.1:19132".parse().unwrap()).await.unwrap();
assert_eq!(socket.local_addr().unwrap().ip(), IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));

pub fn set_loss_rate(&mut self, stage: u8)

Set the packet loss rate and use it for testing

The stage parameter ranges from 0 to 10, indicating a packet loss rate of 0% to 100%.

Example

let mut socket = RaknetSocket::connect("127.0.0.1:19132".parse().unwrap()).await.unwrap();
// set 20% loss packet rate.
socket.set_loss_rate(8);

Trait Implementations

impl AsyncRead for RaknetSocket

Note: AsyncRead requires you to provide a fixed-size buffer for reading data.

However, Raknet is not a streaming protocol, so when you use AsyncRead, if you don’t provide enough buffer size (less than Raknet Packet size), then a Raknet Packet will be split into multiple reads.

This will lead to a similar TCP unpacking problem when you use AsyncRead when you are developing scenarios such as Raknet reverse proxy where the packet size cannot be predicted. https://programmer.ink/think/tcp-packet-sticking-unpacking.html So it is not recommended to use AsyncRead for developing Raknet reverse proxy.

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    buf: &mut ReadBuf<'_>
) -> Poll<Result<()>>

Attempts to read from the AsyncRead into buf.

impl AsyncWrite for RaknetSocket

Note: AsyncWrite is not stream written. Every time the data sent using AsyncWrite will be completely put into the Raknet Packet, so the returned write size is always equal to the incoming buffer size.

fn poll_write(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    buf: &[u8]
) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<()>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<()>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl Drop for RaknetSocket

fn drop(&mut self)

Executes the destructor for this type.