Esempio n. 1
0
        private void EnsureCapacity(int size)
        {
            BufferSegment segment = BufferManager.GetSegment(size);

            _segment.CopyTo(segment, _length);
            m_Position = m_Position - _segment.Offset + segment.Offset;
            _segment.DecrementUsage();
            _segment = segment;
        }
Esempio n. 2
0
        private void ProcessRecieve(SocketAsyncEventArgs args)
        {
            try
            {
                var bytesReceived = args.BytesTransferred;

                if (bytesReceived == 0)
                //if (args.SocketError != SocketError.Success)
                {
                    // no bytes means the client disconnected, so clean up!
                    _server.DisconnectClient(this, true);
                }
                else
                {
                    // increment our counters
                    unchecked
                    {
                        _bytesReceived += (uint)bytesReceived;
                    }

                    Interlocked.Add(ref _totalBytesReceived, bytesReceived);

                    _remainingLength += bytesReceived;

                    if (OnReceive(_bufferSegment))
                    {
                        // packet processed entirely
                        _offset          = 0;
                        _remainingLength = 0;
                        _bufferSegment.DecrementUsage();
                        _bufferSegment = Buffers.CheckOut();
                    }
                    else
                    {
                        EnsureBuffer();
                    }

                    ResumeReceive();
                }
            }
            catch (ObjectDisposedException)
            {
                _server.DisconnectClient(this, true);
            }
            catch (Exception e)
            {
                _server.Warning(this, e);
                _server.DisconnectClient(this, true);
            }
            finally
            {
                args.Completed -= ReceiveAsyncComplete;
                SocketHelpers.ReleaseSocketArg(args);
            }
        }
Esempio n. 3
0
        private void EnsureCapacity(int size)
        {
            // return the old segment and get a new, bigger one
            var newSegment = BufferManager.GetSegment(size);

            _segment.CopyTo(newSegment, _length);
            m_Position = m_Position - _segment.Offset + newSegment.Offset;

            _segment.DecrementUsage();
            _segment = newSegment;
        }
Esempio n. 4
0
 protected virtual void Dispose(bool disposing)
 {
     lock (typeof(ClientBase))
     {
         if (_tcpSock == null || !_tcpSock.Connected)
         {
             return;
         }
         try
         {
             _bufferSegment.DecrementUsage();
             _tcpSock.Shutdown(SocketShutdown.Both);
             _tcpSock.Close();
             _tcpSock = null;
         }
         catch (Exception ex)
         {
         }
     }
 }
Esempio n. 5
0
 protected virtual void Dispose(bool disposing)
 {
     lock (typeof(ClientBase))
     {
         if (_tcpSock != null && _tcpSock.Connected)
         {
             try
             {
                 _bufferSegment.DecrementUsage();
                 _tcpSock.Shutdown(SocketShutdown.Both);
                 _tcpSock.Close();
                 _tcpSock = null;
             }
             catch (Exception ex)
             {
                 //log.ErrorException("failed to dispose client "+AddrTemp,ex);
             }
         }
     }
 }