Exemplo n.º 1
0
        protected virtual IAsyncResult BeginReadCore(byte[] buffer, int offset, int size, AsyncCallback cback, object state)
        {
            if (size == 0 || _closed)
            {
                HttpStreamAsyncResult ares = new HttpStreamAsyncResult(this);
                ares._callback = cback;
                ares._state    = state;
                ares.Complete();
                return(ares);
            }

            int nread = FillFromBuffer(buffer, offset, size);

            if (nread > 0 || nread == -1)
            {
                HttpStreamAsyncResult ares = new HttpStreamAsyncResult(this);
                ares._buffer    = buffer;
                ares._offset    = offset;
                ares._count     = size;
                ares._callback  = cback;
                ares._state     = state;
                ares._synchRead = Math.Max(0, nread);
                ares.Complete();
                return(ares);
            }

            // Avoid reading past the end of the request to allow
            // for HTTP pipelining
            if (_remainingBody >= 0 && size > _remainingBody)
            {
                size = (int)Math.Min(_remainingBody, (long)size);
            }

            return(_stream.BeginRead(buffer, offset, size, cback, state));
        }
        public override int EndRead(IAsyncResult ares)
        {
            if (disposed)
            {
                throw new ObjectDisposedException(GetType().ToString());
            }

            HttpStreamAsyncResult my_ares = ares as HttpStreamAsyncResult;

            if (ares == null)
            {
                throw new ArgumentException("Invalid IAsyncResult", "ares");
            }

            if (!ares.IsCompleted)
            {
                ares.AsyncWaitHandle.WaitOne();
            }

            if (my_ares.Error != null)
            {
                throw new System.Net.HttpListenerException(400, "I/O operation aborted: " + my_ares.Error.Message);
            }

            return(my_ares.Count);
        }
        void OnRead(IAsyncResult base_ares)
        {
            ReadBufferState       rb   = (ReadBufferState)base_ares.AsyncState;
            HttpStreamAsyncResult ares = rb.Ares;

            try
            {
                int nread = base.EndRead(base_ares);
                decoder.Write(ares.Buffer, ares.Offset, nread);
                nread      = decoder.Read(rb.Buffer, rb.Offset, rb.Count);
                rb.Offset += nread;
                rb.Count  -= nread;
                if (rb.Count == 0 || !decoder.WantMore || nread == 0)
                {
                    no_more_data = !decoder.WantMore && nread == 0;
                    ares.Count   = rb.InitialCount - rb.Count;
                    ares.Complete();
                    return;
                }
                ares.Offset = 0;
                ares.Count  = Math.Min(8192, decoder.ChunkLeft + 6);
                base.BeginRead(ares.Buffer, ares.Offset, ares.Count, OnRead, rb);
            }
            catch (Exception e)
            {
                context.Connection.SendError(e.Message, 400);
                ares.Complete(e);
            }
        }
Exemplo n.º 4
0
        public override int EndRead(IAsyncResult asyncResult)
        {
            if (asyncResult == null)
            {
                throw new ArgumentNullException(nameof(asyncResult));
            }

            HttpStreamAsyncResult ares = asyncResult as HttpStreamAsyncResult;

            if (ares == null || !ReferenceEquals(this, ares._parent))
            {
                throw new ArgumentException("Invalid async result");
            }
            if (ares._endCalled)
            {
                throw new InvalidOperationException("Invalid end call");
            }
            ares._endCalled = true;

            if (!asyncResult.IsCompleted)
            {
                asyncResult.AsyncWaitHandle.WaitOne();
            }

            if (ares._error != null)
            {
                throw new HttpListenerException((int)HttpStatusCode.BadRequest, "Operation aborted");
            }

            return(ares._count);
        }
Exemplo n.º 5
0
        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count,
                            AsyncCallback cback, object state)
        {
            if (disposed)
                throw new ObjectDisposedException(typeof(RequestStream).ToString());

            int nread = FillFromBuffer(buffer, offset, count);
            if (nread > 0 || nread == -1)
            {
                HttpStreamAsyncResult ares = new HttpStreamAsyncResult();
                ares.Buffer = buffer;
                ares.Offset = offset;
                ares.Count = count;
                ares.Callback = cback;
                ares.State = state;
                ares.SynchRead = Math.Max(0, nread);
                ares.Complete();
                return ares;
            }

            // Avoid reading past the end of the request to allow
            // for HTTP pipelining
            if (remaining_body >= 0 && count > remaining_body)
                count = (int)Math.Min(Int32.MaxValue, remaining_body);
            return stream.BeginRead(buffer, offset, count, cback, state);
        }
