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