Ejemplo n.º 1
0
        public void SendResponse()
        {
            try
            {
                fContext.CurrentResponse.KeepAlive = ((AsyncHttpServer)AsyncOwner).KeepAlive;
                Byte[] lHeader = Encoding.ASCII.GetBytes(fContext.CurrentResponse.Header.ToString());

                if (lHeader.Length >= 4096 || fContext.CurrentResponse.ContentSource == ContentSource.ContentNone)
                {
                    fBodyOffset = 0;

                    switch (fContext.CurrentResponse.ContentSource)
                    {
                    case ContentSource.ContentBytes:
                        DataConnection.BeginWrite(lHeader, 0, fBodyOffset, ResponseBodyCallback, fContext.CurrentResponse.ContentBytes);
                        break;

                    case ContentSource.ContentString:
                        Byte[] lBuffer = fContext.CurrentResponse.Encoding.GetBytes(fContext.CurrentResponse.ContentString);
                        DataConnection.BeginWrite(lHeader, 0, fBodyOffset, ResponseBodyCallback, lBuffer);
                        break;

                    case ContentSource.ContentStream:
                        fContext.CurrentResponse.ContentStream.Position = 0;
                        DataConnection.BeginWrite(lHeader, 0, fBodyOffset, ResponseBodyCallback, fContext.CurrentResponse.ContentStream);
                        break;

                    default:
                        DataConnection.BeginWrite(lHeader, 0, fBodyOffset, ResponseBodyCallback, null);
                        break;
                    }
                }
                else
                {
                    if (fBodyBuffer == null)
                    {
                        fBodyBuffer = new Byte[4096];
                    }

                    Array.Copy(lHeader, 0, fBodyBuffer, 0, lHeader.Length);
                    fBodyOffset = fBodyBuffer.Length - lHeader.Length;

                    switch (fContext.CurrentResponse.ContentSource)
                    {
                    case ContentSource.ContentBytes:
                        if (fBodyOffset > fContext.CurrentResponse.ContentBytes.Length)
                        {
                            fBodyOffset = fContext.CurrentResponse.ContentBytes.Length;
                        }
                        Array.Copy(fContext.CurrentResponse.ContentBytes, 0, fBodyBuffer, lHeader.Length, fBodyOffset);
                        DataConnection.BeginWrite(fBodyBuffer, 0, fBodyOffset + lHeader.Length, ResponseBodyCallback, fContext.CurrentResponse.ContentBytes);
                        break;

                    case ContentSource.ContentString:
                        Byte[] lBuffer = fContext.CurrentResponse.Encoding.GetBytes(fContext.CurrentResponse.ContentString);
                        if (fBodyOffset > lBuffer.Length)
                        {
                            fBodyOffset = lBuffer.Length;
                        }
                        Array.Copy(lBuffer, 0, fBodyBuffer, lHeader.Length, fBodyOffset);
                        DataConnection.BeginWrite(fBodyBuffer, 0, fBodyOffset + lHeader.Length, ResponseBodyCallback, lBuffer);
                        break;

                    case ContentSource.ContentStream:
                        fContext.CurrentResponse.ContentStream.Position = 0;
                        fBodyOffset = fContext.CurrentResponse.ContentStream.Read(fBodyBuffer, lHeader.Length, fBodyOffset);
                        DataConnection.BeginWrite(fBodyBuffer, 0, fBodyOffset + lHeader.Length, ResponseBodyCallback, fContext.CurrentResponse.ContentStream);
                        break;

                    default:
                        DataConnection.BeginWrite(lHeader, 0, fBodyOffset, ResponseBodyCallback, null);
                        break;
                    }
                }
            }
            catch (ConnectionClosedException)
            {
                this.fOwner.TriggerHttpResponseFailed(new AsyncHttpRequestEventArgs(this.DataConnection, this.fContext));
                Done();
            }
            catch (SocketException)
            {
                this.fOwner.TriggerHttpResponseFailed(new AsyncHttpRequestEventArgs(this.DataConnection, this.fContext));
                Done();
            }
            catch (ObjectDisposedException)
            {
                this.fOwner.TriggerHttpResponseFailed(new AsyncHttpRequestEventArgs(this.DataConnection, this.fContext));
                Done();
            }
        }
