First byte changes (#2006)

Author: Vect0rZ

QuicNet.Infrastructure/PacketType.cs

@@ -6,14 +6,11 @@
 
 namespace QuicNet.Infrastructure
 {
-    public enum PacketType
+    public enum PacketType : UInt16
     {
-        InitialPacket,
-        HandshakePacket,
-        ShortHeaderPacket,
-        LongHeaderPacket,
-        RetryPacket,
-        VersionNegotiationPacket,
-        BrokenPacket
+        Initial = 0x0,
+        ZeroRTTProtected = 0x1,
+        Handshake = 0x2,
+        RetryPacket = 0x3
     }
 }

QuicNet.Infrastructure/Packets/HandshakePacket.cs

@@ -1,21 +1,91 @@
-using System;
+using QuickNet.Utilities;
+using System;
 using System.Collections.Generic;
 using System.Text;
 
 namespace QuicNet.Infrastructure.Packets
 {
     public class LongHeaderPacket : Packet
     {
-        public override byte Type => throw new NotImplementedException();
+        public override byte Type => 0xC0;
+
+        public byte DCIL_SCIL { get; set; }
+        public byte DestinationConnectionId { get; set; }
+        public byte SourceConnectionId { get; set; }
+        public VariableInteger TokenLength { get; set; }
+        public byte[] Token { get; set; }
+        public VariableInteger Length { get; set; }
+        public UInt32 PacketNumber { get; set; }
+
+        public PacketType PacketType { get; set; }
+        public LongHeaderPacket(PacketType packetType)
+        {
+            DCIL_SCIL = 0;
+            PacketType = packetType;
+        }
 
         public override void Decode(byte[] packet)
         {
-            throw new NotImplementedException();
+            ByteArray array = new ByteArray(packet);
+            byte type = array.ReadByte();
+            PacketType = (PacketType)(type & 0x30);
+
+            Version = array.ReadUInt32();
+            DCIL_SCIL = array.ReadByte();
+
+            if ((DCIL_SCIL & 0xF0) != 0)
+                DestinationConnectionId = array.ReadByte();
+            if ((DCIL_SCIL & 0x0F) != 0)
+                SourceConnectionId = array.ReadByte();
+
+            TokenLength = array.ReadVariableInteger();
+            if (TokenLength != 0)
+                Token = array.ReadBytes((int)TokenLength.Value);
+
+            Length = array.ReadVariableInteger();
+            PacketNumber = array.ReadUInt32();
+
+            Length = Length - 4;
+
+            this.DecodeFrames(array);
         }
 
         public override byte[] Encode()
         {
-            throw new NotImplementedException();
+            byte[] frames = EncodeFrames();
+
+            List<byte> result = new List<byte>();
+            result.Add(EncodeTypeField());
+            result.AddRange(ByteUtilities.GetBytes(Version));
+
+            if (DestinationConnectionId > 0)
+                DCIL_SCIL = (byte)(DCIL_SCIL | 0x50);
+            if (SourceConnectionId > 0)
+                DCIL_SCIL = (byte)(DCIL_SCIL | 0x05);
+
+            result.Add(DCIL_SCIL);
+
+            if (DestinationConnectionId > 0)
+                result.Add(DestinationConnectionId);
+            if (SourceConnectionId > 0)
+                result.Add(SourceConnectionId);
+
+            byte[] tokenLength = new VariableInteger(0);
+            byte[] length = new VariableInteger(4 + (UInt64)frames.Length);
+
+            result.AddRange(tokenLength);
+            result.AddRange(length);
+            result.AddRange(ByteUtilities.GetBytes(PacketNumber));
+            result.AddRange(frames);
+
+            return result.ToArray();
+        }
+
+        private byte EncodeTypeField()
+        {
+            byte type = (byte)(Type | (byte)PacketType | 0x03);
+
+            return type;
         }
     }
 }

QuicNet.Infrastructure/Packets/LongHeaderPacket.cs

@@ -7,7 +7,7 @@ namespace QuicNet.Infrastructure.Packets
 {
     public class ShortHeaderPacket : Packet
     {
-        public override byte Type => 0x8E; // 1000 1110;
+        public override byte Type => 0x43; // 0100 0011;
         public byte DestinationConnectionId { get; set; }
         public UInt32 PacketNumber { get; set; }
 

QuicNet.Infrastructure/Packets/RetryPacket.cs

@@ -8,30 +8,15 @@ namespace QuicNet.Infrastructure.Packets
 {
     public class Unpacker
     {
-        private Dictionary<byte, PacketType> _typeMap = new Dictionary<byte, PacketType>()
-        {
-            { 0xFF, PacketType.InitialPacket },
-            { 0xFE, PacketType.RetryPacket },
-            { 0x8E, PacketType.ShortHeaderPacket },
-            { 0x77, PacketType.LongHeaderPacket },
-            { 0x80, PacketType.VersionNegotiationPacket },
-            { 0x7D, PacketType.HandshakePacket }
-        };
-
-        public Unpacker()
-        {
-            
-        }
-
         public Packet Unpack(byte[] data)
         {
             Packet result = null;
 
-            PacketType type = GetPacketType(data);
+            QuicPacketType type = GetPacketType(data);
             switch(type)
             {
-                case PacketType.InitialPacket: result = new InitialPacket(); break;
-                case PacketType.ShortHeaderPacket: result = new ShortHeaderPacket(); break;
+                case QuicPacketType.Initial: result = new InitialPacket(); break;
+                case QuicPacketType.ShortHeader: result = new ShortHeaderPacket(); break;
             }
 
             if (result == null)
@@ -42,16 +27,24 @@ public Packet Unpack(byte[] data)
             return result;
         }
 
-        public PacketType GetPacketType(byte[] data)
+        public QuicPacketType GetPacketType(byte[] data)
         {
             if (data == null || data.Length <= 0)
-                return PacketType.BrokenPacket;
+                return QuicPacketType.Broken;
+
             byte type = data[0];
 
-            if (_typeMap.ContainsKey(type) == false)
-                return PacketType.BrokenPacket;
+            // TODO: Understand how to differentiate between Initial packet and Long Header Packet,
+            // and if there is any need to do so, or the LHP is just used for deriving the Initial packet.
 
-            return _typeMap[type];            
+            if ((type & 0xC0) == 0xC0)
+                return QuicPacketType.Initial;
+            if ((type & 0x40) == 0x40)
+                return QuicPacketType.ShortHeader;
+            if ((type & 0x80) == 0x80)
+                return QuicPacketType.VersionNegotiation;
+            
+            return QuicPacketType.Broken;            
         }
     }
 }

QuicNet.Infrastructure/Packets/ShortHeaderPacket.cs

@@ -66,16 +66,15 @@
     <Compile Include="Frames\StreamDataBlockedFrame.cs" />
     <Compile Include="NumberSpace.cs" />
     <Compile Include="PacketCreator.cs" />
-    <Compile Include="Packets\HandshakePacket.cs" />
     <Compile Include="Packets\InitialPacket.cs" />
     <Compile Include="Packets\LongHeaderPacket.cs" />
     <Compile Include="Packets\Packet.cs" />
     <Compile Include="Packets\Unpacker.cs" />
-    <Compile Include="Packets\RetryPacket.cs" />
     <Compile Include="Packets\ShortHeaderPacket.cs" />
     <Compile Include="Packets\VersionNegotiationPacket.cs" />
     <Compile Include="PacketType.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="QuicPacketType.cs" />
     <Compile Include="Settings\QuicSettings.cs" />
     <Compile Include="Settings\QuicVersion.cs" />
   </ItemGroup>

QuicNet.Infrastructure/Packets/Unpacker.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace QuicNet.Infrastructure
+{
+    public enum QuicPacketType
+    {
+        Initial,
+        LongHeader,
+        ShortHeader,
+        VersionNegotiation,
+        Broken
+    }
+}