Exemplo n.º 6
0
 public ReadBufferState(byte[] buffer, int offset, int count, HttpStreamAsyncResult ares)
 {
     Buffer       = buffer;
     Offset       = offset;
     Count        = count;
     InitialCount = count;
     Ares         = ares;
 }
        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count,
                            AsyncCallback cback, object state)
        {
            if (disposed)
                throw new ObjectDisposedException(GetType().ToString());

            if (buffer == null)
                throw new ArgumentNullException("buffer");

            int len = buffer.Length;
            if (offset < 0 || offset > len)
                throw new ArgumentOutOfRangeException("offset exceeds the size of buffer");

            if (count < 0 || offset > len - count)
                throw new ArgumentOutOfRangeException("offset+size exceeds the size of buffer");

            HttpStreamAsyncResult ares = new HttpStreamAsyncResult();
            ares.Callback = cback;
            ares.State = state;
            if (no_more_data)
            {
                ares.Complete();
                return ares;
            }
            int nread = decoder.Read(buffer, offset, count);
            offset += nread;
            count -= nread;
            if (count == 0)
            {
                // got all we wanted, no need to bother the decoder yet
                ares.Count = nread;
                ares.Complete();
                return ares;
            }
            if (!decoder.WantMore)
            {
                no_more_data = nread == 0;
                ares.Count = nread;
                ares.Complete();
                return ares;
            }
            ares.Buffer = new byte[8192];
            ares.Offset = 0;
            ares.Count = 8192;
            ReadBufferState rb = new ReadBufferState(buffer, offset, count, ares);
            rb.InitialCount += nread;
            base.BeginRead(ares.Buffer, ares.Offset, ares.Count, OnRead, rb);
            return ares;
        }
Exemplo n.º 8
0
        protected override IAsyncResult BeginReadCore(byte[] buffer, int offset, int size, AsyncCallback cback, object state)
        {
            HttpStreamAsyncResult ares = new HttpStreamAsyncResult(this);

            ares._callback = cback;
            ares._state    = state;
            if (_no_more_data || size == 0 || _closed)
            {
                ares.Complete();
                return(ares);
            }
            int nread = _decoder.Read(buffer, offset, size);

            offset += nread;
            size   -= nread;
            if (size == 0)
            {
                // got all we wanted, no need to bother the decoder yet
                ares._count = nread;
                ares.Complete();
                return(ares);
            }
            if (!_decoder.WantMore)
            {
                _no_more_data = nread == 0;
                ares._count   = nread;
                ares.Complete();
                return(ares);
            }
            ares._buffer = new byte[8192];
            ares._offset = 0;
            ares._count  = 8192;
            ReadBufferState rb = new ReadBufferState(buffer, offset, size, ares);

            rb.InitialCount += nread;
            base.BeginReadCore(ares._buffer, ares._offset, ares._count, OnRead, rb);
            return(ares);
        }
Exemplo n.º 9
0
        private IAsyncResult BeginWriteCore(byte[] buffer, int offset, int size, AsyncCallback cback, object state)
        {
            if (_closed)
            {
                HttpStreamAsyncResult ares = new HttpStreamAsyncResult(this);
                ares._callback = cback;
                ares._state    = state;
                ares.Complete();
                return(ares);
            }

            byte[]       bytes   = null;
            MemoryStream ms      = GetHeaders(false);
            bool         chunked = _response.SendChunked;

            if (ms != null)
            {
                long start = ms.Position;
                ms.Position = ms.Length;
                if (chunked)
                {
                    bytes = GetChunkSizeBytes(size, false);
                    ms.Write(bytes, 0, bytes.Length);
                }
                ms.Write(buffer, offset, size);
                buffer = ms.GetBuffer();
                offset = (int)start;
                size   = (int)(ms.Position - start);
            }
            else if (chunked)
            {
                bytes = GetChunkSizeBytes(size, false);
                InternalWrite(bytes, 0, bytes.Length);
            }

            return(_stream.BeginWrite(buffer, offset, size, cback, state));
        }
        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count,
                                               AsyncCallback cback, object state)
        {
            if (disposed)
            {
                throw new ObjectDisposedException(GetType().ToString());
            }

            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }

            int len = buffer.Length;

            if (offset < 0 || offset > len)
            {
                throw new ArgumentOutOfRangeException("offset exceeds the size of buffer");
            }

            if (count < 0 || offset > len - count)
            {
                throw new ArgumentOutOfRangeException("offset+size exceeds the size of buffer");
            }

            HttpStreamAsyncResult ares = new HttpStreamAsyncResult();

            ares.Callback = cback;
            ares.State    = state;
            if (no_more_data)
            {
                ares.Complete();
                return(ares);
            }
            int nread = decoder.Read(buffer, offset, count);

            offset += nread;
            count  -= nread;
            if (count == 0)
            {
                // got all we wanted, no need to bother the decoder yet
                ares.Count = nread;
                ares.Complete();
                return(ares);
            }
            if (!decoder.WantMore)
            {
                no_more_data = nread == 0;
                ares.Count   = nread;
                ares.Complete();
                return(ares);
            }
            ares.Buffer = new byte[8192];
            ares.Offset = 0;
            ares.Count  = 8192;
            ReadBufferState rb = new ReadBufferState(buffer, offset, count, ares);

            rb.InitialCount += nread;
            base.BeginRead(ares.Buffer, ares.Offset, ares.Count, OnRead, rb);
            return(ares);
        }
 public ReadBufferState(byte[] buffer, int offset, int count,
             HttpStreamAsyncResult ares)
 {
     Buffer = buffer;
     Offset = offset;
     Count = count;
     InitialCount = count;
     Ares = ares;
 }