Esempio n. 1
0
        void OnReceiveComplete(IncomingBuffer buffer)
        {
            if (buffer.AsyncArgs.BytesTransferred == 0)
            {
                IncomingBufferPool.TryPush(buffer);
                return;
            }

            var connection = buffer.Win32Connection;

            lock (IncomingBufferQueueSync)
            {
                IncomingBufferQueue.Enqueue(buffer);
            }

            ReceiverEvent.Set();
            Receive(connection);
        }
Esempio n. 2
0
        internal void Receive(Connection connection)
        {
            IncomingBuffer buffer;

            if (IncomingBufferPool.TryPop(out buffer))
            {
                buffer.Win32Connection = connection;

                var isDone = !connection.Socket.ReceiveAsync(buffer.AsyncArgs);
                if (isDone)
                {
                    OnReceiveComplete(buffer);
                }
            }
            else
            {
                //TODO: Error
            }
        }
Esempio n. 3
0
        void ReceiveDone(IAsyncResult result)
        {
            var buffer     = (IncomingBuffer)result.AsyncState;
            var connection = buffer.MonoConnection;

            try
            {
                var bytesTransferred = connection.Socket.EndReceive(result);

#if DEBUG
                if (bytesTransferred == 0)
                {
                    Disconnect(connection);

                    if (!IncomingBufferPool.TryPush(buffer))
                    {
                        //TODO: Error
                    }

                    return;
                }
#endif

                buffer.BytesTransferred = bytesTransferred;

                lock (IncomingBufferQueueSync)
                {
                    IncomingBufferQueue.Enqueue(buffer);
                }

                ReceiverEvent.Set();
                Receive(connection);
            }
            catch (SocketException)
            {
                Disconnect(connection);

                if (!IncomingBufferPool.TryPush(buffer))
                {
                    //TODO: Error
                }
            }
        }
Esempio n. 4
0
        internal void Receive(Connection connection)
        {
#if DEBUG
            if (connection == null)
            {
                throw new ArgumentNullException("connection");
            }
#endif
            IncomingBuffer buffer;

            if (IncomingBufferPool.TryPop(out buffer))
            {
                buffer.MonoConnection = connection;

                try
                {
                    connection.Socket.BeginReceive(
                        buffer.BufferHandle,
                        buffer.BufferOffset,
                        buffer.BufferSize,
                        System.Net.Sockets.SocketFlags.None,
                        ReceiveDone,
                        buffer
                        );
                }
                catch (SocketException)
                {
                    Disconnect(connection);
                    IncomingBufferPool.TryPush(buffer);
                }
                catch (NullReferenceException)
                {
                    // This means that socket was null (connection was already closed)
                    // We can just ignore this
                }
            }
            else
            {
                //TODO: Error
            }
        }