Exemple #1
0
        void NetworkServer_NotifyReceivedPackage(object sender, IocpPacketEventArgs e)
        {
            NetworkComputeBuffer ComputeBuffer = null;

            lock (ComputeTable)
            {
                if (ComputeTable.ContainsKey(e.token.UniqueId))
                {
                    ComputeBuffer = ComputeTable[e.token.UniqueId];
                }
            }

            //附加数据到缓冲区
            ComputeBuffer.TotalBuffer.Write(e.Buffer, 0, e.Buffer.Length);

            //开始拆分封包数据
            while (ComputeBuffer.TotalBuffer.Length >= Shared.GetPackageInformationLength())                  //封包是否符合逻辑
            {
                //开始读取封包
                BinaryReader ComputeReader = ComputeBuffer.GetReader();

                uint   CurrentBlockLength      = ComputeReader.ReadUInt32();                //当前数据分块的长度
                ushort CurrentPackageSignature = ComputeReader.ReadUInt16();                //封包标记

                if (
                    CurrentBlockLength <= 0 ||                                   //包大小是否负数
                    CurrentBlockLength > 0x100000 ||                             //包大小大于1MB
                    CurrentBlockLength < Shared.GetPackageInformationLength() || //包头的大小
                    CurrentPackageSignature != Shared.PackageSignature           //包标记
                    )
                {
                    throw new BadPackageException();
                }

                if (CurrentBlockLength > ComputeBuffer.TotalBuffer.Length)                 //是否完整的数据,就等待客户端下次发送数据到达
                {
                    break;
                }

                int CurrentBlockDataLength = (int)CurrentBlockLength - Shared.GetPackageInformationLength();

                //解密数据
                byte[] encrypted = ComputeReader.ReadBytes(CurrentBlockDataLength);
                byte[] decrypted = AESEx.AESDecrypt(encrypted, CommonConfig.key, CommonConfig.iv);


                if (USERNotifyReceivedPackage != null)
                {
                    USERNotifyReceivedPackage(this, new USER_NetworkReceivedArgs(e.token, decrypted));
                }

                int nextBufferLength = (int)(ComputeBuffer.TotalBuffer.Length - CurrentBlockLength);
                ComputeBuffer.TotalBuffer.SetLength(0);
                ComputeBuffer.TotalBuffer.Write(ComputeReader.ReadBytes(nextBufferLength), 0, nextBufferLength);
            }
        }
Exemple #2
0
        public bool Connect(string host, int port)
        {
            try
            {
                _instance.Connect(host, port);

                NetworkComputeBuffer ComputeBuffer = new NetworkComputeBuffer(_instance);

                ComputeBuffer.SocketStream.BeginRead(ComputeBuffer.CurrentBuffer, 0, ComputeBuffer.CurrentBuffer.Length, new AsyncCallback(AsyncReadCallBack), ComputeBuffer);
            }
            catch (Exception)
            {
                return(false);
            }

            return(true);
        }
Exemple #3
0
        public bool Connect(string host, int port)
        {
            try
            {
                _instance.Connect(host, port);

                NetworkComputeBuffer ComputeBuffer = new NetworkComputeBuffer(_instance);

                ComputeBuffer.SocketStream.BeginRead(ComputeBuffer.CurrentBuffer, 0, ComputeBuffer.CurrentBuffer.Length, new AsyncCallback(AsyncReadCallBack), ComputeBuffer);
            }
            catch (Exception)
            {
                return false;
            }

            return true;
        }
Exemple #4
0
        private void AsyncReadCallBack(IAsyncResult ar)
        {
            NetworkComputeBuffer ComputeBuffer = ar.AsyncState as NetworkComputeBuffer;

            try
            {
                ComputeBuffer.BytesTransferred = ComputeBuffer.SocketStream.EndRead(ar);
                if (ComputeBuffer.BytesTransferred > 0)
                {
                    //附加数据到缓冲区
                    ComputeBuffer.TotalBuffer.Write(ComputeBuffer.CurrentBuffer, 0, ComputeBuffer.BytesTransferred);

                    //开始拆分封包数据
                    while (ComputeBuffer.TotalBuffer.Length >= Marshal.SizeOf(typeof(Shared.PackageInformation)))                          //封包是否符合逻辑
                    {
                        //开始读取封包
                        BinaryReader ComputeReader = ComputeBuffer.GetReader();

                        uint   CurrentBlockLength      = ComputeReader.ReadUInt32();                        //当前数据分块的长度
                        ushort CurrentPackageSignature = ComputeReader.ReadUInt16();                        //封包标记

                        if (
                            CurrentBlockLength <= 0 ||                                                //包大小是否负数
                            CurrentBlockLength > 0x100000 ||                                          //包大小大于1MB
                            CurrentBlockLength < Marshal.SizeOf(typeof(Shared.PackageInformation)) || //包头的大小
                            CurrentPackageSignature != Shared.PackageSignature                        //包标记
                            )
                        {
                            throw new BadPackageException();
                        }

                        if (CurrentBlockLength > ComputeBuffer.TotalBuffer.Length)                         //是否完整的数据,就等待客户端下次发送数据到达
                        {
                            break;
                        }

                        int CurrentBlockDataLength = (int)CurrentBlockLength - Marshal.SizeOf(typeof(Shared.PackageInformation));

                        //解密数据
                        byte[] encrypted = ComputeReader.ReadBytes(CurrentBlockDataLength);
                        byte[] decrypted = AESEx.AESDecrypt(encrypted, CommonConfig.key, CommonConfig.iv);


                        if (NotifyReceivedPackage != null)
                        {
                            NotifyReceivedPackage(this, new PacketEventArgs(decrypted));
                        }


                        int nextBufferLength = (int)(ComputeBuffer.TotalBuffer.Length - CurrentBlockLength);
                        ComputeBuffer.TotalBuffer.SetLength(0);
                        ComputeBuffer.TotalBuffer.Write(ComputeReader.ReadBytes(nextBufferLength), 0, nextBufferLength);
                    }

                    //读取下一个
                    ComputeBuffer.SocketStream.BeginRead(ComputeBuffer.CurrentBuffer, 0, ComputeBuffer.CurrentBuffer.Length, new AsyncCallback(AsyncReadCallBack), ComputeBuffer);
                }
                else
                {
                    if (NotifyDisconnectedConnection != null)
                    {
                        NotifyDisconnectedConnection(this, new DisconnectEventArgs(DisconnectEventArgs.ReasonType.ReaderException));
                    }

                    _instance.Close();
                }
            }
            catch (BadPackageException)
            {
                if (NotifyDisconnectedConnection != null)
                {
                    NotifyDisconnectedConnection(this, new DisconnectEventArgs(DisconnectEventArgs.ReasonType.ReaderException));
                }
                _instance.Close();
            }
            catch (Exception)
            {
                if (NotifyDisconnectedConnection != null)
                {
                    NotifyDisconnectedConnection(this, new DisconnectEventArgs(DisconnectEventArgs.ReasonType.ReaderException));
                }
                _instance.Close();
            };
        }