Exemple #1
0
        private bool CheckPrefixHeadComplated(WSDataToken dataToken, byte[] buffer, ref int offset)
        {
            if (dataToken.ByteArrayForPrefix == null || dataToken.ByteArrayForPrefix.Length != PreByteLength)
            {
                dataToken.ByteArrayForPrefix = new byte[PreByteLength];
            }
            if (PreByteLength - dataToken.PrefixBytesDone > buffer.Length - offset)
            {
                Buffer.BlockCopy(buffer, offset, dataToken.ByteArrayForPrefix, dataToken.PrefixBytesDone, buffer.Length - offset);
                dataToken.PrefixBytesDone += buffer.Length - offset;
                return(false);
            }

            int count = dataToken.ByteArrayForPrefix.Length - dataToken.PrefixBytesDone;

            if (count > 0)
            {
                Buffer.BlockCopy(buffer, offset, dataToken.ByteArrayForPrefix, dataToken.PrefixBytesDone, count);
                dataToken.PrefixBytesDone += count;
                offset += count;
            }
            if (dataToken.HeadFrame == null)
            {
                //build message head
                dataToken.HeadFrame = MessageHeadFrame.Parse(dataToken.ByteArrayForPrefix);
            }
            return(true);
        }
Exemple #2
0
        public override bool TryReadMeaage(WSDataToken dataToken, byte[] buffer, out List <DataMessage> messageList)
        {
            if (CheckVersion((WebSocket)dataToken.Socket))
            {
                return(base.TryReadMeaage(dataToken, buffer, out messageList));
            }
            messageList = new List <DataMessage>();
            int offset = 0;

            do
            {
                //receive buffer is complated
                if (!CheckPrefixHeadComplated(dataToken, buffer, ref offset) ||
                    !dataToken.HeadFrame.CheckRSV ||
                    !CheckPayloadHeadComplated(dataToken, buffer, ref offset) ||
                    !CheckPayloadDataComplated(dataToken, buffer, ref offset))
                {
                    return(false);
                }
                byte[] data = dataToken.HeadFrame.HasMask
                        ? DecodeMask(dataToken.ByteArrayForMessage, dataToken.ByteArrayMask, 0, dataToken.MessageLength)
                        : dataToken.ByteArrayForMessage;

                if (!dataToken.HeadFrame.FIN)
                {
                    dataToken.DataFrames.Add(new DataSegmentFrame()
                    {
                        Head = dataToken.HeadFrame,
                        Data = new ArraySegment <byte>(data)
                    });
                }
                else
                {
                    //frame complated
                    sbyte opCode;
                    if (dataToken.DataFrames.Count > 0)
                    {
                        dataToken.DataFrames.Add(new DataSegmentFrame()
                        {
                            Head = dataToken.HeadFrame,
                            Data = new ArraySegment <byte>(data)
                        });
                        opCode = dataToken.DataFrames[0].Head.OpCode;
                        data   = CombineDataFrames(dataToken.DataFrames);
                    }
                    else
                    {
                        opCode = dataToken.HeadFrame.OpCode;
                    }
                    messageList.Add(new DataMessage()
                    {
                        Data = data, Opcode = opCode
                    });
                    dataToken.DataFrames.Clear();
                }
                dataToken.Reset();
            } while (offset < buffer.Length);

            return(true);
        }
