Example #1
0
        public void TestMethod1()
        {
            var buffer = new byte[1000];

            var sendFrame = new DataFrame("abc");
            int sendFrameSize;
            sendFrame.WriteTo(buffer, out sendFrameSize);

            DataFrame receiveFrame;
            int receiveFrameSize;
            DataFrame.TryReadFrom(buffer, sendFrameSize, out receiveFrame, out receiveFrameSize);

            Assert.AreEqual(receiveFrameSize, sendFrameSize);
            Assert.AreEqual(receiveFrame.Message, sendFrame.Message);
        }
Example #2
0
        public static bool TryReadFrom(byte[] buffer, int size, out DataFrame frame, out int consumedBytes)
        {
            frame = null;
            consumedBytes = 0;

            if (size < 2)
            {
                return false;
            }

            var stream = new BitReader(buffer, size);

            int fragmented = stream.ReadBit();
            if (fragmented == 0)
            {
                throw new NotSupportedException("Fragmented messages are currently not supported");
            }

            // Reserved
            stream.ReadBits(3);

            // Op code
            var operationCode = (OpCode)stream.ReadBits(4);
            if (operationCode != OpCode.Text)
            {
                throw new NotSupportedException("Only text frames are currently supported");
            }

            // Masking
            bool isMasked = stream.ReadBit() != 0;
            if (!isMasked)
            {
                throw new NotSupportedException("Only masked frames are supported");
            }

            // Payload
            var payloadSize = (ulong)stream.ReadBits(7);
            consumedBytes = 2;
            if (payloadSize == 126)
            {
                byte[] payloadBytes = stream.ReadBytes(2);
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(payloadBytes);
                }

                payloadSize = BitConverter.ToUInt16(payloadBytes, 0);
                consumedBytes = 4;
            }
            else if (payloadSize == 127)
            {
                byte[] payloadSizeBytes = stream.ReadBytes(4);
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(payloadSizeBytes);
                }

                payloadSize = BitConverter.ToUInt64(payloadSizeBytes, 0);
                consumedBytes = 10;
            }

            if (payloadSize > int.MaxValue)
            {
                throw new NotSupportedException("Only frames with a payload smaller than int.MaxValue are currently supported");
            }

            byte[] maskBytes = stream.ReadBytes(4);
            consumedBytes += 4;

            for (int i = 0; i < (int)payloadSize; i++)
            {
                buffer[consumedBytes + i] = (byte)(buffer[consumedBytes + i] ^ maskBytes[i % 4]);
            }

            consumedBytes += (int)payloadSize;

            string message = Encoding.UTF8.GetString(buffer, consumedBytes - (int)payloadSize, (int)payloadSize);
            frame = new DataFrame(message);
            return true;
        }
Example #3
0
 private void WriteSendBuffer(string message)
 {
     var dataFrame = new DataFrame(message);
     int frameSize;
     dataFrame.WriteTo(outputBuffer, out frameSize);
     sendBufferOffset = 0;
     sendBufferSize = frameSize;
 }