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);
}
