@sanctumterra/raknet 1.3.2 → 1.3.22

package/build/index.d.ts

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export declare class RaknetClient {
+  constructor(ip?: string | undefined | null, port?: number | undefined | null, mtuSize?: number | undefined | null)
+  connect(): void
+  tick(): void
+  ping(): void
+  receive(): Buffer
+  frameAndSend(buffer: Buffer): void
+  send(buffer: Buffer): void
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@sanctumterra/raknet",
-  "version": "1.3.2",
+  "version": "1.3.22",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build:rust": "napi build --platform --release build",
+    "build:rust": "napi build --release build",
     "build:ts": "tsc",
     "dev": "npm run build:rust && npm run build:ts",
     "format": "npx @biomejs/biome format ./src_client",
@@ -35,6 +35,14 @@
       ]
     }
   },
+  "files": [
+    "RakNet-win.node",
+    "RakNet-linux.node",
+    "RakNet-osx.node",
+    "build",
+    "dist",
+    "tsconfig.json"
+  ],
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
     "@napi-rs/cli": "^2.18.4",

package/.github/workflows/publish.yml

@@ -1,41 +0,0 @@
-name: Publish to NPM
-
-on:
-  push:
-    branches:
-      - develop
-      - main  # Change this to your default branch if different
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'  # Ensure this matches your engines.node version
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Run lint
-        run: npm run lint
-
-      - name: Clean build directory
-        run: rm -rf build dist  # Clean previous build artifacts
-
-      - name: Build Rust
-        run: npm run build:rust
-
-      - name: Build TypeScript
-        run: npm run build:ts
-
-      - name: Publish to NPM
-        run: npm publish --access=public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "raknet"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-chrono = "0.4.38"
-rand = "0.8.5"
-napi = "2"
-napi-derive = "2"
-
-[build-dependencies]
-napi-build = "2.1.3"

package/build.rs

@@ -1,3 +0,0 @@
-fn main() {
-    napi_build::setup();
-}

package/src/binarystream/binarystream.rs

