feat: tuic proto

Itsusinn · Itsusinn · commit d82cd4dd071e · 2025-03-19T22:11:01.000+08:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/README.md b/README.md
@@ -1 +1,2 @@
-# wind
+# wind
+
diff --git a/crates/wind-tuic/Cargo.toml b/crates/wind-tuic/Cargo.toml
@@ -6,5 +6,17 @@ edition.workspace = true
 description.workspace = true
 license = "MIT OR Apache-2.0"
 
+[features]
+default = ["server", "client"]
+server = []
+client = []
+
 [dependencies]
-tokio-util = { version = "*", features = ["codec"]}
+tokio-util = { version = "*", features = ["codec"] }
+bytes = "*"
+uuid = "*"
+hex = { package = "const-hex", version = "1" }
+
+# Patterns
+num_enum = "0.7"
+snafu = "0.8"
diff --git a/crates/wind-tuic/src/lib.rs b/crates/wind-tuic/src/lib.rs
@@ -1,3 +1,43 @@
-fn main() {
-    println!("Hello, world!");
+pub mod proto;
+
+use std::{backtrace::Backtrace, str::Utf8Error};
+
+use snafu::{IntoError as _, prelude::*};
+
+#[derive(Debug, Snafu)]
+pub enum Error {
+    VersionDismatch {
+        expect:    u8,
+        current:   u8,
+        backtrace: Backtrace,
+    },
+    UnknownCommandType {
+        value:     u8,
+        backtrace: Backtrace,
+    },
+    UnknownAddressType {
+        value:     u8,
+        backtrace: Backtrace,
+    },
+    FailParseDomain {
+        // HEX
+        raw:       String,
+        source:    Utf8Error,
+        backtrace: Backtrace,
+    },
+    DomainTooLong {
+        domain:    String,
+        backtrace: Backtrace,
+    },
+    Io {
+        // #[snafu(backtrace)]
+        source:    std::io::Error,
+        backtrace: Backtrace,
+    },
+}
+
+impl From<std::io::Error> for Error {
+    fn from(source: std::io::Error) -> Self {
+        IoSnafu.into_error(source)
+    }
 }
diff --git a/crates/wind-tuic/src/proto/mod.rs b/crates/wind-tuic/src/proto/mod.rs
@@ -0,0 +1,3 @@
+pub mod v5;
+
+pub use v5::*;
diff --git a/crates/wind-tuic/src/proto/v5/addr.rs b/crates/wind-tuic/src/proto/v5/addr.rs
@@ -0,0 +1,123 @@
+use std::net::{Ipv4Addr, Ipv6Addr};
+
+use bytes::{Buf, BufMut};
+use num_enum::{FromPrimitive, IntoPrimitive};
+use snafu::{ResultExt, ensure};
+use tokio_util::codec::{Decoder, Encoder};
+
+use crate::{DomainTooLongSnafu, FailParseDomainSnafu, UnknownAddressTypeSnafu};
+
+#[derive(Debug, Clone, Copy)]
+pub struct AddressCodec;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Address {
+    None,
+    FQDN(String, u16),
+    IPv4(Ipv4Addr, u16),
+    IPv6(Ipv6Addr, u16),
+}
+
+#[derive(IntoPrimitive, FromPrimitive, Copy, Clone, Debug, PartialEq)]
+#[repr(u8)]
+pub enum AddressType {
+    None = u8::MAX,
+    FQDN = 0,
+    IPv4 = 1,
+    IPv6 = 2,
+    #[num_enum(catch_all)]
+    Other(u8),
+}
+// https://github.com/zephry-works/wind/blob/main/crates/wind-tuic/SPEC.md#5-address-encoding
+#[cfg(feature = "server")]
+impl Decoder for AddressCodec {
+    type Error = crate::Error;
+    type Item = Address;
+
+    fn decode(&mut self, src: &mut bytes::BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if src.len() < 1 {
+            return Ok(None);
+        }
+        let addr_type = AddressType::from(src.get_u8());
+
+        ensure!(!matches!(addr_type, AddressType::Other(..)), UnknownAddressTypeSnafu { value: u8::from(addr_type) });
+        match addr_type {
+            AddressType::None => {
+                Ok(Some(Address::None))
+            }
+            AddressType::IPv4 => {
+                if src.len() < 4 + 2 {
+                    return Ok(None);
+                }
+                let mut octets = [0; 4];
+                src.copy_to_slice(&mut octets);
+                let ip = Ipv4Addr::from(octets);
+                let port = src.get_u16();
+                Ok(Some(Address::IPv4(ip, port)))
+            }
+            AddressType::IPv6 => {
+                if src.len() < 16 + 2 {
+                    return Ok(None);
+                }
+                let mut octets = [0; 16];
+                src.copy_to_slice(&mut octets);
+                let ip = Ipv6Addr::from(octets);
+                let port = src.get_u16();
+                Ok(Some(Address::IPv6(ip, port)))
+            }
+            AddressType::FQDN => {
+                if src.len() < 1 {
+                    return Ok(None);
+                }
+                let domain_len = src.get_u8() as usize;
+                if src.len() < domain_len + 2 {
+                    return Ok(None);
+                }
+
+                let domain = &src[..domain_len];
+                let domain = str::from_utf8(domain)
+                    .context(FailParseDomainSnafu {
+                        raw: hex::encode(domain),
+                    })?
+                    .to_string();
+                let port = src.get_u16();
+                Ok(Some(Address::FQDN(domain, port)))
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+#[cfg(feature = "client")]
+impl Encoder<Address> for AddressCodec {
+    type Error = crate::Error;
+
+    fn encode(&mut self, item: Address, dst: &mut bytes::BytesMut) -> Result<(), Self::Error> {
+        match item {
+            Address::None => {
+                dst.reserve(1);
+                dst.put_u8(AddressType::None.into());
+            }
+            Address::IPv4(ip, port) => {
+                dst.reserve(1 + 4 + 2);
+                dst.put_slice(&ip.octets());
+                dst.put_u16(port);
+            }
+            Address::IPv6(ip, port) => {
+                dst.reserve(1 + 16 + 2);
+                dst.put_slice(&ip.octets());
+                dst.put_u16(port);
+            }
+            Address::FQDN(domain, port) => {
+                if domain.len() > u8::MAX as usize {
+                    return DomainTooLongSnafu { domain }.fail();
+                }
+                dst.reserve(1 + domain.len() + 2);
+                dst.put_u8(domain.len() as u8);
+                dst.put_slice(domain.as_bytes());
+                dst.put_u16(port);
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/crates/wind-tuic/src/proto/v5/cmd.rs b/crates/wind-tuic/src/proto/v5/cmd.rs
@@ -0,0 +1,109 @@
+use bytes::{Buf, BufMut as _};
+use tokio_util::codec::{Decoder, Encoder};
+use uuid::Uuid;
+
+use super::CommandType;
+use crate::UnknownCommandTypeSnafu;
+
+#[derive(Debug, Clone, Copy)]
+pub struct CommandCodec(CommandType);
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Command {
+    Authenticate {
+        uuid:  uuid::Uuid,
+        token: [u8; 32],
+    },
+    Connect,
+    Packet {
+        assos_id:   u16,
+        pkt_id:     u16,
+        frag_total: u8,
+        frag_id:    u8,
+        size:       u16,
+    },
+    Dissociate {
+        assos_id: u16,
+    },
+    Heartbeat,
+}
+
+// https://github.com/zephry-works/wind/blob/main/crates/wind-tuic/SPEC.md#3-command-specifications
+#[cfg(feature = "server")]
+impl Decoder for CommandCodec {
+    type Error = crate::Error;
+    type Item = Command;
+
+    fn decode(&mut self, src: &mut bytes::BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        match self.0 {
+            CommandType::Authenticate => {
+                if src.len() < 16 + 32 {
+                    return Ok(None);
+                }
+                let mut uuid = [0; 16];
+                src.copy_to_slice(&mut uuid);
+                let uuid = Uuid::from_bytes(uuid);
+                let mut token = [0; 32];
+                src.copy_to_slice(&mut token);
+                Ok(Some(Command::Authenticate { uuid, token }))
+            }
+            CommandType::Connect => Ok(Some(Command::Connect)),
+            CommandType::Packet => {
+                if src.len() < 8 {
+                    return Ok(None);
+                }
+                let assos_id = src.get_u16();
+                let pkt_id = src.get_u16();
+                let frag_total = src.get_u8();
+                let frag_id = src.get_u8();
+                let size = src.get_u16();
+                Ok(Some(Command::Packet {
+                    assos_id,
+                    pkt_id,
+                    frag_total,
+                    frag_id,
+                    size,
+                }))
+            }
+            CommandType::Dissociate => {
+                if src.len() < 2 {
+                    return Ok(None);
+                }
+                let assos_id = src.get_u16();
+                Ok(Some(Command::Dissociate { assos_id }))
+            }
+            CommandType::Heartbeat => Ok(Some(Command::Heartbeat)),
+            CommandType::Other(value) => UnknownCommandTypeSnafu { value }.fail(),
+        }
+    }
+}
+
+#[cfg(feature = "client")]
+impl Encoder<Command> for CommandCodec {
+    type Error = crate::Error;
+
+    fn encode(&mut self, item: Command, dst: &mut bytes::BytesMut) -> Result<(), Self::Error> {
+        match item {
+            Command::Authenticate { uuid, token } => {
+                dst.reserve(16 + 32);
+                dst.put_slice(uuid.as_bytes());
+                dst.put_slice(&token);
+            },
+            Command::Connect => {},
+            Command::Packet { assos_id, pkt_id, frag_total, frag_id, size } => {
+                dst.reserve(8);
+                dst.put_u16(assos_id);
+                dst.put_u16(pkt_id);
+                dst.put_u8(frag_total);
+                dst.put_u8(frag_id);
+                dst.put_u16(size);
+            },
+            Command::Dissociate { assos_id } => {
+                dst.reserve(2);
+                dst.put_u16(assos_id);
+            },
+            Command::Heartbeat => {},
+        }
+        Ok(())
+    }
+}
diff --git a/crates/wind-tuic/src/proto/v5/header.rs b/crates/wind-tuic/src/proto/v5/header.rs
@@ -0,0 +1,69 @@
+use bytes::{Buf, BufMut};
+use num_enum::{FromPrimitive, IntoPrimitive};
+use snafu::ensure;
+use tokio_util::codec::{Decoder, Encoder};
+
+use super::VER;
+use crate::{UnknownCommandTypeSnafu, VersionDismatchSnafu};
+
+#[derive(Debug, Clone, Copy)]
+pub struct HeaderCodec;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Header {
+    pub version: u8,
+    pub command: CommandType,
+}
+
+#[derive(IntoPrimitive, FromPrimitive, Copy, Clone, Debug, PartialEq)]
+#[repr(u8)]
+pub enum CommandType {
+    Authenticate = 0,
+    Connect      = 1,
+    Packet       = 2,
+    Dissociate   = 3,
+    Heartbeat    = 4,
+    #[num_enum(catch_all)]
+    Other(u8),
+}
+
+impl Header {
+    pub fn new(command: CommandType) -> Self {
+        Self {
+            version: VER,
+            command,
+        }
+    }
+}
+
+#[cfg(feature = "server")]
+impl Decoder for HeaderCodec {
+    type Error = crate::Error;
+    type Item = Header;
+
+    fn decode(&mut self, src: &mut bytes::BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if src.len() < 2 {
+            return Ok(None);
+        }
+        let ver = src.get_u8();
+        ensure!(ver == VER, VersionDismatchSnafu { expect: VER, current: ver });
+
+        let cmd = CommandType::from(src.get_u8());
+
+        ensure!(!matches!(cmd, CommandType::Other(..)), UnknownCommandTypeSnafu { value: u8::from(cmd) });
+
+        Ok(Some(Header::new(cmd)))
+    }
+}
+
+#[cfg(feature = "client")]
+impl Encoder<Header> for HeaderCodec {
+    type Error = crate::Error;
+
+    fn encode(&mut self, item: Header, dst: &mut bytes::BytesMut) -> Result<(), Self::Error> {
+        dst.reserve(2);
+        dst.put_u8(item.version);
+        dst.put_u8(item.command.into());
+        Ok(())
+    }
+}
diff --git a/crates/wind-tuic/src/proto/v5/mod.rs b/crates/wind-tuic/src/proto/v5/mod.rs
diff --git a/rustfmt.toml b/rustfmt.toml

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+pub mod v5;`
	`2`	`+`
	`3`	`+pub use v5::*;`