fix buffer data

Tun/Inbound/PacketInboundProcessor.swift

@@ -59,8 +59,8 @@ final class PacketInboundProcessor {
             return nil
         }
         
-        let decryptedData = try dataCipher.decrypt(cipherText: Data(data.data))
+        let decryptedData = try dataCipher.decrypt(cipherText: data.data)
-        let layerPacket = try LayerPacket(layerData: decryptedData)
+        let layerPacket = try LayerPacketView(layerData: decryptedData)
         let inboundBytes = decryptedData.count
         
         // 处理arp请求

Tun/NetworkStack/LayerPacket.swift

@@ -79,10 +79,11 @@ struct LayerPacket {
     }
     
     func marshal() -> Data {
-        var packet = Data()
+        var packet = Data(capacity: 14 + self.data.count)
         packet.append(dstMac)
         packet.append(srcMac)
-        packet.append(self.type.rawValue.data())
+        packet.append(UInt8(self.type.rawValue >> 8))
+        packet.append(UInt8(self.type.rawValue & 0x00FF))
         packet.append(self.data)
         
         return packet
@@ -97,3 +98,21 @@ struct LayerPacket {
     }
     
 }
+
+struct LayerPacketView {
+    let type: LayerPacket.PacketType
+    let data: Data
+
+    init(layerData payload: Data) throws {
+        guard payload.count >= 14 else {
+            throw LayerPacket.LayerPacketError.invalidLength
+        }
+
+        guard let type = LayerPacket.PacketType(rawValue: UInt16(bytes: (payload[12], payload[13]))) else {
+            throw LayerPacket.LayerPacketError.invaldPacketType
+        }
+
+        self.type = type
+        self.data = payload.dropFirst(14)
+    }
+}

Tun/UDPHole/SDLHoleMessage.swift

@@ -6,6 +6,7 @@
 //
 import Foundation
 import NIOCore
+import NIOFoundationCompat
 import NIOPosix
 import SwiftProtobuf
 
@@ -32,31 +33,31 @@ extension SDLHoleMessage {
         
         switch packetType {
         case .data:
-            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
+            guard let bytes = buffer.readData(length: buffer.readableBytes, byteTransferStrategy: .noCopy),
                   let dataPacket = try? SDLData(serializedBytes: bytes) else {
                 return nil
             }
             return .data(dataPacket)
         case .register:
-            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
+            guard let bytes = buffer.readData(length: buffer.readableBytes, byteTransferStrategy: .noCopy),
                let registerPacket = try? SDLRegister(serializedBytes: bytes) else {
                 return nil
             }
             return .control(.register(registerPacket))
         case .registerAck:
-            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
+            guard let bytes = buffer.readData(length: buffer.readableBytes, byteTransferStrategy: .noCopy),
                let registerAck = try? SDLRegisterAck(serializedBytes: bytes) else {
                 return nil
             }
             return .control(.registerAck(registerAck))
         case .stunProbeReply:
-            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
+            guard let bytes = buffer.readData(length: buffer.readableBytes, byteTransferStrategy: .noCopy),
                let stunProbeReply = try? SDLStunProbeReply(serializedBytes: bytes) else {
                 return nil
             }
             return .control(.stunProbeReply(stunProbeReply))
         case .stunReply:
-            guard let bytes = buffer.readBytes(length: buffer.readableBytes),
+            guard let bytes = buffer.readData(length: buffer.readableBytes, byteTransferStrategy: .noCopy),
                let stunReply = try? SDLStunReply(serializedBytes: bytes) else {
                 return nil
             }