@@ -1,313 +0,0 @@
-use std::error::Error;
-
-use super::Endianness;
-
-#[derive(Debug)]
-pub enum BinaryStreamError {
-    OutOfBounds,
-    InvalidLength,
-}
-
-impl std::fmt::Display for BinaryStreamError {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-impl Error for BinaryStreamError {}
-
-#[derive(Debug)]
-pub struct BinaryStream {
-    pub binary: Vec<u8>,
-    offset: u32
-}
-
-impl BinaryStream {
-    pub fn new(binary: Option<Vec<u8>>, offset: Option<u32>) -> Self {
-        let bin = match binary {
-            Some(buffer) => buffer,
-            None => vec![],
-          };
-      
-          let offset = match offset {
-            Some(offset) => offset,
-            None => 0,
-          };
-      
-        BinaryStream {
-            binary: bin,
-            offset,
-        }
-    }
-
-    pub fn from(binary: Vec<u8>, offset: Option<u32>) -> Self {
-        let offset = match offset {
-            Some(offset) => offset,
-            None => 0,
-        };
-    
-        BinaryStream {
-          binary: binary,
-          offset,
-        }
-    }
-
-    pub fn read(&mut self, length: u32) -> Result<Vec<u8>, BinaryStreamError> {
-        if length > self.binary.len() as u32 {
-            return Err(BinaryStreamError::InvalidLength);
-        }
-    
-        if self.offset + length > self.binary.len() as u32 {
-            return Err(BinaryStreamError::OutOfBounds);
-        }
-    
-        let start = self.offset as usize;
-        let end = (self.offset + length) as usize;
-        self.offset += length;
-    
-        Ok(self.binary[start..end].to_vec())
-    }
-
-    pub fn write(&mut self, data: Vec<u8>) {
-        self.binary.extend(data);
-    }
-
-    pub fn read_remaining(&mut self) -> Vec<u8> {
-        let start = self.offset as usize;
-        let end = self.binary.len();
-        self.offset = end as u32;
-    
-        self.binary[start..end].to_vec()
-    }
-
-    pub fn skip(&mut self, length: u32) {
-        self.offset += length;
-    }
-
-    pub fn cursor_at_end(&self) -> bool {
-        self.offset == self.binary.len() as u32
-    }
-    
-    pub fn cursor_at_start(&self) -> bool {
-        self.offset == 0
-    }
-
-    pub fn get_offset(&self) -> u32 {
-        self.offset
-    }
-
-    pub fn read_bytes(&mut self, length: u32) -> Result<Vec<u8>, BinaryStreamError> {
-        Ok(self.read(length)?)
-    }
-
-    pub fn write_bytes(&mut self, data: Vec<u8>) {
-        self.write(data);
-    }
-
-    pub fn read_u8(&mut self) -> Result<u8, BinaryStreamError> {
-        let bytes = self.read(1)?;
-        Ok(bytes[0])
-    }
-
-    pub fn write_u8(&mut self, value: u8) {
-        self.write(vec![value]);
-    }
-
-    pub fn read_magic(&mut self) -> Result<Vec<u8>, BinaryStreamError> {
-        let magic = self.read(16)?;
-        Ok(magic)
-    }
-
-    pub fn write_magic(&mut self, magic: Vec<u8>) {
-        self.write(magic);
-    }
-
-    pub fn read_u16(&mut self, endianness: Option<Endianness>) -> Result<u16, BinaryStreamError> {
-        let bytes = self.read(2)?;
-        Ok(match endianness.unwrap_or(Endianness::Big) {
-            Endianness::Big => u16::from_be_bytes(bytes.try_into().unwrap()),
-            Endianness::Little => u16::from_le_bytes(bytes.try_into().unwrap()),
-        })
-    }
-
-    pub fn write_u16(&mut self, value: u16, endianness: Option<Endianness>) {
-        let bytes = match endianness.unwrap_or(Endianness::Big) {
-            Endianness::Big => value.to_be_bytes(),
-            Endianness::Little => value.to_le_bytes(),
-        };
-        self.write(bytes.to_vec());
-    }
-
-    pub fn read_u64(&mut self, endianness: Option<Endianness>) -> Result<u64, BinaryStreamError> {
-        let bytes = self.read(8)?;
-        let bytes: [u8; 8] = bytes.try_into()
-            .map_err(|_| BinaryStreamError::InvalidLength)?;
-            
-        Ok(match endianness.unwrap_or(Endianness::Little) {
-            Endianness::Big => u64::from_be_bytes(bytes),
-            Endianness::Little => u64::from_le_bytes(bytes),
-        })
-    }
-
-    pub fn write_u64(&mut self, value: u64, endianness: Option<Endianness>) {
-        let bytes = match endianness.unwrap_or(Endianness::Little) {
-            Endianness::Big => value.to_be_bytes(),
-            Endianness::Little => value.to_le_bytes(),
-        };
-        self.write(bytes.to_vec());
-    }
-
-    pub fn read_u32(&mut self, endianness: Option<Endianness>) -> Result<u32, BinaryStreamError> {
-        let endian = match endianness {
-            Some(endian) => endian,
-            None => Endianness::Big,
-        };
-      
-        let bytes = match self.read(4) {
-            Ok(bytes) => bytes,
-            Err(err) => return Err(err)
-        };
-          
-        match endian {
-            Endianness::Big => Ok(u32::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])),
-            Endianness::Little => Ok(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])),
-        }
-    }
-
-    pub fn write_u32(&mut self, value: u32, endianness: Option<Endianness>) {
-        let endian = match endianness {
-            Some(endian) => endian,
-            None => Endianness::Big,
-        };
-        match endian {
-            Endianness::Big => self.write(value.to_be_bytes().to_vec()),
-            Endianness::Little => self.write(value.to_le_bytes().to_vec()),
-        }
-    }
-
-    pub fn read_bool(&mut self) -> Result<bool, BinaryStreamError> {
-        let value = self.read_u8()?;
-        Ok(value != 0)
-    }
-
-    pub fn write_bool(&mut self, value: bool) {
-        self.write_u8(if value { 1 } else { 0 });
-    }
-
-    pub fn read_u24(&mut self, endianness: Option<Endianness>) -> Result<u32, BinaryStreamError> {
-        let endian = match endianness {
-            Some(endian) => endian,
-            None => Endianness::Big,
-        };
-          
-        let bytes = match self.read(3) {
-            Ok(bytes) => bytes,
-            Err(err) => return Err(err)
-        };
-      
-        match endian {
-            Endianness::Big => Ok(u32::from_be_bytes([0, bytes[0], bytes[1], bytes[2]])),
-            Endianness::Little => Ok(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], 0])),
-        }
-    }
-
-    pub fn write_u24(&mut self, value: u32, endianness: Option<Endianness>) {
-        let endian = match endianness {
-            Some(endian) => endian,
-            None => Endianness::Big,
-        };
-      
-        match endian {
-            Endianness::Big => self.write(value.to_be_bytes()[1..].to_vec()),
-            Endianness::Little => self.write(value.to_le_bytes()[..3].to_vec()),
-        }    
-    }
-
-    pub fn read_i16(&mut self, endianness: Option<Endianness>) -> Result<i16, BinaryStreamError> {
-        let endian = match endianness {
-            Some(endian) => endian,
-            None => Endianness::Big,
-        };
-      
-        let bytes = match self.read(2) {
-            Ok(bytes) => bytes,
-            Err(err) => return Err(err)
-        };
-      
-        match endian {
-            Endianness::Big => Ok(i16::from_be_bytes([bytes[0], bytes[1]])),
-            Endianness::Little => Ok(i16::from_le_bytes([bytes[0], bytes[1]])),
-        }
-    }
-
-    pub fn write_i16(&mut self, value: i16, endianness: Option<Endianness>) {
-        let endian = match endianness {
-            Some(endian) => endian,
-            None => Endianness::Big,
-        };
-
-        match endian {
-            Endianness::Big => self.write(value.to_be_bytes().to_vec()),
-            Endianness::Little => self.write(value.to_le_bytes().to_vec()),
-        }
-    }
-
-    pub fn read_i64(&mut self, endianness: Option<Endianness>) -> Result<i64, BinaryStreamError> {
-        let bytes = self.read(8)?;
-        let bytes: [u8; 8] = bytes.try_into()
-            .map_err(|_| BinaryStreamError::InvalidLength)?;
-        Ok(match endianness.unwrap_or(Endianness::Big) {
-            Endianness::Big => i64::from_be_bytes(bytes),
-            Endianness::Little => i64::from_le_bytes(bytes),
-        })
-    }
-
-    pub fn write_i64(&mut self, value: i64, endianness: Option<Endianness>) {
-        let endian = match endianness {
-            Some(endian) => endian,
-            None => Endianness::Big,
-        };
-      
-        match endian {
-            Endianness::Big => self.write(value.to_be_bytes().to_vec()),
-            Endianness::Little => self.write(value.to_le_bytes().to_vec()),
-        }
-    }
-
-    pub fn read_long(&mut self, endianness: Option<Endianness>) -> Result<i64, BinaryStreamError> {
-        Ok(self.read_i64(Some(endianness.unwrap_or(Endianness::Big)))?)
-    }
-
-    pub fn write_long(&mut self, value: i64, endianness: Option<Endianness>) {
-        self.write_i64(value, Some(endianness.unwrap_or(Endianness::Big)));
-    }
-
-    pub fn read_short(&mut self, endianness: Option<Endianness>) -> Result<u16, BinaryStreamError> {
-        let bytes = self.read(2)?;
-
-        match endianness.unwrap_or(Endianness::Big) {
-            Endianness::Big => Ok((bytes[0] as u16) << 8 | bytes[1] as u16),
-            Endianness::Little => Ok((bytes[1] as u16) << 8 | bytes[0] as u16),
-        }
-    }
-
-    pub fn write_short(&mut self, value: u16, endianness: Option<Endianness>) {
-        match endianness.unwrap_or(Endianness::Big) {
-            Endianness::Big => {
-                self.write(vec![(value >> 8) as u8, (value & 0xFF) as u8]);
-            },
-            Endianness::Little => {
-                self.write(vec![(value & 0xFF) as u8, (value >> 8) as u8]);
-            }
-        }
-    }
-
-    pub fn read_byte(&mut self) -> Result<u8, BinaryStreamError> {
-        let byte = self.read(1)?;
-        Ok(byte[0])
-    }
-
-    pub fn write_byte(&mut self, value: u8) {
-        self.write(vec![value]);
-    }
-}

