支持tap网卡,优化tun网卡配置

switch/packet/src/arp/arp.rs

@@ -0,0 +1,123 @@
+use std::fmt;
+
+/// 地址解析协议，由IP地址找到MAC地址
+/// https://www.ietf.org/rfc/rfc6747.txt
+/*
+   0      2       4         5          6      8      10  (字节)
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  | 硬件类型|协议类型|硬件地址长度|协议地址长度|操作类型|
+  |          源MAC地址                  |    源ip地址    |
+  |          目的MAC地址                 |   目的ip地址   |
+ */
+use crate::error::*;
+
+pub struct ArpPacket<B> {
+    buffer: B,
+}
+
+impl<B: AsRef<[u8]>> ArpPacket<B> {
+    pub fn unchecked(buffer: B) -> Self {
+        Self { buffer }
+    }
+    pub fn new(buffer: B) -> Result<Self> {
+        if buffer.as_ref().len() != 28 {
+            Err(Error::InvalidPacket)?
+        }
+        let packet = Self::unchecked(buffer);
+        Ok(packet)
+    }
+}
+
+impl<B: AsRef<[u8]>> ArpPacket<B> {
+    /// 硬件类型 以太网类型为1
+    pub fn hardware_type(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[0..2].try_into().unwrap())
+    }
+    /// 上层协议类型,ipv4是0x0800
+    pub fn protocol_type(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
+    }
+    /// 如果是MAC地址 则长度为6
+    pub fn hardware_size(&self) -> u8 {
+        self.buffer.as_ref()[4]
+    }
+    /// 如果是IPv4 则长度为4
+    pub fn protocol_size(&self) -> u8 {
+        self.buffer.as_ref()[5]
+    }
+    /// 操作类型，请求和响应 1：ARP请求，2：ARP响应，3：RARP请求，4：RARP响应
+    pub fn op_code(&self) -> u16 {
+        u16::from_be_bytes(self.buffer.as_ref()[6..8].try_into().unwrap())
+    }
+    /// 发送端硬件地址，仅支持以太网
+    pub fn sender_hardware_addr(&self) -> &[u8] {
+        &self.buffer.as_ref()[8..14]
+    }
+    /// 发送端协议地址，仅支持IPv4
+    pub fn sender_protocol_addr(&self) -> &[u8] {
+        &self.buffer.as_ref()[14..18]
+    }
+    /// 接收端硬件地址，仅支持以太网
+    pub fn target_hardware_addr(&self) -> &[u8] {
+        &self.buffer.as_ref()[18..24]
+    }
+    /// 接收端协议地址，仅支持IPv4
+    pub fn target_protocol_addr(&self) -> &[u8] {
+        &self.buffer.as_ref()[24..28]
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> ArpPacket<B> {
+    /// 硬件类型 以太网类型为1
+    pub fn set_hardware_type(&mut self, value: u16) {
+        self.buffer.as_mut()[0..2].copy_from_slice(&value.to_be_bytes())
+    }
+    /// 上层协议类型,ipv4是0x0800
+    pub fn set_protocol_type(&mut self, value: u16) {
+        self.buffer.as_mut()[2..4].copy_from_slice(&value.to_be_bytes())
+    }
+    /// 如果是MAC地址 则长度为6
+    pub fn set_hardware_size(&mut self, value: u8) {
+        self.buffer.as_mut()[4] = value
+    }
+    /// 如果是IPv4 则长度为4
+    pub fn set_protocol_size(&mut self, value: u8) {
+        self.buffer.as_mut()[5] = value
+    }
+    /// 操作类型，请求和响应 1：ARP请求，2：ARP响应，3：RARP请求，4：RARP响应
+    pub fn set_op_code(&mut self, value: u16) {
+        self.buffer.as_mut()[6..8].copy_from_slice(&value.to_be_bytes())
+    }
+    /// 发送端硬件地址，仅支持以太网
+    pub fn set_sender_hardware_addr(&mut self, buf: &[u8]) {
+        self.buffer.as_mut()[8..14].copy_from_slice(buf)
+    }
+    /// 发送端协议地址，仅支持IPv4
+    pub fn set_sender_protocol_addr(&mut self, buf: &[u8]) {
+        self.buffer.as_mut()[14..18].copy_from_slice(buf)
+    }
+    /// 接收端硬件地址，仅支持以太网
+    pub fn set_target_hardware_addr(&mut self, buf: &[u8]) {
+        self.buffer.as_mut()[18..24].copy_from_slice(buf)
+    }
+    /// 接收端协议地址，仅支持IPv4
+    pub fn set_target_protocol_addr(&mut self, buf: &[u8]) {
+        self.buffer.as_mut()[24..28].copy_from_slice(buf)
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for ArpPacket<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ArpPacket")
+            .field("hardware_type", &self.hardware_type())
+            .field("protocol_type", &self.protocol_type())
+            .field("hardware_size", &self.hardware_size())
+            .field("protocol_size", &self.protocol_size())
+            .field("op_code", &self.op_code())
+            .field("sender_hardware_addr", &self.sender_hardware_addr())
+            .field("sender_protocol_addr", &self.sender_protocol_addr())
+            .field("target_hardware_addr", &self.target_hardware_addr())
+            .field("target_protocol_addr", &self.target_protocol_addr())
+            .finish()
+    }
+}

switch/packet/src/arp/mod.rs

@@ -0,0 +1 @@
+pub mod arp;

switch/packet/src/ethernet/mod.rs

@@ -0,0 +1,2 @@
+pub mod packet;
+pub mod protocol;

switch/packet/src/ethernet/packet.rs

@@ -0,0 +1,78 @@
+use std::fmt;
+use crate::error::*;
+use crate::ethernet::protocol::Protocol;
+
+/// 以太网帧协议
+/// https://www.ietf.org/rfc/rfc894.txt
+/*
+   0                      6                      12    14 (字节)
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |        目的地址         |         源地址         | 类型 |
+ */
+pub struct EthernetPacket<B> {
+    pub buffer: B,
+}
+
+impl<B: AsRef<[u8]>> EthernetPacket<B> {
+    pub fn unchecked(buffer: B) -> EthernetPacket<B> {
+        EthernetPacket { buffer }
+    }
+
+    pub fn new(buffer: B) -> Result<EthernetPacket<B>> {
+        let packet = EthernetPacket::unchecked(buffer);
+        //头部固定14位
+        if packet.buffer.as_ref().len() < 14 {
+            Err(Error::SmallBuffer)?
+        }
+
+        Ok(packet)
+    }
+}
+
+impl<B: AsRef<[u8]>> EthernetPacket<B> {
+    /// 目的MAC地址
+    pub fn destination(&self) -> &[u8] {
+        &self.buffer.as_ref()[0..6]
+    }
+    /// 源MAC地址
+    pub fn source(&self) -> &[u8] {
+        &self.buffer.as_ref()[6..12]
+    }
+    /// 3层协议
+    pub fn protocol(&self) -> Protocol {
+        u16::from_be_bytes(self.buffer.as_ref()[12..14].try_into().unwrap()).into()
+    }
+    /// 载荷
+    pub fn payload(&self) -> &[u8] {
+        &self.buffer.as_ref()[14..]
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> EthernetPacket<B> {
+    pub fn set_destination(&mut self, value: &[u8]) {
+        self.buffer.as_mut()[0..6].copy_from_slice(value);
+    }
+
+    pub fn set_source(&mut self, value: &[u8]) {
+        self.buffer.as_mut()[6..12].copy_from_slice(value);
+    }
+
+    pub fn set_protocol(&mut self, value: Protocol) {
+        let p: u16 = value.into();
+        self.buffer.as_mut()[12..14].copy_from_slice(&p.to_be_bytes())
+    }
+    pub fn payload_mut(&mut self) -> &mut [u8] {
+        &mut self.buffer.as_mut()[14..]
+    }
+}
+
+impl<B: AsRef<[u8]>> fmt::Debug for EthernetPacket<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EthernetPacket")
+            .field("destination", &self.destination())
+            .field("source", &self.source())
+            .field("protocol", &self.protocol())
+            .field("payload", &self.payload())
+            .finish()
+    }
+}

switch/packet/src/ethernet/protocol.rs

@@ -0,0 +1,141 @@
+/// 以太网帧协议
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub enum Protocol {
+    ///
+    Ipv4,
+
+    ///
+    Arp,
+
+    ///
+    WakeOnLan,
+
+    ///
+    Trill,
+
+    ///
+    DecNet,
+
+    ///
+    Rarp,
+
+    ///
+    AppleTalk,
+
+    ///
+    Aarp,
+
+    ///
+    Ipx,
+
+    ///
+    Qnx,
+
+    ///
+    Ipv6,
+
+    ///
+    FlowControl,
+
+    ///
+    CobraNet,
+
+    ///
+    Mpls,
+
+    ///
+    MplsMulticast,
+
+    ///
+    PppoeDiscovery,
+
+    ///
+    PppoeSession,
+
+    ///
+    Vlan,
+
+    ///
+    PBridge,
+
+    ///
+    Lldp,
+
+    ///
+    Ptp,
+
+    ///
+    Cfm,
+
+    ///
+    QinQ,
+
+    ///
+    Unknown(u16),
+}
+
+impl From<u16> for Protocol {
+    fn from(value: u16) -> Protocol {
+        use self::Protocol::*;
+
+        match value {
+            0x0800 => Ipv4,
+            0x0806 => Arp,
+            0x0842 => WakeOnLan,
+            0x22f3 => Trill,
+            0x6003 => DecNet,
+            0x8035 => Rarp,
+            0x809b => AppleTalk,
+            0x80f3 => Aarp,
+            0x8137 => Ipx,
+            0x8204 => Qnx,
+            0x86dd => Ipv6,
+            0x8808 => FlowControl,
+            0x8819 => CobraNet,
+            0x8847 => Mpls,
+            0x8848 => MplsMulticast,
+            0x8863 => PppoeDiscovery,
+            0x8864 => PppoeSession,
+            0x8100 => Vlan,
+            0x88a8 => PBridge,
+            0x88cc => Lldp,
+            0x88f7 => Ptp,
+            0x8902 => Cfm,
+            0x9100 => QinQ,
+            n      => Unknown(n),
+        }
+    }
+}
+
+impl Into<u16> for Protocol {
+    fn into(self) -> u16 {
+        use self::Protocol::*;
+
+        match self {
+            Ipv4           => 0x0800,
+            Arp            => 0x0806,
+            WakeOnLan      => 0x0842,
+            Trill          => 0x22f3,
+            DecNet         => 0x6003,
+            Rarp           => 0x8035,
+            AppleTalk      => 0x809b,
+            Aarp           => 0x80f3,
+            Ipx            => 0x8137,
+            Qnx            => 0x8204,
+            Ipv6           => 0x86dd,
+            FlowControl    => 0x8808,
+            CobraNet       => 0x8819,
+            Mpls           => 0x8847,
+            MplsMulticast  => 0x8848,
+            PppoeDiscovery => 0x8863,
+            PppoeSession   => 0x8864,
+            Vlan           => 0x8100,
+            PBridge        => 0x88a8,
+            Lldp           => 0x88cc,
+            Ptp            => 0x88f7,
+            Cfm            => 0x8902,
+            QinQ           => 0x9100,
+            Unknown(n)     => n,
+        }
+    }
+}

switch/packet/src/ip/ipv4/packet.rs

@@ -1,7 +1,6 @@
 use std::fmt;
 use std::net::Ipv4Addr;
 
-use byteorder::{BigEndian, ReadBytesExt};
 
 use crate::cal_checksum;
 use crate::error::*;
@@ -141,16 +140,12 @@ impl<B: AsRef<[u8]>> IpV4Packet<B> {
 
     /// ip报总字节数
     pub fn length(&self) -> u16 {
-        (&self.buffer.as_ref()[2..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[2..4].try_into().unwrap())
     }
 
     /// 标识. ip报文在数据链路层可能会被拆分，同一报文的不同分组标识字段相同
     pub fn id(&self) -> u16 {
-        (&self.buffer.as_ref()[4..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[4..6].try_into().unwrap())
     }
 
     /// 标志 3位.
@@ -170,10 +165,7 @@ impl<B: AsRef<[u8]>> IpV4Packet<B> {
     /// 以字节为单位,用于指明分段起始点相对于包头起始点的偏移量
     /// 由于分段到达时可能错序，所以分段的偏移字段可以使接收者按照正确的顺序重组数据包
     pub fn offset(&self) -> u16 {
-        (&self.buffer.as_ref()[6..])
-            .read_u16::<BigEndian>()
-            .unwrap()
-            & 0x1fff
+        u16::from_be_bytes(self.buffer.as_ref()[6..8].try_into().unwrap()) & 0x1fff
     }
 
     /// 生存时间.
@@ -189,9 +181,7 @@ impl<B: AsRef<[u8]>> IpV4Packet<B> {
 
     /// 首部校验和
     pub fn checksum(&self) -> u16 {
-        (&self.buffer.as_ref()[10..])
-            .read_u16::<BigEndian>()
-            .unwrap()
+        u16::from_be_bytes(self.buffer.as_ref()[10..12].try_into().unwrap())
     }
     /// 验证校验和
     ///

switch/packet/src/lib.rs

@@ -8,7 +8,8 @@ pub mod icmp;
 pub mod ip;
 pub mod tcp;
 pub mod udp;
-
+pub mod ethernet;
+pub mod arp;
 // pub enum IpUpperLayer<B> {
 //     UDP(UdpPacket<B>),
 //     Unknown(B),

switch/packet/src/tcp/tcp.rs

@@ -76,6 +76,17 @@ impl<B: AsRef<[u8]>> TcpPacket<B> {
     }
 }
 
+impl<B: AsRef<[u8]> + AsMut<[u8]>> TcpPacket<B> {
+    fn set_checksum(&mut self, value: u16) {
+        self.buffer.as_mut()[16..18].copy_from_slice(&value.to_be_bytes())
+    }
+    /// 更新校验和
+    pub fn update_checksum(&mut self) {
+        //先将校验和置0
+        self.set_checksum(0);
+        self.set_checksum(self.cal_checksum())
+    }
+}
 impl<B: AsRef<[u8]>> TcpPacket<B> {
     /// 源端口
     pub fn source_port(&self) -> u16 {