Exemple #3
0
        public override bool TryReadMeaage(WSDataToken dataToken, byte[] buffer, out List <DataMessage> messageList)
        {
            messageList = new List <DataMessage>();
            int offset = 0;

            do
            {
                //check close flag
                if (CheckCloseFlag(buffer, ref offset))
                {
                    messageList.Add(new DataMessage()
                    {
                        Data = buffer, Opcode = Opcode.Close
                    });
                    dataToken.Reset();
                    return(true);
                }
                //receive buffer is complated
                if (!CheckPrefixHeadComplated(dataToken, buffer, ref offset) ||
                    !CheckDataComplated(dataToken, buffer, ref offset))
                {
                    return(false);
                }
                byte[] data = dataToken.ByteArrayForMessage;
                if (data != null)
                {
                    messageList.Add(new DataMessage()
                    {
                        Data = data, Opcode = Opcode.Text
                    });
                }
                dataToken.Reset();
            } while (offset < buffer.Length);
            return(true);
        }
        public WebSocketListener(WebSocketListenerSetting setting)
        {
            if (setting == null)
            {
                throw new ArgumentNullException(nameof(setting));
            }

            this.setting = setting;
            if (setting.Version >= 13)
            {
                handshakeProcessor = new Rfc6455HandshakeProcessor(this, setting.Encoding);
                messageProcessor   = new Rfc6455MessageProcessor();
            }
            else if (setting.Version >= 8)
            {
                handshakeProcessor = new Hybi10HandshakeProcessor(this, setting.Encoding);
                messageProcessor   = new Hybi10MessageProcessor();
            }
            else
            {
                handshakeProcessor = new Hybi00HandshakeProcessor(this, setting.Encoding);
                messageProcessor   = new Hybi00MessageProcessor();
            }

            acceptEventArgsPool = new BlockingCollection <SocketAsyncEventArgs>();
            for (int i = 0; i < setting.MaxAcceptOps; i++)
            {
                var acceptEventArgs = new SocketAsyncEventArgs();
                acceptEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(Accept_Completed);
                acceptEventArgsPool.Add(acceptEventArgs);
            }
            var numOfSaeaForRecSend = setting.MaxConnections * 2;

            bufferManager   = new BufferManager(numOfSaeaForRecSend, setting.BufferSize);
            ioEventArgsPool = new ConcurrentStack <SocketAsyncEventArgs>();
            for (int i = 0; i < numOfSaeaForRecSend; i++)
            {
                var ioEventArgs = new SocketAsyncEventArgs();
                ioEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IO_Completed);
                bufferManager.SetBuffer(ioEventArgs);

                var dataToken = new WSDataToken();
                ioEventArgs.UserToken = dataToken;
                ioEventArgsPool.Push(ioEventArgs);
            }
        }
Exemple #5
0
        private bool CheckPayloadDataComplated(WSDataToken dataToken, byte[] buffer, ref int offset)
        {
            int copyByteCount = dataToken.RemainByte;

            if (buffer.Length - offset >= copyByteCount)
            {
                Buffer.BlockCopy(buffer, offset, dataToken.ByteArrayForMessage, dataToken.MessageBytesDone, copyByteCount);
                dataToken.MessageBytesDone += copyByteCount;
                offset += copyByteCount;
            }
            else
            {
                Buffer.BlockCopy(buffer, offset, dataToken.ByteArrayForMessage, dataToken.MessageBytesDone, buffer.Length - offset);
                dataToken.MessageBytesDone += buffer.Length - offset;
                offset += buffer.Length - offset;
            }
            return(dataToken.IsMessageReady);
        }