package/src/binarystream/endianess.rs

@@ -1,5 +0,0 @@
-#[derive(Debug)]
-pub enum Endianness {
-    Big,
-    Little,
-}

package/src/binarystream/mod.rs

@@ -1,6 +0,0 @@
-pub mod binarystream;
-pub mod endianess;
-
-pub use binarystream::BinaryStream;
-pub use binarystream::BinaryStreamError;
-pub use endianess::Endianness;

package/src/client/client.rs

@@ -1,201 +0,0 @@
-use chrono::Utc;
-use rand::Rng;
-
-use crate::{
-    packets::{
-        open_connection_request_one::OpenConnectionRequestOne, packet::Packet, packet_types::PacketType, Ack, Address, ConnectionRequest, Frame, FrameSet, OpenConnectionReplyOne, OpenConnectionReplyTwo, OpenConnectionRequestTwo, Priority, Reliability, UnconnectedPing
-    },
-    socket::{Socket, SocketError},
-};
-
-use super::Framer;
-
-pub struct Client {
-    socket: Socket,
-    address: String,
-    pub mtu_size: u16,
-    framer: Framer,
-    port: u16,
-    guid: i64,
-    step: u32
-}
-
-impl Client {
-    pub fn new(address: Option<String>, port: Option<u16>, mtu_size: Option<u16>) -> Result<Self, SocketError> {
-        let socket = Socket::new(None, None)?;
-        let address = address.unwrap_or("127.0.0.1".to_string());
-        let port = port.unwrap_or(socket.get_local_port());
-        let guid = rand::thread_rng().gen_range(0..i64::MAX);
-        let mtu_size = mtu_size.unwrap_or(1492);
-        
-        let framer = Framer::new(socket.clone(), mtu_size, address.clone(), port);
-        
-        Ok(Self { socket, address, port, guid, step: 0, mtu_size, framer })
-    }
-
-    pub fn send(&self, buffer: &[u8]) -> Result<usize, SocketError> {
-        self.socket.send(buffer, &format!("{}:{}", self.address, self.port))
-    }
-
-    pub fn tick(&mut self) -> Result<(), SocketError> {
-        let _ = self.framer.tick();
-        Ok(())
-    }
-
-    pub fn ping(&self) -> Result<(), SocketError> {
-        let timestamp = Utc::now().timestamp();
-        let packet = UnconnectedPing::new(timestamp, self.guid);
-        let serialized = packet.serialize().unwrap();
-        self.send(&serialized)?;
-        Ok(())
-    }
-
-    pub fn frame_and_send(&mut self, buffer: &[u8]) -> Result<(), SocketError> {
-        let mut frame = self.pls_frame(buffer)?;
-        self.framer.send_frame(&mut frame, Priority::Immediate).unwrap();
-        Ok(())
-    }
-
-    pub fn get_timestamp(&self) -> i64 {
-        Utc::now().timestamp()
-    }
-
-    pub fn connect(&mut self) -> Result<(), SocketError> {
-        let mut mtu_size = self.mtu_size;
-        if self.step == 1 {
-            mtu_size = 1200;
-        }
-        if self.step == 2 {
-            mtu_size = 576;
-        }
-
-        let packet = OpenConnectionRequestOne {
-            protocol_version: 11,
-            mtu_size: mtu_size as usize,
-        };
-
-
-        let serialized = packet.serialize().unwrap();
-        self.send(&serialized)?;
-        Ok(())
-    }
-
-    pub fn receive(&mut self) -> Result<Vec<u8>, SocketError> {
-        let mut buffer = [0; 1500];
-        let (size, _) = self.socket.receive(&mut buffer).unwrap();
-        
-        if size > 0 {
-            let _ = self.handle_packet(&buffer[..size]);
-        }
-        Ok(buffer[..size].to_vec())
-    }
-
-    fn pls_frame(&mut self, buffer: &[u8]) -> Result<Frame, SocketError> {
-        let frame = Frame {
-            reliability: Reliability::ReliableOrdered,
-            reliable_frame_index: Some(1),
-            sequence_frame_index: None,
-            ordered_frame_index: Some(0),
-            order_channel: Some(0),
-            split_frame_index: None,
-            split_size: None,
-            split_id: None,
-            payload: buffer.to_vec()
-        };
-        Ok(frame)
-    }
-
-    fn send_frame(&mut self, buffer: &[u8]) -> Result<(), SocketError> {
-        let mut frame = Frame {
-            reliability: Reliability::ReliableOrdered,
-            reliable_frame_index: Some(1),
-            sequence_frame_index: None,
-            ordered_frame_index: Some(0),
-            order_channel: Some(0),
-            split_frame_index: None,
-            split_size: None,
-            split_id: None,
-            payload: buffer.to_vec()
-        };
-        self.framer.send_frame(&mut frame, Priority::Immediate).unwrap();
-        Ok(())
-    }
-
-    fn handle_packet(&mut self, buffer: &[u8]) -> Result<(), SocketError> {
-        if buffer.is_empty() {
-            return Ok(());
-        }
-        let mut packet_type = PacketType::from(buffer[0]);
-        
-        if (packet_type.to_u8() & 0xf0) == 0x80 {
-            packet_type = PacketType::FrameSet;
-        }
-
-        match packet_type {
-            PacketType::UnconnectedPong => {
-                self.framer.add_received_packet(buffer.to_vec());
-            },
-            PacketType::OpenConnectionReplyOne => {
-                let packet = OpenConnectionReplyOne::deserialize(buffer).unwrap();
-                let request_two = OpenConnectionRequestTwo {
-                    address: Address::new(self.address.clone(), self.port, 4),
-                    mtu_size: packet.mtu_size,
-                    guid: self.guid
-                };
-                let serialized = request_two.serialize().unwrap();
-                self.send(&serialized)?;
-                if packet.mtu_size > 1500 {
-                    self.connect()?;
-                }
-            },
-            PacketType::OpenConnectionReplyTwo => {
-                let packet = OpenConnectionReplyTwo::deserialize(buffer).unwrap();
-                let conn_request = ConnectionRequest {
-                    guid: self.guid,
-                    timestamp: Utc::now().timestamp(),
-                    security: false,
-                };
-                let serialized = conn_request.serialize().unwrap();
-                self.send_frame(&serialized)?;
-                if packet.mtu_size > 1500 {
-                    self.connect()?;
-                }
-            },
-            PacketType::FrameSet => {
-                let _ = self.framer.on_frame_set(&FrameSet::deserialize(buffer).unwrap());
-            },
-            PacketType::Ack => {
-                let frame = Frame {
-                    reliability: Reliability::ReliableOrdered,
-                    reliable_frame_index: Some(1),
-                    sequence_frame_index: None,
-                    ordered_frame_index: Some(0),
-                    order_channel: Some(0),
-                    split_frame_index: None,
-                    split_size: None,
-                    split_id: None,
-                    payload: buffer.to_vec()
-                };
-                self.framer.process_packet(&frame).unwrap();
-            },
-            PacketType::Nack => {
-                let frame = self.pls_frame(buffer)?;
-                self.framer.process_packet(&frame).unwrap();
-            },
-            _ => {}
-        }
-
-        Ok(())
-    }
-
-    pub fn get_received_packets(&mut self) -> Result<Vec<Vec<u8>>, SocketError> {
-        let mut buffer = [0; 1500];
-        let (size, _) = self.socket.receive(&mut buffer)?;
-        
-        if size > 0 {
-            let _ = self.handle_packet(&buffer[..size]);
-        }
-
-        Ok(self.framer.get_received_packets())
-    }
-}