public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback cback, object state) { if (this.disposed) { throw new ObjectDisposedException(typeof(RequestStream).ToString()); } int num = this.FillFromBuffer(buffer, offset, count); if (num > 0 || num == -1) { HttpStreamAsyncResult httpStreamAsyncResult = new HttpStreamAsyncResult(); httpStreamAsyncResult.Buffer = buffer; httpStreamAsyncResult.Offset = offset; httpStreamAsyncResult.Count = count; httpStreamAsyncResult.Callback = cback; httpStreamAsyncResult.State = state; httpStreamAsyncResult.SynchRead = num; httpStreamAsyncResult.Complete(); return(httpStreamAsyncResult); } if (this.remaining_body >= 0L && (long)count > this.remaining_body) { count = (int)Math.Min(2147483647L, this.remaining_body); } return(this.stream.BeginRead(buffer, offset, count, cback, state)); }
private void OnRead(IAsyncResult base_ares) { ChunkedInputStream.ReadBufferState readBufferState = (ChunkedInputStream.ReadBufferState)base_ares.AsyncState; HttpStreamAsyncResult ares = readBufferState.Ares; try { int num = base.EndRead(base_ares); this.decoder.Write(ares.Buffer, ares.Offset, num); num = this.decoder.Read(readBufferState.Buffer, readBufferState.Offset, readBufferState.Count); readBufferState.Offset += num; readBufferState.Count -= num; if (readBufferState.Count == 0 || !this.decoder.WantMore || num == 0) { this.no_more_data = (!this.decoder.WantMore && num == 0); ares.Count = readBufferState.InitialCount - readBufferState.Count; ares.Complete(); } else { ares.Offset = 0; ares.Count = Math.Min(8192, this.decoder.ChunkLeft + 6); base.BeginRead(ares.Buffer, ares.Offset, ares.Count, new AsyncCallback(this.OnRead), readBufferState); } } catch (Exception ex) { this.context.Connection.SendError(ex.Message, 400); ares.Complete(ex); } }
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 = 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)); }
public override int EndRead(IAsyncResult ares) { if (disposed) { throw new ObjectDisposedException(typeof(RequestStream).ToString()); } if (ares == null) { throw new ArgumentNullException("async_result"); } if (ares is HttpStreamAsyncResult) { HttpStreamAsyncResult httpStreamAsyncResult = (HttpStreamAsyncResult)ares; if (!ares.IsCompleted) { ares.AsyncWaitHandle.WaitOne(); } return(httpStreamAsyncResult.SynchRead); } int num = stream.EndRead(ares); if (remaining_body > 0 && num > 0) { remaining_body -= num; } return(num); }
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); } }
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 HttpListenerException(400, "I/O operation aborted: " + my_ares.Error.Message); } return(my_ares.Count); }
public IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback cback, object state) { if (_disposed) { throw new ObjectDisposedException(typeof(RequestStream).ToString()); } var nread = FillFromBuffer(buffer, offset, count); if (nread > 0 || nread == -1) { var ares = new HttpStreamAsyncResult { Buffer = buffer, Offset = offset, Count = count, Callback = cback, State = state, 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 && count > _remainingBody) { count = (int)Math.Min(int.MaxValue, _remainingBody); } return(_stream.BeginRead(buffer, offset, count, cback, state)); }
protected virtual IAsyncResult BeginReadCore(byte[] buffer, int offset, int size, AsyncCallback cback, object state) { if (size == 0 || _closed) { HttpStreamAsyncResult ares = new HttpStreamAsyncResult(); 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(); 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(int.MaxValue, _remainingBody); } return(_stream.BeginRead(buffer, offset, size, cback, state)); }
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(SR.net_io_invalidasyncresult, nameof(asyncResult)); } if (ares._endCalled) { throw new InvalidOperationException(SR.Format(SR.net_io_invalidendcall, nameof(EndRead))); } ares._endCalled = true; if (!asyncResult.IsCompleted) { asyncResult.AsyncWaitHandle.WaitOne(); } if (ares._error != null) { throw new HttpListenerException((int)HttpStatusCode.BadRequest, SR.Format(SR.net_io_operation_aborted, ares._error.Message)); } return(ares._count); }
private void OnRead(IAsyncResult base_ares) { ReadBufferState readBufferState = (ReadBufferState)base_ares.AsyncState; HttpStreamAsyncResult ares = readBufferState.Ares; try { int size = base.EndRead(base_ares); decoder.Write(ares.Buffer, ares.Offset, size); size = decoder.Read(readBufferState.Buffer, readBufferState.Offset, readBufferState.Count); readBufferState.Offset += size; readBufferState.Count -= size; if (readBufferState.Count == 0 || !decoder.WantMore || size == 0) { no_more_data = (!decoder.WantMore && size == 0); ares.Count = readBufferState.InitialCount - readBufferState.Count; ares.Complete(); } else { ares.Offset = 0; ares.Count = Math.Min(8192, decoder.ChunkLeft + 6); base.BeginRead(ares.Buffer, ares.Offset, ares.Count, (AsyncCallback)OnRead, (object)readBufferState); } } catch (Exception ex) { context.Connection.SendError(ex.Message, 400); ares.Complete(ex); } }
public override int EndRead(IAsyncResult asyncResult) { if (_disposed) { throw new ObjectDisposedException(typeof(HttpRequestStream).ToString()); } if (asyncResult == null) { throw new ArgumentNullException(nameof(asyncResult)); } if (asyncResult is HttpStreamAsyncResult) { HttpStreamAsyncResult r = (HttpStreamAsyncResult)asyncResult; if (!asyncResult.IsCompleted) { asyncResult.AsyncWaitHandle.WaitOne(); } return(r._synchRead); } int nread = _stream.EndRead(asyncResult); if (_remainingBody > 0 && nread > 0) { _remainingBody -= nread; } return(nread); }
public ReadBufferState(byte[] buffer, int offset, int count, HttpStreamAsyncResult ares) { this.Buffer = buffer; this.Offset = offset; this.Count = count; this.InitialCount = count; this.Ares = ares; }
public ReadBufferState(byte[] buffer, int offset, int count, HttpStreamAsyncResult ares) { Buffer = buffer; Offset = offset; Count = count; InitialCount = count; Ares = ares; }
public ReadBufferState (byte [] buffer, int offset, int count, HttpStreamAsyncResult ares) { Buffer = buffer; Offset = offset; Count = count; InitialCount = count; Ares = ares; }
private IAsyncResult BeginWriteCore(byte[] buffer, int offset, int size, AsyncCallback cback, object state) { if (_closed) { HttpStreamAsyncResult ares = new HttpStreamAsyncResult(); 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); } try { return(_stream.BeginWrite(buffer, offset, size, cback, state)); } catch (IOException ex) { if (_ignore_errors) { HttpStreamAsyncResult ares = new HttpStreamAsyncResult(); ares._callback = cback; ares._state = state; ares.Complete(); return(ares); } else { throw new HttpListenerException(ex.HResult, ex.Message); } } }
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 num = buffer.Length; if (offset < 0 || offset > num) { throw new ArgumentOutOfRangeException("offset exceeds the size of buffer"); } if (count < 0 || offset > num - count) { throw new ArgumentOutOfRangeException("offset+size exceeds the size of buffer"); } HttpStreamAsyncResult httpStreamAsyncResult = new HttpStreamAsyncResult(); httpStreamAsyncResult.Callback = cback; httpStreamAsyncResult.State = state; if (no_more_data) { httpStreamAsyncResult.Complete(); return(httpStreamAsyncResult); } int num2 = decoder.Read(buffer, offset, count); offset += num2; count -= num2; if (count == 0) { httpStreamAsyncResult.Count = num2; httpStreamAsyncResult.Complete(); return(httpStreamAsyncResult); } if (!decoder.WantMore) { no_more_data = (num2 == 0); httpStreamAsyncResult.Count = num2; httpStreamAsyncResult.Complete(); return(httpStreamAsyncResult); } httpStreamAsyncResult.Buffer = new byte[8192]; httpStreamAsyncResult.Offset = 0; httpStreamAsyncResult.Count = 8192; ReadBufferState readBufferState = new ReadBufferState(buffer, offset, count, httpStreamAsyncResult); readBufferState.InitialCount += num2; base.BeginRead(httpStreamAsyncResult.Buffer, httpStreamAsyncResult.Offset, httpStreamAsyncResult.Count, (AsyncCallback)OnRead, (object)readBufferState); return(httpStreamAsyncResult); }
public override IAsyncResult BeginRead(byte[] buffer, int offset, int size, AsyncCallback cback, object state) { if (_disposed) { throw new ObjectDisposedException(typeof(HttpRequestStream).ToString()); } if (buffer == null) { throw new ArgumentNullException(nameof(buffer)); } if (offset < 0 || offset > buffer.Length) { throw new ArgumentOutOfRangeException(nameof(offset)); } if (size < 0 || size > buffer.Length - offset) { throw new ArgumentOutOfRangeException(nameof(size)); } int nread = FillFromBuffer(buffer, offset, size); if (nread > 0 || nread == -1) { HttpStreamAsyncResult ares = new HttpStreamAsyncResult(); 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(int.MaxValue, _remainingBody); } return(_stream.BeginRead(buffer, offset, size, cback, state)); }
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); }
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 new 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(nameof(buffer)); } var 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"); } var ares = new HttpStreamAsyncResult { Callback = cback, State = state }; if (_noMoreData) { ares.Complete(); return(ares); } var 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) { _noMoreData = nread == 0; ares.Count = nread; ares.Complete(); return(ares); } ares.Buffer = new byte[8192]; ares.Offset = 0; ares.Count = 8192; var rb = new ReadBufferState(buffer, offset, count, ares); rb.InitialCount += nread; base.BeginRead(ares.Buffer, ares.Offset, ares.Count, OnRead, rb); return(ares); }
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); }