示例#1
0
        public void ReadBuffer(byte[] buffer, uint seq)
        {
            Sfs2X.Util.ByteArray data = new Sfs2X.Util.ByteArray(buffer);
            data.Position = 0;

            if (NextSeq == 0 || NextSeq == seq)
            {
                NextSeq = seq + (uint)data.Length;
                if (!NeedsMoreData)
                {
                    HandleNewPacket(data);
                }
                else
                {
                    HandleContinuePacket(data);
                }



                HandlePaddingPacket();
            }
            else if (seq > NextSeq)
            {
                PeddingBuffer[seq] = data;
            }
            //去除retrans
        }
示例#2
0
        private Sfs2X.Util.ByteArray ResizeByteArray(Sfs2X.Util.ByteArray data, uint pos)
        {
            int len = data.Length - (int)pos;

            byte[] b = new byte[(uint)len];
            Array.ConstrainedCopy(data.Bytes, (int)pos, b, 0, len);
            return(new Sfs2X.Util.ByteArray(b));
        }
示例#3
0
        public void ReadBuffer(byte[] buffer, uint seq)
        {
            Sfs2X.Util.ByteArray data = new Sfs2X.Util.ByteArray(buffer);
            data.Position = 0;

            if (NextSeq == 0 || NextSeq == seq)
            {
                NextSeq = seq + (uint)data.Length;
                if (!NeedsMoreData)
                    HandleNewPacket(data);
                else
                    HandleContinuePacket(data);

                HandlePaddingPacket();
            }
            else if (seq > NextSeq)
            {
                PeddingBuffer[seq] = data;
            }
            //去除retrans
        }
示例#4
0
        private void HandleContinuePacket(Sfs2X.Util.ByteArray data)
        {
            int packetRemain = PendingPacket.Header.ExpectedLength - PendingPacket.Buffer.Length;

            if (packetRemain > data.Length)
            {//还有包
                PendingPacket.Buffer.WriteBytes(data.Bytes);
                NeedsMoreData = true;
            }
            else
            {
                PendingPacket.Buffer.WriteBytes(data.Bytes, 0, packetRemain);

                if (PendingPacket.Header.Compressed)
                {
                    PendingPacket.Buffer.Uncompress();
                }

                Sfs2X.Entities.Data.SFSObject obj = Sfs2X.Entities.Data.SFSObject.NewFromBinaryData(PendingPacket.Buffer);
                string dumpstr = obj.GetDump();
                Console.WriteLine(IsReq ? "req:" : "resp");
                Console.WriteLine(dumpstr);

                Writer.WriteLine(IsReq ?    "req:=========================="
                                        :   "resp:=========================");
                Writer.WriteLine(dumpstr);

                int dataRemain = data.Length - packetRemain;
                if (dataRemain == 0)
                {
                    NeedsMoreData = false;
                }
                else
                {
                    data = ResizeByteArray(data, (uint)packetRemain);
                    HandleNewPacket(data);
                }
            }
        }
示例#5
0
        private void HandleNewPacket(Sfs2X.Util.ByteArray data)
        {
            Byte headerByte = data.ReadByte();

            PendingPacket = new Sfs2X.Bitswarm.PendingPacket(Sfs2X.Core.PacketHeader.FromBinary(headerByte));

            int dataSize;

            if (PendingPacket.Header.BigSized)
            {
                dataSize = data.ReadInt();
            }
            else
            {
                dataSize = data.ReadUShort();
            }

            data = ResizeByteArray(data, (uint)data.Position);

            PendingPacket.Header.ExpectedLength = dataSize;

            HandleContinuePacket(data);
        }
示例#6
0
        private void HandlePaddingPacket()
        {
            if (PeddingBuffer.Count > 0)
            {
                var item = PeddingBuffer.FirstOrDefault();
                if (item.Key == NextSeq)
                {
                    Sfs2X.Util.ByteArray data = item.Value;
                    PeddingBuffer.Remove(item.Key);

                    NextSeq += (uint)data.Length;
                    if (!NeedsMoreData)
                    {
                        HandleNewPacket(data);
                    }
                    else
                    {
                        HandleContinuePacket(data);
                    }

                    HandlePaddingPacket();
                }
            }
        }