Exemple #6
0
        private bool CheckPrefix2Complated(WSDataToken dataToken, byte[] buffer, ref int offset, int size)
        {
            if (dataToken.ByteArrayForPrefix2 == null || dataToken.ByteArrayForPrefix2.Length != size)
            {
                dataToken.ByteArrayForPrefix2 = new byte[size];
            }
            if (size - dataToken.PrefixBytesDone2 > buffer.Length - offset)
            {
                Buffer.BlockCopy(buffer, offset, dataToken.ByteArrayForPrefix2, dataToken.PrefixBytesDone2, buffer.Length - offset);
                dataToken.PrefixBytesDone2 += buffer.Length - offset;
                return(false);
            }
            int count = dataToken.ByteArrayForPrefix2.Length - dataToken.PrefixBytesDone2;

            if (count > 0)
            {
                Buffer.BlockCopy(buffer, offset, dataToken.ByteArrayForPrefix2, dataToken.PrefixBytesDone2, count);
                dataToken.PrefixBytesDone2 += count;
                offset += count;
            }
            return(true);
        }
        internal HandshakeResult Receive(SocketAsyncEventArgs ioEventArgs, WSDataToken dataToken, byte[] data)
        {
            if (dataToken.ByteArrayForHandshake == null)
            {
                dataToken.ByteArrayForHandshake = new List <byte>(data);
            }
            else
            {
                dataToken.ByteArrayForHandshake.AddRange(data);
            }
            var socket     = (WebSocket)dataToken.Socket;
            var buffer     = dataToken.ByteArrayForHandshake.ToArray();
            int headLength = MathUtils.IndexOf(buffer, HandshakeEndBytes);

            if (headLength < 0)
            {
                //data not complate, wait receive
                return(HandshakeResult.Wait);
            }
            headLength += HandshakeEndBytes.Length;
            byte[] headBytes = new byte[headLength];
            Buffer.BlockCopy(buffer, 0, headBytes, 0, headBytes.Length);

            string        message       = Encoding.GetString(headBytes);
            HandshakeData handshakeData = socket.Handshake;

            if (TryParseHandshake(message, handshakeData, out string error))
            {
                if (handshakeData.ParamItems.ContainsKey(HandshakeHeadKeys.SecKey1) &&
                    handshakeData.ParamItems.ContainsKey(HandshakeHeadKeys.SecKey2))
                {
                    int remainBytesNum = buffer.Length - headLength;
                    if (!handshakeData.IsClient && remainBytesNum == 8)
                    {
                        byte[] secKey3Bytes = new byte[remainBytesNum];
                        Buffer.BlockCopy(buffer, headBytes.Length, secKey3Bytes, 0, secKey3Bytes.Length);
                        handshakeData.ParamItems[HandshakeHeadKeys.SecKey3] = secKey3Bytes;
                    }
                    else if (handshakeData.IsClient && remainBytesNum == 16)
                    {
                        byte[] secKey3Bytes = new byte[remainBytesNum];
                        Buffer.BlockCopy(buffer, headBytes.Length, secKey3Bytes, 0, secKey3Bytes.Length);
                        handshakeData.ParamItems[HandshakeHeadKeys.SecAccept] = secKey3Bytes;
                    }
                    else
                    {
                        //data not complate, wait receive
                        return(HandshakeResult.Wait);
                    }
                }
                if (!handshakeData.IsClient)
                {
                    if (!ResponseHandshake(socket, handshakeData))
                    {
                        //TraceLog.ReleaseWriteDebug("Client {0} handshake fail, message:\r\n{2}", session.Socket.RemoteEndPoint, message);
                        return(HandshakeResult.Close);
                    }
                    dataToken.ByteArrayForHandshake = null;
                    socket.Handshake.Handshaked     = true;
                    return(HandshakeResult.Success);
                }
                if (CheckSignKey(handshakeData))
                {
                    dataToken.ByteArrayForHandshake = null;
                    socket.Handshake.Handshaked     = true;
                    return(HandshakeResult.Success);
                }
                return(HandshakeResult.Close);
            }

            logger.Warn("Client {0} handshake {1} error, detail\r\n{2}", socket.RemoteEndPoint, error, message);
            return(HandshakeResult.Close);
        }
 public abstract bool TryReadMeaage(WSDataToken dataToken, byte[] buffer, out List <DataMessage> messageList);
Exemple #9
0
        private bool CheckPayloadHeadComplated(WSDataToken dataToken, byte[] buffer, ref int offset)
        {
            try
            {
                if (dataToken.ByteArrayForMessage == null)
                {
                    int size          = 0;
                    int payloadLenght = dataToken.HeadFrame.PayloadLenght;
                    switch (payloadLenght)
                    {
                    case 126:
                        size = 2;     //uint16 2bit
                        if (!CheckPrefix2Complated(dataToken, buffer, ref offset, size))
                        {
                            return(false);
                        }
                        UInt16 len = (UInt16)(dataToken.ByteArrayForPrefix2[0] << 8 | dataToken.ByteArrayForPrefix2[1]);
                        dataToken.ByteArrayForMessage = new byte[len];
                        break;

                    case 127:
                        size = 8;     //uint64 8bit
                        if (!CheckPrefix2Complated(dataToken, buffer, ref offset, size))
                        {
                            return(false);
                        }
                        UInt64 len64 = BitConverter.ToUInt64(dataToken.ByteArrayForPrefix2.Reverse().ToArray(), 0);
                        dataToken.ByteArrayForMessage = new byte[len64];
                        break;

                    default:
                        dataToken.ByteArrayForMessage = new byte[payloadLenght];
                        break;
                    }
                    dataToken.MessageLength = dataToken.ByteArrayForMessage.Length;
                }
                if (dataToken.HeadFrame.HasMask)
                {
                    if (dataToken.ByteArrayMask == null || dataToken.ByteArrayMask.Length != MaskLength)
                    {
                        dataToken.ByteArrayMask = new byte[MaskLength];
                    }
                    if (MaskLength - dataToken.MaskBytesDone > buffer.Length - offset)
                    {
                        Buffer.BlockCopy(buffer, offset, dataToken.ByteArrayMask, dataToken.MaskBytesDone, buffer.Length - offset);
                        dataToken.MaskBytesDone += buffer.Length - offset;
                        return(false);
                    }
                    int count = dataToken.ByteArrayMask.Length - dataToken.MaskBytesDone;
                    if (count > 0)
                    {
                        Buffer.BlockCopy(buffer, offset, dataToken.ByteArrayMask, dataToken.MaskBytesDone, count);
                        dataToken.MaskBytesDone += count;
                        offset += count;
                    }
                }
                return(true);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }