public async Task AbortCausesReadToCancel()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(null);
stream.Abort();
await Assert.ThrowsAsync <TaskCanceledException>(() => stream.ReadAsync(new byte[1], 0, 1));
}
public Streams(IHttpBodyControlFeature bodyControl, HttpResponsePipeWriter writer)
{
_request = new HttpRequestStream(bodyControl);
_emptyRequest = new HttpRequestStream(bodyControl);
_response = new HttpResponseStream(bodyControl, writer);
_upgradeableResponse = new WrappingStream(_response);
_upgradeStream = new HttpUpgradeStream(_request, _response);
}
public void StopAcceptingReadsCausesReadToThrowObjectDisposedException()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(null);
stream.StopAcceptingReads();
Assert.Throws <ObjectDisposedException>(() => { stream.ReadAsync(new byte[1], 0, 1); });
}
public Streams(IISHttpContext context)
{
_context = context;
_request = new HttpRequestStream(_context);
_response = new HttpResponseStream(_context, _context);
_upgradeableResponse = new WrappingStream(_response);
_upgradeableRequest = new WrappingStream(_request);
}
public Streams(bool AllowSynchronousIO, IHttpResponseControl httpResponseControl)
{
_request = new HttpRequestStream(AllowSynchronousIO);
_emptyRequest = new HttpRequestStream(AllowSynchronousIO);
_response = new HttpResponseStream(AllowSynchronousIO, httpResponseControl);
_upgradeableResponse = new WrappingStream(_response);
_upgradeStream = new HttpUpgradeStream(_request, _response);
}
public void AbortCausesCopyToAsyncToCancel()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(null);
stream.Abort();
var task = stream.CopyToAsync(Mock.Of <Stream>());
Assert.True(task.IsCanceled);
}
public async Task AbortWithErrorCausesCopyToAsyncToCancel()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(null);
var error = new Exception();
stream.Abort(error);
var exception = await Assert.ThrowsAsync <Exception>(() => stream.CopyToAsync(Mock.Of <Stream>()));
Assert.Same(error, exception);
}
public BodyControl(IHttpBodyControlFeature bodyControl, IHttpResponseControl responseControl)
{
_requestReader = new HttpRequestPipeReader();
_request = new HttpRequestStream(bodyControl, _requestReader);
_emptyRequestReader = new HttpRequestPipeReader();
_emptyRequest = new HttpRequestStream(bodyControl, _emptyRequestReader);
_responseWriter = new HttpResponsePipeWriter(responseControl);
_response = new HttpResponseStream(bodyControl, _responseWriter);
_upgradeableResponse = new WrappingStream(_response);
_upgradeStream = new HttpUpgradeStream(_request, _response);
}
internal async Task <MutableHttpServerRequest> ParseRequestStream(IInputStream requestStream)
{
var httpStream = new HttpRequestStream(requestStream);
var request = new MutableHttpServerRequest();
try
{
var stream = await httpStream.ReadAsync(BUFFER_SIZE, InputStreamOptions.Partial);
byte[] streamData = stream.Data;
var requestPipeline = GetPipeline();
using (var pipeLineEnumerator = requestPipeline.GetEnumerator())
{
pipeLineEnumerator.MoveNext();
bool requestComplete = false;
while (!requestComplete)
{
pipeLineEnumerator.Current.HandleRequestPart(streamData, request);
streamData = pipeLineEnumerator.Current.UnparsedData;
if (pipeLineEnumerator.Current.IsFinished)
{
if (!pipeLineEnumerator.Current.IsSucceeded ||
!pipeLineEnumerator.MoveNext())
{
break;
}
}
else
{
var newStreamdata = await httpStream.ReadAsync(BUFFER_SIZE, InputStreamOptions.Partial);
if (!newStreamdata.ReadSuccessful)
{
break;
}
streamData = streamData.ConcatArray(newStreamdata.Data);
}
}
}
request.IsComplete = requestPipeline.All(p => p.IsSucceeded);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(request);
}
internal async Task<HttpRequest> ParseRequestStream(IInputStream requestStream)
{
var httpStream = new HttpRequestStream(requestStream);
var request = new HttpRequest();
try
{
var stream = await httpStream.ReadAsync(BUFFER_SIZE, InputStreamOptions.Partial);
byte[] streamData = stream.Data;
var requestPipeline = GetPipeline();
using (var pipeLineEnumerator = requestPipeline.GetEnumerator())
{
pipeLineEnumerator.MoveNext();
bool requestComplete = false;
while (!requestComplete)
{
pipeLineEnumerator.Current.HandleRequestPart(streamData, request);
streamData = pipeLineEnumerator.Current.UnparsedData;
if (pipeLineEnumerator.Current.IsFinished)
{
if (!pipeLineEnumerator.Current.IsSucceeded ||
!pipeLineEnumerator.MoveNext())
{
break;
}
}
else
{
var newStreamdata = await httpStream.ReadAsync(BUFFER_SIZE, InputStreamOptions.Partial);
if (!newStreamdata.ReadSuccessful)
{
break;
}
streamData = streamData.ConcatArray(newStreamdata.Data);
}
}
}
request.IsComplete = requestPipeline.All(p => p.IsSucceeded);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return request;
}
public void AbortWithErrorCausesCopyToAsyncToCancel()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(null);
var error = new Exception();
stream.Abort(error);
var task = stream.CopyToAsync(Mock.Of <Stream>());
Assert.True(task.IsFaulted);
Assert.Same(error, task.Exception.InnerException);
}
public async Task ReadAsyncFromNoContentLengthReturnsZero(HttpVersion httpVersion)
{
using (var input = new TestInput())
{
var body = Http1MessageBody.For(httpVersion, new HttpRequestHeaders(), input.Http1Connection);
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(body);
input.Add("Hello");
var buffer = new byte[1024];
Assert.Equal(0, await stream.ReadAsync(buffer, 0, buffer.Length));
await body.StopAsync();
}
}
public async Task ReadFromNoContentLengthReturnsZero(HttpVersion httpVersion)
{
using (var input = new TestInput())
{
var body = Http1MessageBody.For(httpVersion, new HttpRequestHeaders(), input.Http1Connection);
var mockBodyControl = new Mock <IHttpBodyControlFeature>();
mockBodyControl.Setup(m => m.AllowSynchronousIO).Returns(true);
var stream = new HttpRequestStream(mockBodyControl.Object);
stream.StartAcceptingReads(body);
input.Add("Hello");
var buffer = new byte[1024];
Assert.Equal(0, stream.Read(buffer, 0, buffer.Length));
await body.StopAsync();
}
}
public WebSocketHttpListenerDuplexStream(HttpRequestStream inputStream,
HttpResponseStream outputStream,
HttpListenerContext context)
{
Debug.Assert(inputStream != null, "'inputStream' MUST NOT be NULL.");
Debug.Assert(outputStream != null, "'outputStream' MUST NOT be NULL.");
Debug.Assert(context != null, "'context' MUST NOT be NULL.");
Debug.Assert(inputStream.CanRead, "'inputStream' MUST support read operations.");
Debug.Assert(outputStream.CanWrite, "'outputStream' MUST support write operations.");
_inputStream = inputStream;
_outputStream = outputStream;
_context = context;
if (NetEventSource.IsEnabled)
{
NetEventSource.Associate(inputStream, this);
NetEventSource.Associate(outputStream, this);
}
}
public WebSocketHttpListenerDuplexStream(HttpRequestStream inputStream,
HttpResponseStream outputStream,
HttpListenerContext context)
{
Debug.Assert(inputStream != null, "'inputStream' MUST NOT be NULL.");
Debug.Assert(outputStream != null, "'outputStream' MUST NOT be NULL.");
Debug.Assert(context != null, "'context' MUST NOT be NULL.");
Debug.Assert(inputStream.CanRead, "'inputStream' MUST support read operations.");
Debug.Assert(outputStream.CanWrite, "'outputStream' MUST support write operations.");
_inputStream = inputStream;
_outputStream = outputStream;
_context = context;
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Associate(inputStream, this);
NetEventSource.Associate(outputStream, this);
}
}
public WebSocketHttpListenerDuplexStream(HttpRequestStream inputStream,
HttpResponseStream outputStream,
HttpListenerContext context)
{
Contract.Assert(inputStream != null, "'inputStream' MUST NOT be NULL.");
Contract.Assert(outputStream != null, "'outputStream' MUST NOT be NULL.");
Contract.Assert(context != null, "'context' MUST NOT be NULL.");
Contract.Assert(inputStream.CanRead, "'inputStream' MUST support read operations.");
Contract.Assert(outputStream.CanWrite, "'outputStream' MUST support write operations.");
m_InputStream = inputStream;
m_OutputStream = outputStream;
m_Context = context;
if (WebSocketBase.LoggingEnabled)
{
Logging.Associate(Logging.WebSockets, inputStream, this);
Logging.Associate(Logging.WebSockets, outputStream, this);
}
}
public async Task ConnectionUpgradeKeepAlive(string headerConnection)
{
using (var input = new TestInput())
{
var body = Http1MessageBody.For(HttpVersion.Http11, new HttpRequestHeaders {
HeaderConnection = headerConnection
}, input.Http1Connection);
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(body);
input.Add("Hello");
var buffer = new byte[1024];
Assert.Equal(5, await stream.ReadAsync(buffer, 0, buffer.Length));
AssertASCII("Hello", new ArraySegment <byte>(buffer, 0, 5));
input.Fin();
await body.StopAsync();
}
}
public async Task ReadThrowsGivenChunkPrefixGreaterThan8Bytes()
{
using (var input = new TestInput())
{
var body = Http1MessageBody.For(HttpVersion.Http11, new HttpRequestHeaders {
HeaderTransferEncoding = "chunked"
}, input.Http1Connection);
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(body);
input.Add("012345678\r");
var buffer = new byte[1024];
var ex = await Assert.ThrowsAsync <BadHttpRequestException>(async() =>
await stream.ReadAsync(buffer, 0, buffer.Length));
Assert.Equal(CoreStrings.BadRequest_BadChunkSizeData, ex.Message);
await body.StopAsync();
}
}
public async Task PumpAsyncDoesNotReturnAfterCancelingInput()
{
using (var input = new TestInput())
{
var body = Http1MessageBody.For(HttpVersion.Http11, new HttpRequestHeaders {
HeaderContentLength = "2"
}, input.Http1Connection);
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(body);
// Add some input and consume it to ensure PumpAsync is running
input.Add("a");
Assert.Equal(1, await stream.ReadAsync(new byte[1], 0, 1));
input.Transport.Input.CancelPendingRead();
// Add more input and verify is read
input.Add("b");
Assert.Equal(1, await stream.ReadAsync(new byte[1], 0, 1));
await body.StopAsync();
}
}
public async Task StopAsyncPreventsFurtherDataConsumption()
{
using (var input = new TestInput())
{
var body = Http1MessageBody.For(HttpVersion.Http11, new HttpRequestHeaders {
HeaderContentLength = "2"
}, input.Http1Connection);
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(body);
// Add some input and consume it to ensure PumpAsync is running
input.Add("a");
Assert.Equal(1, await stream.ReadAsync(new byte[1], 0, 1));
await body.StopAsync();
// Add some more data. Checking for cancelation and exiting the loop
// should take priority over reading this data.
input.Add("b");
// There shouldn't be any additional data available
Assert.Equal(0, await stream.ReadAsync(new byte[1], 0, 1));
}
}
public async Task CanReadAsyncFromRemainingData(HttpVersion httpVersion)
{
using (var input = new TestInput())
{
var body = Http1MessageBody.For(httpVersion, new HttpRequestHeaders {
HeaderConnection = "upgrade"
}, input.Http1Connection);
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
stream.StartAcceptingReads(body);
input.Add("Hello");
var buffer = new byte[1024];
var count = await stream.ReadAsync(buffer, 0, buffer.Length);
Assert.Equal(5, count);
AssertASCII("Hello", new ArraySegment <byte>(buffer, 0, count));
input.Fin();
await body.StopAsync();
}
}
public void SetLengthThrows()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>(), new HttpRequestPipeReader());
Assert.Throws <NotSupportedException>(() => stream.SetLength(0));
}
public void WriteThrows()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>(), new HttpRequestPipeReader());
Assert.Throws <NotSupportedException>(() => stream.Write(new byte[1], 0, 1));
}
public void BeginWriteThrows()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
Assert.Throws <NotSupportedException>(() => stream.BeginWrite(new byte[1], 0, 1, null, null));
}
public async Task WriteAsyncThrows()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
await Assert.ThrowsAsync <NotSupportedException>(() => stream.WriteAsync(new byte[1], 0, 1));
}
public void WriteByteThrows()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
Assert.Throws <NotSupportedException>(() => stream.WriteByte(0));
}
// Read-only streams should support Flush according to https://github.com/dotnet/corefx/pull/27327#pullrequestreview-98384813
public void FlushDoesNotThrow()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>(), new HttpRequestPipeReader());
stream.Flush();
}
public void CanWriteReturnsFalse()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
Assert.False(stream.CanWrite);
}
public async Task FlushAsyncThrows()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
await Assert.ThrowsAsync <NotSupportedException>(() => stream.FlushAsync());
}
private static async Task <HttpListenerWebSocketContext> AcceptWebSocketAsyncCore(HttpListenerContext context,
string subProtocol,
int receiveBufferSize,
TimeSpan keepAliveInterval,
ArraySegment <byte> internalBuffer)
{
HttpListenerWebSocketContext webSocketContext = null;
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(null, context);
}
try
{
// get property will create a new response if one doesn't exist.
HttpListenerResponse response = context.Response;
HttpListenerRequest request = context.Request;
ValidateWebSocketHeaders(context);
string secWebSocketVersion = request.Headers[HttpKnownHeaderNames.SecWebSocketVersion];
// Optional for non-browser client
string origin = request.Headers[HttpKnownHeaderNames.Origin];
List <string> secWebSocketProtocols = new List <string>();
string outgoingSecWebSocketProtocolString;
bool shouldSendSecWebSocketProtocolHeader =
ProcessWebSocketProtocolHeader(
request.Headers[HttpKnownHeaderNames.SecWebSocketProtocol],
subProtocol,
out outgoingSecWebSocketProtocolString);
if (shouldSendSecWebSocketProtocolHeader)
{
secWebSocketProtocols.Add(outgoingSecWebSocketProtocolString);
response.Headers.Add(HttpKnownHeaderNames.SecWebSocketProtocol,
outgoingSecWebSocketProtocolString);
}
// negotiate the websocket key return value
string secWebSocketKey = request.Headers[HttpKnownHeaderNames.SecWebSocketKey];
string secWebSocketAccept = HttpWebSocket.GetSecWebSocketAcceptString(secWebSocketKey);
response.Headers.Add(HttpKnownHeaderNames.Connection, HttpKnownHeaderNames.Upgrade);
response.Headers.Add(HttpKnownHeaderNames.Upgrade, WebSocketUpgradeToken);
response.Headers.Add(HttpKnownHeaderNames.SecWebSocketAccept, secWebSocketAccept);
response.StatusCode = (int)HttpStatusCode.SwitchingProtocols; // HTTP 101
response.ComputeCoreHeaders();
ulong hresult = SendWebSocketHeaders(response);
if (hresult != 0)
{
throw new WebSocketException((int)hresult,
SR.Format(SR.net_WebSockets_NativeSendResponseHeaders,
nameof(AcceptWebSocketAsync),
hresult));
}
if (NetEventSource.IsEnabled)
{
NetEventSource.Info(null, $"{HttpKnownHeaderNames.Origin} = {origin}");
NetEventSource.Info(null, $"{HttpKnownHeaderNames.SecWebSocketVersion} = {secWebSocketVersion}");
NetEventSource.Info(null, $"{HttpKnownHeaderNames.SecWebSocketKey} = {secWebSocketKey}");
NetEventSource.Info(null, $"{HttpKnownHeaderNames.SecWebSocketAccept} = {secWebSocketAccept}");
NetEventSource.Info(null, $"{HttpKnownHeaderNames.SecWebSocketProtocol} = {request.Headers[HttpKnownHeaderNames.SecWebSocketProtocol]}");
NetEventSource.Info(null, $"{HttpKnownHeaderNames.SecWebSocketProtocol} = {outgoingSecWebSocketProtocolString}");
}
await response.OutputStream.FlushAsync().SuppressContextFlow();
HttpResponseStream responseStream = response.OutputStream as HttpResponseStream;
Debug.Assert(responseStream != null, "'responseStream' MUST be castable to System.Net.HttpResponseStream.");
((HttpResponseStream)response.OutputStream).SwitchToOpaqueMode();
HttpRequestStream requestStream = new HttpRequestStream(context);
requestStream.SwitchToOpaqueMode();
WebSocketHttpListenerDuplexStream webSocketStream =
new WebSocketHttpListenerDuplexStream(requestStream, responseStream, context);
WebSocket webSocket = ServerWebSocket.Create(webSocketStream,
subProtocol,
receiveBufferSize,
keepAliveInterval,
internalBuffer);
webSocketContext = new HttpListenerWebSocketContext(
request.Url,
request.Headers,
request.Cookies,
context.User,
request.IsAuthenticated,
request.IsLocal,
request.IsSecureConnection,
origin,
secWebSocketProtocols.AsReadOnly(),
secWebSocketVersion,
secWebSocketKey,
webSocket);
if (NetEventSource.IsEnabled)
{
NetEventSource.Associate(context, webSocketContext);
NetEventSource.Associate(webSocketContext, webSocket);
}
}
catch (Exception ex)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Error(context, ex);
}
throw;
}
finally
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(context);
}
}
return(webSocketContext);
}
public void SeekThrows()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
Assert.Throws <NotSupportedException>(() => stream.Seek(0, SeekOrigin.Begin));
}
public void CanReadReturnsTrue()
{
var stream = new HttpRequestStream(Mock.Of <IHttpBodyControlFeature>());
Assert.True(stream.CanRead);
}
