Пример #1
0
        private void ProcessReceive(object sender, SocketAsyncEventArgs e)
        {
            m_readArgs.Completed -= ProcessReceive;
            if (e.BytesTransferred <= 0 || e.SocketError != SocketError.Success)
            {
                Disconnect();
                return;
            }

            m_remainingLength += e.BytesTransferred;
            try
            {
                if (BuildMessage(m_bufferSegment))
                {
                    m_writeOffset = m_readOffset = 0;
                    if (m_bufferSegment.Length != BufferSize)
                    {
                        m_bufferSegment.DecrementUsage();
                        m_bufferSegment = BufferManager.GetSegment(BufferSize);
                    }
                }

                ResumeReceive();
            }
            catch (Exception ex)
            {
                logger.Error("Forced disconnection during reception : " + ex);

                Disconnect();
            }
        }
Пример #2
0
 protected override void Dispose(bool disposing)
 {
     if (Interlocked.Exchange(ref _offset, -1) == -1)
     {
         throw new InvalidOperationException("BAD BUG Packet " + this + " was already disposed!");
     }
     _segment.DecrementUsage();
     base.Dispose(disposing);
 }
Пример #3
0
        private void ProcessReceive(object sender, SocketAsyncEventArgs args)
        {
            try
            {
                args.Completed -= ProcessReceive;
                var bytesReceived = args.BytesTransferred;

                if (args.LastOperation != SocketAsyncOperation.Receive || bytesReceived == 0)
                {
                    Disconnect();
                }
                else
                {
                    Interlocked.Add(ref m_totalBytesReceived, bytesReceived);

                    m_remainingLength += bytesReceived;
                    if (BuildMessage(m_bufferSegment))
                    {
                        m_writeOffset = m_readOffset = 0;
                        if (m_bufferSegment.Length != ClientManager.BufferSize)
                        {
                            m_bufferSegment.DecrementUsage();
                            m_bufferSegment = BufferManager.GetSegment(ClientManager.BufferSize);
                        }
                    }

                    ResumeReceive();
                }
            }
            catch (Exception ex)
            {
                logger.Error("Forced disconnection " + ToString() + " : " + ex);

                Disconnect();
            }
            finally
            {
                ClientManager.Instance.PushSocketArg((PoolableSocketArgs)args);
            }
        }
Пример #4
0
        private void ProcessReceive(object sender, SocketAsyncEventArgs args)
        {
            try
            {
                var bytesReceived = args.BytesTransferred;

                if (bytesReceived == 0)
                {
                    Disconnect(ConnectingToWorld);
                }
                else
                {
                    Interlocked.Add(ref m_totalBytesReceived, bytesReceived);

                    m_remainingLength += bytesReceived;
                    if (BuildMessage(m_bufferSegment))
                    {
                        m_writeOffset = m_readOffset = 0;
                        if (m_bufferSegment.Length != ClientManager.BufferSize)
                        {
                            m_bufferSegment.DecrementUsage();
                            m_bufferSegment = BufferManager.GetSegment(ClientManager.BufferSize);
                        }
                    }

                    ResumeReceive();
                }
            }
            catch (Exception ex)
            {
                logger.Error("Fake client : Forced disconnection " + ToString() + " : " + ex);

                Disconnect();
            }
            finally
            {
                args.Completed -= ProcessReceive;
                args.Dispose();
            }
        }
Пример #5
0
        protected override void FinalizeWrite()
        {
            Position = HeaderSize;
            BufferSegment segment = BufferManager.GetSegment(ContentLength);
            int           deflatedLength;

            Compression.CompressZLib((backingStream.BaseStream as MemoryStream).GetBuffer(), segment.Buffer.Array,
                                     7, out deflatedLength);
            Write(deflatedLength);
            Write(segment.Buffer.Array);
            segment.DecrementUsage();
            base.FinalizeWrite();
        }