raknet

raknet is a RakNet implementation for V, focused on the classic RakNet protocol used by Minecraft: Bedrock Edition.

The API is plain-structed and inspired by Sandertv's go-raknet.

Basic Server

import raknet

mut listener := raknet.listen('0.0.0.0:19132')!
defer {
    listener.close() or {}
}

listener.set_pong_data('raknet server'.bytes())!

mut conn := listener.accept()!
mut buf := []u8{len: 4096}
n := conn.read(mut buf)!
conn.write(buf[..n])!

Basic Client

import raknet

mut conn := raknet.dial('127.0.0.1:19132')!
defer {
    conn.close() or {}
}

conn.write('ping'.bytes())!
packet := conn.read_packet()!
println(packet.bytestr())

Basic Ping

import raknet

data := raknet.ping('127.0.0.1:19132')!
println(data.bytestr())

IPv6 addresses use bracket notation:

mut conn := raknet.dial('[::1]:19133')!

Configuration

import time
import raknet

mut listener := raknet.ListenConfig{
    max_mtu: 1200
    disable_cookies: false
    handshake_timeout: 10 * time.second
}.listen('0.0.0.0:19132')!

dialer := raknet.Dialer{
    max_mtu: 1200
    timeout: 2 * time.second
}
mut conn := dialer.dial(listener.addr())!

Logging

ListenConfig and Dialer both accept an optional error_log hook for diagnostic events (blocked reads, transient UDP errors, close-drain progress...) that would otherwise be silently dropped:

fn on_event(msg string, fields map[string]string) {
    eprintln('${msg}: ${fields}')
}

mut listener := raknet.ListenConfig{
    error_log: on_event
}.listen('0.0.0.0:19132')!

Tests

v test .

fn dial(address string) !&Conn

fn dial_timeout(address string, timeout time.Duration) !&Conn

fn listen(address string) !&Listener

fn load_uint24(b []u8) Uint24

fn ping(address string) ![]u8

fn ping_timeout(address string, timeout time.Duration) ![]u8

fn safe_load_uint24(b []u8) !Uint24

fn write_uint24(mut b []u8, v Uint24)

fn Reliability.from[W](input W) !Reliability

type LogFunc = fn (msg string, fields map[string]string)

LogFunc is an optional diagnostic hook. msg is a short, stable event name (e.g. "read from", "blocked read", "transient udp error", "close drain timeout") and fields carries event-specific context such as the remote address or underlying error.

type PongDataFunc = fn (net.Addr) []u8

type Uint24 = u32

fn (mut u Uint24) inc() Uint24

In V, a mutable receiver for an alias type behaves pointer-like here, so copy the underlying value explicitly before incrementing.

struct Conn {
mut:
	udp                 &net.UdpConn = unsafe { nil }
	remote              net.Addr
	remote_key          string
	mtu                 u16
	seq                 Uint24
	message_idx         Uint24
	sequence_idx        Uint24
	order_idx           Uint24
	split_id            u32
	packets             PacketChan = new_packet_chan(packet_chan_initial_cap, packet_chan_max_cap,
		packet_chan_max_bytes)
	connected           chan bool
	splits              map[u16][][]u8
	resend              ResendMap
	win                 DatagramWindow
	packet_queue        PacketQueue
	pending_ack         []Uint24
	pending_nack        []Uint24
	sent_raw            [][]u8
	rtt                 time.Duration
	last_activity       time.Time
	idle_timeout        time.Duration
	keepalive_interval  time.Duration
	read_deadline       time.Time
	write_deadline      time.Time
	read_timeout        time.Duration
	is_server           bool
	listener            &Listener   = unsafe { nil }
	mutex               &sync.Mutex = sync.new_mutex()
	ack_mutex           &sync.Mutex = sync.new_mutex()
	lifecycle_mutex     &sync.Mutex = sync.new_mutex()
	closed_chan         chan bool   = chan bool{cap: 1}
	connected_confirmed bool
	closing_deadline    time.Time
	closing             bool
	closed              bool
	error_log           LogFunc = unsafe { nil }
}

fn (mut c Conn) remote_addr() string

fn (mut c Conn) local_addr() string

fn (mut c Conn) latency() time.Duration

fn (mut c Conn) set_read_deadline(deadline time.Time)

fn (mut c Conn) set_write_deadline(deadline time.Time)

fn (mut c Conn) set_deadline(deadline time.Time)

fn (mut c Conn) set_read_timeout(timeout time.Duration)

fn (mut c Conn) set_write_timeout(timeout time.Duration)

fn (mut c Conn) set_idle_timeout(timeout time.Duration)

fn (mut c Conn) set_keepalive_interval(interval time.Duration)

fn (mut c Conn) write(data []u8) !int

fn (mut c Conn) write_reliable_ordered(data []u8) !int

fn (mut c Conn) write_reliable(data []u8) !int

fn (mut c Conn) write_unreliable(data []u8) !int

fn (mut c Conn) write_unreliable_sequenced(data []u8) !int

fn (mut c Conn) write_reliable_sequenced(data []u8) !int

fn (mut c Conn) read(mut buf []u8) !int

fn (mut c Conn) read_packet() ![]u8

fn (mut c Conn) close() !

struct Dialer {
pub mut:
	max_mtu              u16
	timeout              time.Duration
	max_transient_errors int
	error_log            LogFunc = unsafe { nil }
}

fn (dialer Dialer) ping(address string) ![]u8

fn (dialer Dialer) ping_timeout(address string, timeout time.Duration) ![]u8

fn (dialer Dialer) dial(address string) !&Conn

struct ListenConfig {
pub mut:
	disable_cookies   bool
	max_mtu           u16
	block_duration    time.Duration
	capture_packets   bool
	handshake_timeout time.Duration
	error_log         LogFunc = unsafe { nil }
}

fn (conf ListenConfig) listen(address string) !&Listener

struct Listener {
mut:
	udp                  &net.UdpConn = unsafe { nil }
	incoming             chan &Conn
	connections          map[string]&Conn
	connections_mutex    &sync.Mutex = sync.new_mutex()
	id                   i64
	closed               bool
	lifecycle_mutex      &sync.Mutex = sync.new_mutex()
	pong_data            []u8
	pong_data_func       PongDataFunc = unsafe { nil }
	pong_data_mutex      &sync.Mutex  = sync.new_mutex()
	max_mtu              u16
	disable_cookies      bool
	cookie_salt          u64
	previous_cookie_salt u64
	block_duration       time.Duration
	blocks               map[string]time.Time
	security_mutex       &sync.Mutex = sync.new_mutex()
	capture_packets      bool
	captured             [][]u8
	capture_mutex        &sync.Mutex = sync.new_mutex()
	handshake_timeout    time.Duration
	error_log            LogFunc = unsafe { nil }
}

fn (l &Listener) addr() string

fn (l &Listener) accept() !&Conn

fn (l &Listener) accept_timeout(timeout time.Duration) !&Conn

fn (mut l Listener) close() !

fn (mut l Listener) set_pong_data(data []u8) !

fn (mut l Listener) set_pong_data_func(f PongDataFunc)

fn (mut l Listener) clear_pong_data_func()

fn (mut l Listener) block(addr net.Addr)

fn (mut l Listener) block_for(addr net.Addr, duration time.Duration)

fn (mut l Listener) captured_packets() [][]u8