创建项目

src/protocol/control_packet.rs

@@ -0,0 +1,205 @@
+use std::fmt;
+use std::net::Ipv4Addr;
+
+use crate::error::*;
+
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub enum Protocol {
+    Ping,
+    Pong,
+    PunchRequest,
+    PunchResponse,
+    UnKnow(u8),
+}
+
+impl From<u8> for Protocol {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => Protocol::Ping,
+            2 => Protocol::Pong,
+            3 => Protocol::PunchRequest,
+            4 => Protocol::PunchResponse,
+            val => Protocol::UnKnow(val),
+        }
+    }
+}
+
+impl Into<u8> for Protocol {
+    fn into(self) -> u8 {
+        match self {
+            Protocol::Ping => 1,
+            Protocol::Pong => 2,
+            Protocol::PunchRequest => 3,
+            Protocol::PunchResponse => 4,
+            Protocol::UnKnow(val) => val,
+        }
+    }
+}
+
+pub enum ControlPacket<B> {
+    PingPacket(PingPacket<B>),
+    PongPacket(PongPacket<B>),
+    PunchRequest(PunchRequestPacket<B>),
+    PunchResponse(PunchResponsePacket<B>),
+}
+
+impl<B: AsRef<[u8]>> ControlPacket<B> {
+    pub fn new(protocol: u8, buffer: B) -> Result<ControlPacket<B>> {
+        match Protocol::from(protocol) {
+            Protocol::Ping => Ok(ControlPacket::PingPacket(PingPacket::new(buffer)?)),
+            Protocol::Pong => Ok(ControlPacket::PongPacket(PongPacket::new(buffer)?)),
+            Protocol::PunchRequest => Ok(ControlPacket::PunchRequest(PunchRequestPacket::new(
+                buffer,
+            )?)),
+            Protocol::PunchResponse => Ok(ControlPacket::PunchResponse(PunchResponsePacket::new(
+                buffer,
+            )?)),
+            Protocol::UnKnow(_) => Err(Error::NotSupport),
+        }
+    }
+}
+
+/// 网络探针
+#[derive(Copy, Clone)]
+pub struct PingPacket<B> {
+    buffer: B,
+}
+
+#[derive(Copy, Clone)]
+pub struct PongPacket<B> {
+    buffer: B,
+}
+
+impl<B: AsRef<[u8]>> PingPacket<B> {
+    pub fn new(buffer: B) -> Result<PingPacket<B>> {
+        let len = buffer.as_ref().len();
+        if len != 8 + 4 {
+            return Err(Error::InvalidPacket);
+        }
+        Ok(PingPacket { buffer })
+    }
+}
+
+impl<B: AsRef<[u8]>> PingPacket<B> {
+    pub fn time(&self) -> i64 {
+        i64::from_be_bytes(self.buffer.as_ref()[..8].try_into().unwrap())
+    }
+    pub fn epoch(&self) -> u32 {
+        u32::from_be_bytes(self.buffer.as_ref()[8..12].try_into().unwrap())
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> PingPacket<B> {
+    pub fn set_time(&mut self, time: i64) {
+        self.buffer.as_mut()[..8].copy_from_slice(&time.to_be_bytes())
+    }
+    pub fn set_epoch(&mut self, epoch: u32) {
+        self.buffer.as_mut()[8..12].copy_from_slice(&epoch.to_be_bytes())
+    }
+}
+
+impl<B: AsRef<[u8]>> PongPacket<B> {
+    pub fn new(buffer: B) -> Result<PongPacket<B>> {
+        let len = buffer.as_ref().len();
+        if len != 8 {
+            return Err(Error::InvalidPacket);
+        }
+        Ok(PongPacket { buffer })
+    }
+}
+
+impl<B: AsRef<[u8]>> PongPacket<B> {
+    pub fn time(&self) -> i64 {
+        i64::from_be_bytes(self.buffer.as_ref()[..8].try_into().unwrap())
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> PongPacket<B> {
+    pub fn set_time(&mut self, time: i64) {
+        self.buffer.as_mut()[..8].copy_from_slice(&time.to_be_bytes())
+    }
+}
+
+pub type TurnPongPacket<B> = TurnPingPacket<B>;
+
+/// 探测目标延迟
+#[derive(Copy, Clone)]
+pub struct TurnPingPacket<B> {
+    buffer: B,
+}
+
+impl<B: AsRef<[u8]>> TurnPingPacket<B> {
+    pub fn new(buffer: B) -> Result<TurnPingPacket<B>> {
+        let len = buffer.as_ref().len();
+        if len != 16 {
+            return Err(Error::InvalidPacket);
+        }
+        Ok(TurnPingPacket { buffer })
+    }
+}
+
+impl<B: AsRef<[u8]>> TurnPingPacket<B> {
+    // pub fn source(&self) -> Ipv4Addr {
+    //     let tmp:[u8;4] = self.buffer.as_ref()[..4].try_into().unwrap();
+    //     Ipv4Addr::from(tmp)
+    // }
+    // pub fn destination(&self) -> Ipv4Addr {
+    //     let tmp:[u8;4] = self.buffer.as_ref()[4..8].try_into().unwrap();
+    //     Ipv4Addr::from(tmp)
+    // }
+    pub fn time(&self) -> i64 {
+        i64::from_be_bytes(self.buffer.as_ref()[8..].try_into().unwrap())
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> TurnPingPacket<B> {
+    pub fn set_source(&mut self, source: Ipv4Addr) {
+        self.buffer.as_mut()[..4].copy_from_slice(&source.octets());
+    }
+    pub fn set_destination(&mut self, destination: Ipv4Addr) {
+        self.buffer.as_mut()[4..8].copy_from_slice(&destination.octets());
+    }
+    pub fn set_time(&mut self, time: i64) {
+        self.buffer.as_mut()[8..].copy_from_slice(&time.to_be_bytes())
+    }
+}
+
+pub type PunchResponsePacket<B> = PunchPacket<B>;
+pub type PunchRequestPacket<B> = PunchPacket<B>;
+
+/// nat穿透
+#[derive(Clone)]
+pub struct PunchPacket<B> {
+    buffer: B,
+}
+
+impl<B: AsRef<[u8]>> PunchPacket<B> {
+    pub fn new(buffer: B) -> Result<PunchPacket<B>> {
+        let len = buffer.as_ref().len();
+        if len != 8 {
+            return Err(Error::InvalidPacket);
+        }
+        Ok(Self { buffer })
+    }
+}
+
+impl<B: AsRef<[u8]>> PunchPacket<B> {
+    pub fn source(&self) -> Ipv4Addr {
+        let tmp: [u8; 4] = self.buffer.as_ref()[..4].try_into().unwrap();
+        Ipv4Addr::from(tmp)
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> PunchPacket<B> {
+    pub fn set_source(&mut self, source: Ipv4Addr) {
+        self.buffer.as_mut()[..4].copy_from_slice(&source.octets());
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for PunchPacket<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PunchPacket")
+            .field("source", &self.source())
+            .finish()
+    }
+}

src/protocol/error_packet.rs

@@ -0,0 +1,69 @@
+use crate::error::*;
+
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub enum Protocol {
+    TokenError,
+    Disconnect,
+    Other(u8),
+}
+
+impl From<u8> for Protocol {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => Self::TokenError,
+            2 => Self::Disconnect,
+            val => Self::Other(val),
+        }
+    }
+}
+
+impl Into<u8> for Protocol {
+    fn into(self) -> u8 {
+        match self {
+            Protocol::TokenError => 1,
+            Protocol::Disconnect => 2,
+            Protocol::Other(val) => val,
+        }
+    }
+}
+
+pub enum InErrorPacket<B> {
+    TokenError,
+    Disconnect,
+    OtherError(ErrorPacket<B>),
+}
+
+impl<B: AsRef<[u8]>> InErrorPacket<B> {
+    pub fn new(protocol: u8, buffer: B) -> Result<InErrorPacket<B>> {
+        match Protocol::from(protocol) {
+            Protocol::TokenError => Ok(InErrorPacket::TokenError),
+            Protocol::Disconnect => Ok(InErrorPacket::Disconnect),
+            Protocol::Other(_) => Ok(InErrorPacket::OtherError(ErrorPacket::new(buffer)?)),
+        }
+    }
+}
+
+pub struct ErrorPacket<B> {
+    buffer: B,
+}
+
+impl<B: AsRef<[u8]>> ErrorPacket<B> {
+    pub fn new(buffer: B) -> Result<ErrorPacket<B>> {
+        Ok(Self { buffer })
+    }
+}
+
+impl<B: AsRef<[u8]>> ErrorPacket<B> {
+    pub fn message(&self) -> Result<String> {
+        match String::from_utf8(self.buffer.as_ref().to_vec()) {
+            Ok(str) => Ok(str),
+            Err(_) => Err(Error::InvalidPacket),
+        }
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> ErrorPacket<B> {
+    pub fn set_message(&mut self, message: &str) {
+        self.buffer.as_mut().copy_from_slice(message.as_bytes())
+    }
+}

src/protocol/mod.rs

@@ -0,0 +1,145 @@
+use std::fmt;
+
+use crate::error::*;
+
+pub mod control_packet;
+pub mod error_packet;
+pub mod service_packet;
+pub mod turn_packet;
+
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub enum Version {
+    V1,
+    UnKnow(u8),
+}
+
+impl From<u8> for Version {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => Version::V1,
+            val => Version::UnKnow(val),
+        }
+    }
+}
+
+impl Into<u8> for Version {
+    fn into(self) -> u8 {
+        match self {
+            Version::V1 => 1,
+            Version::UnKnow(val) => val,
+        }
+    }
+}
+
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub enum Protocol {
+    /// 服务包 用于和服务端交互
+    Service,
+    /// 响应异常
+    Error,
+    /// 控制协议
+    Control,
+    /// 转发ipv4数据
+    Ipv4Turn,
+    OtherTurn,
+    UnKnow(u8),
+}
+
+impl From<u8> for Protocol {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => Protocol::Service,
+            2 => Protocol::Error,
+            3 => Protocol::Control,
+            4 => Protocol::Ipv4Turn,
+            5 => Protocol::OtherTurn,
+            val => Protocol::UnKnow(val),
+        }
+    }
+}
+
+impl Into<u8> for Protocol {
+    fn into(self) -> u8 {
+        match self {
+            Protocol::Service => 1,
+            Protocol::Error => 2,
+            Protocol::Control => 3,
+            Protocol::Ipv4Turn => 4,
+            Protocol::OtherTurn => 5,
+            Protocol::UnKnow(val) => val,
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct NetPacket<B> {
+    buffer: B,
+}
+
+impl<B: AsRef<[u8]>> NetPacket<B> {
+    pub fn new(buffer: B) -> Result<NetPacket<B>> {
+        let len = buffer.as_ref().len();
+        // 不能大于udp最大载荷长度
+        if len < 4 || len > 65535 - 20 - 8 {
+            return Err(Error::InvalidPacket);
+        }
+        Ok(NetPacket { buffer })
+    }
+    pub fn buffer(&self) -> &[u8] {
+        self.buffer.as_ref()
+    }
+    pub fn into_buffer(self) -> B {
+        self.buffer
+    }
+}
+
+impl<B: AsRef<[u8]>> NetPacket<B> {
+    pub fn version(&self) -> Version {
+        Version::from(self.buffer.as_ref()[0])
+    }
+    pub fn protocol(&self) -> Protocol {
+        Protocol::from(self.buffer.as_ref()[1])
+    }
+    pub fn transport_protocol(&self) -> u8 {
+        self.buffer.as_ref()[2]
+    }
+    pub fn ttl(&self) -> u8 {
+        self.buffer.as_ref()[3]
+    }
+    pub fn payload(&self) -> &[u8] {
+        &self.buffer.as_ref()[4..]
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> NetPacket<B> {
+    pub fn set_version(&mut self, version: Version) {
+        self.buffer.as_mut()[0] = version.into();
+    }
+    pub fn set_protocol(&mut self, protocol: Protocol) {
+        self.buffer.as_mut()[1] = protocol.into();
+    }
+    pub fn set_transport_protocol(&mut self, transport_protocol: u8) {
+        self.buffer.as_mut()[2] = transport_protocol;
+    }
+    pub fn set_ttl(&mut self, ttl: u8) {
+        self.buffer.as_mut()[3] = ttl;
+    }
+    pub fn set_payload(&mut self, payload: &[u8]) {
+        self.buffer.as_mut()[4..payload.len() + 4].copy_from_slice(payload);
+    }
+    pub fn payload_mut(&mut self) -> &mut [u8] {
+        &mut self.buffer.as_mut()[4..]
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for NetPacket<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("NetPacket")
+            .field("version", &self.version())
+            .field("protocol", &self.protocol())
+            .field("transport_protocol", &self.transport_protocol())
+            .field("ttl", &self.ttl())
+            .field("payload", &self.payload())
+            .finish()
+    }
+}

src/protocol/service_packet.rs

@@ -0,0 +1,32 @@
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub enum Protocol {
+    /// 注册请求
+    RegistrationRequest,
+    /// 注册响应
+    RegistrationResponse,
+    /// 更新设备列表
+    UpdateDeviceList,
+    UnKnow(u8),
+}
+
+impl From<u8> for Protocol {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => Self::RegistrationRequest,
+            2 => Self::RegistrationResponse,
+            3 => Self::UpdateDeviceList,
+            val => Self::UnKnow(val),
+        }
+    }
+}
+
+impl Into<u8> for Protocol {
+    fn into(self) -> u8 {
+        match self {
+            Self::RegistrationRequest => 1,
+            Self::RegistrationResponse => 2,
+            Self::UpdateDeviceList => 3,
+            Self::UnKnow(val) => val,
+        }
+    }
+}

src/protocol/turn_packet.rs

@@ -0,0 +1,81 @@
+use std::fmt;
+use std::net::Ipv4Addr;
+
+use crate::error::*;
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum Protocol {
+    Punch,
+    UnKnow(u8),
+}
+
+impl From<u8> for Protocol {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => Protocol::Punch,
+            val => Protocol::UnKnow(val),
+        }
+    }
+}
+
+impl Into<u8> for Protocol {
+    fn into(self) -> u8 {
+        match self {
+            Protocol::Punch => 1,
+            Protocol::UnKnow(val) => val,
+        }
+    }
+}
+
+pub struct TurnPacket<B> {
+    buffer: B,
+}
+
+impl<B: AsRef<[u8]>> TurnPacket<B> {
+    pub fn new(buffer: B) -> Result<TurnPacket<B>> {
+        let len = buffer.as_ref().len();
+        if len <= 8 {
+            return Err(Error::InvalidPacket);
+        }
+        Ok(Self { buffer })
+    }
+}
+
+impl<B: AsRef<[u8]>> TurnPacket<B> {
+    pub fn source(&self) -> Ipv4Addr {
+        let tmp: [u8; 4] = self.buffer.as_ref()[..4].try_into().unwrap();
+        Ipv4Addr::from(tmp)
+    }
+    pub fn destination(&self) -> Ipv4Addr {
+        let tmp: [u8; 4] = self.buffer.as_ref()[4..8].try_into().unwrap();
+        Ipv4Addr::from(tmp)
+    }
+    pub fn payload(&self) -> &[u8] {
+        &self.buffer.as_ref()[8..]
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> TurnPacket<B> {
+    pub fn payload_mut(&mut self) -> &mut [u8] {
+        &mut self.buffer.as_mut()[8..]
+    }
+    pub fn set_source(&mut self, source: Ipv4Addr) {
+        self.buffer.as_mut()[..4].copy_from_slice(&source.octets());
+    }
+    pub fn set_destination(&mut self, destination: Ipv4Addr) {
+        self.buffer.as_mut()[4..8].copy_from_slice(&destination.octets());
+    }
+    pub fn set_payload(&mut self, payload: &[u8]) {
+        self.buffer.as_mut()[8..payload.len() + 8].copy_from_slice(payload)
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for TurnPacket<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TurnPacket")
+            .field("source", &self.source())
+            .field("destination", &self.destination())
+            .field("payload", &self.payload())
+            .finish()
+    }
+}