Ejemplo n.º 2
0
        private void ResponseBodyCallback(IAsyncResult ar)
        {
            try
            {
                DataConnection.EndWrite(ar);

                if (ar.AsyncState is Stream)
                {
                    Stream lData = (Stream)ar.AsyncState;
                    Int32  lLen  = lData.Read(fBodyBuffer, 0, fBodyBuffer.Length);
                    if (lLen != 0)
                    {
                        DataConnection.BeginWrite(fBodyBuffer, 0, lLen, ResponseBodyCallback, lData);
                        return;
                    }
                }
                else if (ar.AsyncState is Byte[])
                {
                    Byte[] lData = (Byte[])ar.AsyncState;
                    Int32  lLen  = fBodyBuffer.Length;
                    if (fBodyOffset + lLen > lData.Length)
                    {
                        lLen = lData.Length - fBodyOffset;
                    }
                    if (lLen != 0)
                    {
                        Array.Copy(lData, fBodyOffset, fBodyBuffer, 0, lLen);
                        fBodyOffset += lLen;
                        DataConnection.BeginWrite(fBodyBuffer, 0, lLen, ResponseBodyCallback, lData);
                        return;
                    }
                }
            }
            catch (ConnectionClosedException)
            {
                this.fOwner.TriggerHttpResponseFailed(new AsyncHttpRequestEventArgs(this.DataConnection, this.fContext));
                Done();
                return;
            }
            catch (SocketException)
            {
                this.fOwner.TriggerHttpResponseFailed(new AsyncHttpRequestEventArgs(this.DataConnection, this.fContext));
                Done();
                return;
            }
            catch (ObjectDisposedException)
            {
                this.fOwner.TriggerHttpResponseFailed(new AsyncHttpRequestEventArgs(this.DataConnection, this.fContext));
                Done();
                return;
            }

            //AsyncHttpContext lOldContext = fContext;

            fContext = this.fOwner.NewContext(this);
            try
            {
                DataConnection.BeginReadLine(HeaderFirstLineCallback, null);
            }
            catch (SocketException)
            {
                this.fOwner.TriggerHttpResponseFailed(new AsyncHttpRequestEventArgs(this.DataConnection, this.fContext));
                Done();
                return;
            }

            catch (ObjectDisposedException)
            {
                this.fOwner.TriggerHttpResponseFailed(new AsyncHttpRequestEventArgs(this.DataConnection, this.fContext));
                Done();
                return;
            }
            this.fOwner.TriggerHttpResponseSent(new AsyncHttpRequestEventArgs(this.DataConnection, this.fContext));
        }
        private void ResponseBodyCallback(IAsyncResult ar)
        {
            try
            {
                DataConnection.EndWrite(ar);

                if (ar.AsyncState is Stream)
                {
                    Stream lData = (Stream)ar.AsyncState;
                    Int32  lLen  = lData.Read(fBodyBuffer, 0, fBodyBuffer.Length);
                    if (lLen != 0)
                    {
                        DataConnection.BeginWrite(fBodyBuffer, 0, lLen, new AsyncCallback(ResponseBodyCallback), lData);
                        return;
                    }
                }
                else if (ar.AsyncState is Byte[])
                {
                    Byte[] lData = (Byte[])ar.AsyncState;
                    Int32  lLen  = fBodyBuffer.Length;
                    if (fBodyOffset + lLen > lData.Length)
                    {
                        lLen = lData.Length - fBodyOffset;
                    }
                    if (lLen != 0)
                    {
                        Array.Copy(lData, fBodyOffset, fBodyBuffer, 0, lLen);
                        fBodyOffset += lLen;
                        DataConnection.BeginWrite(fBodyBuffer, 0, lLen, new AsyncCallback(ResponseBodyCallback), lData);
                        return;
                    }
                }
            }
            catch (ConnectionClosedException)
            {
                ((AsyncHttpServer)Owner).TriggerOnHttpResponseFailed(DataConnection, fContext);
                return;
            }
            catch (SocketException)
            {
                ((AsyncHttpServer)Owner).TriggerOnHttpResponseFailed(DataConnection, fContext);
                return;
            }
            catch (ObjectDisposedException)
            {
                ((AsyncHttpServer)Owner).TriggerOnHttpResponseFailed(DataConnection, fContext);
                return;
            }

            AsyncHttpContext lOldContext = fContext;

            fContext = ((AsyncHttpServer)Owner).NewContext(this);
            try
            {
                DataConnection.BeginReadLine(new AsyncCallback(HeaderFirstLineCallback), null);
            }
            catch (SocketException)
            {
                ((AsyncHttpServer)Owner).TriggerOnHttpResponseFailed(DataConnection, fContext);
                return;
            }

            catch (ObjectDisposedException)
            {
                ((AsyncHttpServer)Owner).TriggerOnHttpResponseFailed(DataConnection, fContext);
                return;
            }
            ((AsyncHttpServer)Owner).TriggerOnHttpResponseSent(DataConnection, lOldContext);

            return;
        }