port dotnet/corefx#11348 (#114)

analogrelay · web-flow · commit b996ee39a429 · 2016-09-02T14:02:06.000-07:00
also adds some tests and extra features to the EchoApp test sample
diff --git a/samples/EchoApp/Startup.cs b/samples/EchoApp/Startup.cs
@@ -24,7 +24,7 @@ public void ConfigureServices(IServiceCollection services)
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
         public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
         {
-            loggerFactory.AddConsole();
+            loggerFactory.AddConsole(LogLevel.Debug);
 
             if (env.IsDevelopment())
             {
@@ -38,7 +38,7 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerF
                 if (context.WebSockets.IsWebSocketRequest)
                 {
                     var webSocket = await context.WebSockets.AcceptWebSocketAsync();
-                    await Echo(webSocket);
+                    await Echo(context, webSocket, loggerFactory.CreateLogger("Echo"));
                 }
                 else
                 {
@@ -49,27 +49,57 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerF
             app.UseFileServer();
         }
 
-        private async Task Echo(WebSocket webSocket)
+        private async Task Echo(HttpContext context, WebSocket webSocket, ILogger logger)
         {
             var buffer = new byte[1024 * 4];
             var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
+            LogFrame(logger, result, buffer);
             while (!result.CloseStatus.HasValue)
             {
                 // If the client send "ServerClose", then they want a server-originated close to occur
-                if(result.MessageType == WebSocketMessageType.Text)
+                string content = "<<binary>>";
+                if (result.MessageType == WebSocketMessageType.Text)
                 {
-                    var str = Encoding.UTF8.GetString(buffer, 0, result.Count);
-                    if(str.Equals("ServerClose"))
+                    content = Encoding.UTF8.GetString(buffer, 0, result.Count);
+                    if (content.Equals("ServerClose"))
                     {
                         await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing from Server", CancellationToken.None);
+                        logger.LogDebug($"Sent Frame Close: {WebSocketCloseStatus.NormalClosure} Closing from Server");
                         return;
                     }
+                    else if (content.Equals("ServerAbort"))
+                    {
+                        context.Abort();
+                    }
                 }
 
                 await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None);
+                logger.LogDebug($"Sent Frame {result.MessageType}: Len={result.Count}, Fin={result.EndOfMessage}: {content}");
+
                 result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
+                LogFrame(logger, result, buffer);
             }
             await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
         }
+
+        private void LogFrame(ILogger logger, WebSocketReceiveResult frame, byte[] buffer)
+        {
+            var close = frame.CloseStatus != null;
+            string message;
+            if (close)
+            {
+                message = $"Close: {frame.CloseStatus.Value} {frame.CloseStatusDescription}";
+            }
+            else
+            {
+                string content = "<<binary>>";
+                if (frame.MessageType == WebSocketMessageType.Text)
+                {
+                    content = Encoding.UTF8.GetString(buffer, 0, frame.Count);
+                }
+                message = $"{frame.MessageType}: Len={frame.Count}, Fin={frame.EndOfMessage}: {content}";
+            }
+            logger.LogDebug("Received Frame " + message);
+        }
     }
 }
diff --git a/samples/EchoApp/wwwroot/index.html b/samples/EchoApp/wwwroot/index.html
@@ -25,7 +25,7 @@ <h1>WebSocket Test Page</h1>
         <button id="closeButton" disabled>Close Socket</button>
     </div>
 
-    <p>Note: When connected to the default server (i.e. the server in the address bar ;)), the message "ServerClose" will cause the server to close the connection</p>
+    <p>Note: When connected to the default server (i.e. the server in the address bar ;)), the message "ServerClose" will cause the server to close the connection. Similarly, the message "ServerAbort" will cause the server to forcibly terminate the connection without a closing handshake</p>
 
     <h2>Communication Log</h2>
     <table style="width: 800px">
diff --git a/src/Microsoft.AspNetCore.WebSockets/Internal/fx/src/System.Net.WebSockets.Client/src/System/Net/WebSockets/ManagedWebSocket.cs b/src/Microsoft.AspNetCore.WebSockets/Internal/fx/src/System.Net.WebSockets.Client/src/System/Net/WebSockets/ManagedWebSocket.cs
@@ -615,12 +615,7 @@ private async Task<WebSocketReceiveResult> ReceiveAsyncPrivate(ArraySegment<byte
                             // Make sure we have the first two bytes, which includes the start of the payload length.
                             if (_receiveBufferCount < 2)
                             {
-                                await EnsureBufferContainsAsync(2, cancellationToken, throwOnPrematureClosure: false).ConfigureAwait(false);
-                                if (_receiveBufferCount < 2)
-                                {
-                                    // The connection closed; nothing more to read.
-                                    return new WebSocketReceiveResult(0, WebSocketMessageType.Text, true);
-                                }
+                                await EnsureBufferContainsAsync(2, cancellationToken, throwOnPrematureClosure: true).ConfigureAwait(false);
                             }
 
                             // Then make sure we have the full header based on the payload length.
diff --git a/test/Microsoft.AspNetCore.WebSockets.Test/BufferStream.cs b/test/Microsoft.AspNetCore.WebSockets.Test/BufferStream.cs
@@ -16,6 +16,7 @@ public class BufferStream : Stream
     {
         private bool _disposed;
         private bool _aborted;
+        private bool _terminated;
         private Exception _abortException;
         private ConcurrentQueue<byte[]> _bufferedData;
         private ArraySegment<byte> _topBuffer;
@@ -71,6 +72,14 @@ public override void SetLength(long value)
 
         #endregion NotSupported
 
+        /// <summary>
+        /// Ends the stream, meaning all future reads will return '0'.
+        /// </summary>
+        public void End()
+        {
+            _terminated = true;
+        }
+
         public override void Flush()
         {
             CheckDisposed();
@@ -95,6 +104,11 @@ public override Task FlushAsync(CancellationToken cancellationToken)
 
         public override int Read(byte[] buffer, int offset, int count)
         {
+            if(_terminated)
+            {
+                return 0;
+            }
+
             VerifyBuffer(buffer, offset, count, allowEmpty: false);
             _readLock.Wait();
             try
@@ -154,6 +168,11 @@ public override int EndRead(IAsyncResult asyncResult)
 
         public async override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
+            if(_terminated)
+            {
+                return 0;
+            }
+
             VerifyBuffer(buffer, offset, count, allowEmpty: false);
             CancellationTokenRegistration registration = cancellationToken.Register(Abort);
             await _readLock.WaitAsync(cancellationToken);
diff --git a/test/Microsoft.AspNetCore.WebSockets.Test/DuplexStream.cs b/test/Microsoft.AspNetCore.WebSockets.Test/DuplexStream.cs
@@ -10,30 +10,31 @@ namespace Microsoft.AspNetCore.WebSockets.Test
     // A duplex wrapper around a read and write stream.
     public class DuplexStream : Stream
     {
-        private readonly Stream _readStream;
-        private readonly Stream _writeStream;
+        public BufferStream ReadStream { get; }
+        public BufferStream WriteStream { get; }
 
         public DuplexStream()
             : this (new BufferStream(), new BufferStream())
         {
         }
 
-        public DuplexStream(Stream readStream, Stream writeStream)
+        public DuplexStream(BufferStream readStream, BufferStream writeStream)
         {
-            _readStream = readStream;
-            _writeStream = writeStream;
+            ReadStream = readStream;
+            WriteStream = writeStream;
         }
 
         public DuplexStream CreateReverseDuplexStream()
         {
-            return new DuplexStream(_writeStream, _readStream);
+            return new DuplexStream(WriteStream, ReadStream);
         }
 
+
 #region Properties
 
         public override bool CanRead
         {
-            get { return _readStream.CanRead; }
+            get { return ReadStream.CanRead; }
         }
 
         public override bool CanSeek
@@ -43,12 +44,12 @@ public override bool CanSeek
 
         public override bool CanTimeout
         {
-            get { return _readStream.CanTimeout || _writeStream.CanTimeout; }
+            get { return ReadStream.CanTimeout || WriteStream.CanTimeout; }
         }
 
         public override bool CanWrite
         {
-            get { return _writeStream.CanWrite; }
+            get { return WriteStream.CanWrite; }
         }
 
         public override long Length
@@ -64,14 +65,14 @@ public override long Position
 
         public override int ReadTimeout
         {
-            get { return _readStream.ReadTimeout; }
-            set { _readStream.ReadTimeout = value; }
+            get { return ReadStream.ReadTimeout; }
+            set { ReadStream.ReadTimeout = value; }
         }
 
         public override int WriteTimeout
         {
-            get { return _writeStream.WriteTimeout; }
-            set { _writeStream.WriteTimeout = value; }
+            get { return WriteStream.WriteTimeout; }
+            set { WriteStream.WriteTimeout = value; }
         }
 
 #endregion Properties
@@ -90,33 +91,33 @@ public override void SetLength(long value)
 
         public override int Read(byte[] buffer, int offset, int count)
         {
-            return _readStream.Read(buffer, offset, count);
+            return ReadStream.Read(buffer, offset, count);
         }
 
 #if !NETCOREAPP1_0
         public override int ReadByte()
         {
-            return _readStream.ReadByte();
+            return ReadStream.ReadByte();
         }
 
         public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
         {
-            return _readStream.BeginRead(buffer, offset, count, callback, state);
+            return ReadStream.BeginRead(buffer, offset, count, callback, state);
         }
 
         public override int EndRead(IAsyncResult asyncResult)
         {
-            return _readStream.EndRead(asyncResult);
+            return ReadStream.EndRead(asyncResult);
         }
 
         public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
-            return _readStream.ReadAsync(buffer, offset, count, cancellationToken);
+            return ReadStream.ReadAsync(buffer, offset, count, cancellationToken);
         }
 
         public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
         {
-            return _readStream.CopyToAsync(destination, bufferSize, cancellationToken);
+            return ReadStream.CopyToAsync(destination, bufferSize, cancellationToken);
         }
 #endif
 
@@ -126,39 +127,39 @@ public override Task CopyToAsync(Stream destination, int bufferSize, Cancellatio
 
         public override void Write(byte[] buffer, int offset, int count)
         {
-            _writeStream.Write(buffer, offset, count);
+            WriteStream.Write(buffer, offset, count);
         }
 
 #if !NETCOREAPP1_0
         public override void WriteByte(byte value)
         {
-            _writeStream.WriteByte(value);
+            WriteStream.WriteByte(value);
         }
 
         public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
         {
-            return _writeStream.BeginWrite(buffer, offset, count, callback, state);
+            return WriteStream.BeginWrite(buffer, offset, count, callback, state);
         }
 
         public override void EndWrite(IAsyncResult asyncResult)
         {
-            _writeStream.EndWrite(asyncResult);
+            WriteStream.EndWrite(asyncResult);
         }
 
         public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
-            return _writeStream.WriteAsync(buffer, offset, count, cancellationToken);
+            return WriteStream.WriteAsync(buffer, offset, count, cancellationToken);
         }
 
         public override Task FlushAsync(CancellationToken cancellationToken)
         {
-            return _writeStream.FlushAsync(cancellationToken);
+            return WriteStream.FlushAsync(cancellationToken);
         }
 #endif
 
         public override void Flush()
         {
-            _writeStream.Flush();
+            WriteStream.Flush();
         }
 
 #endregion Write
@@ -167,8 +168,8 @@ protected override void Dispose(bool disposing)
         {
             if (disposing)
             {
-                _readStream.Dispose();
-                _writeStream.Dispose();
+                ReadStream.Dispose();
+                WriteStream.Dispose();
             }
             base.Dispose(disposing);
         }
diff --git a/test/Microsoft.AspNetCore.WebSockets.Test/SendReceiveTests.cs b/test/Microsoft.AspNetCore.WebSockets.Test/SendReceiveTests.cs
@@ -73,5 +73,35 @@ public async Task ServerToClientBinaryMessage()
             Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
             Assert.Equal(sendBuffer, receiveBuffer.Take(result.Count).ToArray());
         }
+
+        [Fact]
+        public async Task ThrowsWhenUnderlyingStreamClosed()
+        {
+            var pair = WebSocketPair.Create();
+            var sendBuffer = new byte[] { 0xde, 0xad, 0xbe, 0xef };
+
+            await pair.ServerSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Binary, endOfMessage: true, cancellationToken: CancellationToken.None);
+
+            var receiveBuffer = new byte[32];
+            var result = await pair.ClientSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
+
+            Assert.Equal(WebSocketMessageType.Binary, result.MessageType);
+
+            // Close the client socket's read end
+            pair.ClientStream.ReadStream.End();
+
+            // Assert.Throws doesn't support async :(
+            try
+            {
+                await pair.ClientSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);
+
+                // The exception should prevent this line from running
+                Assert.False(true, "Expected an exception to be thrown!");
+            }
+            catch (WebSocketException ex)
+            {
+                Assert.Equal(WebSocketError.ConnectionClosedPrematurely, ex.WebSocketErrorCode);
+            }
+        }
     }
 }
diff --git a/test/Microsoft.AspNetCore.WebSockets.Test/WebSocketPair.cs b/test/Microsoft.AspNetCore.WebSockets.Test/WebSocketPair.cs
@@ -8,9 +8,13 @@ internal class WebSocketPair
     {
         public WebSocket ClientSocket { get; }
         public WebSocket ServerSocket { get; }
+        public DuplexStream ServerStream { get; }
+        public DuplexStream ClientStream { get; }
 
-        public WebSocketPair(WebSocket clientSocket, WebSocket serverSocket)
+        public WebSocketPair(DuplexStream serverStream, DuplexStream clientStream, WebSocket clientSocket, WebSocket serverSocket)
         {
+            ClientStream = clientStream;
+            ServerStream = serverStream;
             ClientSocket = clientSocket;
             ServerSocket = serverSocket;
         }
@@ -22,6 +26,8 @@ public static WebSocketPair Create()
             var clientStream = serverStream.CreateReverseDuplexStream();
 
             return new WebSocketPair(
+                serverStream,
+                clientStream,
                 clientSocket: WebSocketFactory.CreateClientWebSocket(clientStream, null, TimeSpan.FromMinutes(2), 1024),
                 serverSocket: WebSocketFactory.CreateServerWebSocket(serverStream, null, TimeSpan.FromMinutes(2), 1024));
         }

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public void ConfigureServices(IServiceCollection services)`
`24`	`24`	`// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.`
`25`	`25`	`public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)`
`26`	`26`	`{`
`27`		`- loggerFactory.AddConsole();`
	`27`	`+ loggerFactory.AddConsole(LogLevel.Debug);`
`28`	`28`
`29`	`29`	`if (env.IsDevelopment())`
`30`	`30`	`{`
`@@ -38,7 +38,7 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerF`
`38`	`38`	`if (context.WebSockets.IsWebSocketRequest)`
`39`	`39`	`{`
`40`	`40`	`var webSocket = await context.WebSockets.AcceptWebSocketAsync();`
`41`		`- await Echo(webSocket);`
	`41`	`+ await Echo(context, webSocket, loggerFactory.CreateLogger("Echo"));`
`42`	`42`	`}`
`43`	`43`	`else`
`44`	`44`	`{`
`@@ -49,27 +49,57 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerF`
`49`	`49`	`app.UseFileServer();`
`50`	`50`	`}`
`51`	`51`
`52`		`- private async Task Echo(WebSocket webSocket)`
	`52`	`+ private async Task Echo(HttpContext context, WebSocket webSocket, ILogger logger)`
`53`	`53`	`{`
`54`	`54`	`var buffer = new byte[1024 * 4];`
`55`	`55`	`var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);`
	`56`	`+ LogFrame(logger, result, buffer);`
`56`	`57`	`while (!result.CloseStatus.HasValue)`
`57`	`58`	`{`
`58`	`59`	`// If the client send "ServerClose", then they want a server-originated close to occur`
`59`		`- if(result.MessageType == WebSocketMessageType.Text)`
	`60`	`+ string content = "<<binary>>";`
	`61`	`+ if (result.MessageType == WebSocketMessageType.Text)`
`60`	`62`	`{`
`61`		`- var str = Encoding.UTF8.GetString(buffer, 0, result.Count);`
`62`		`- if(str.Equals("ServerClose"))`
	`63`	`+ content = Encoding.UTF8.GetString(buffer, 0, result.Count);`
	`64`	`+ if (content.Equals("ServerClose"))`
`63`	`65`	`{`
`64`	`66`	`await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing from Server", CancellationToken.None);`
	`67`	`+ logger.LogDebug($"Sent Frame Close: {WebSocketCloseStatus.NormalClosure} Closing from Server");`
`65`	`68`	`return;`
`66`	`69`	`}`
	`70`	`+ else if (content.Equals("ServerAbort"))`
	`71`	`+ {`
	`72`	`+ context.Abort();`
	`73`	`+ }`
`67`	`74`	`}`
`68`	`75`
`69`	`76`	`await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None);`
	`77`	`+ logger.LogDebug($"Sent Frame {result.MessageType}: Len={result.Count}, Fin={result.EndOfMessage}: {content}");`
	`78`	`+`
`70`	`79`	`result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);`
	`80`	`+ LogFrame(logger, result, buffer);`
`71`	`81`	`}`
`72`	`82`	`await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);`
`73`	`83`	`}`
	`84`	`+`
	`85`	`+ private void LogFrame(ILogger logger, WebSocketReceiveResult frame, byte[] buffer)`
	`86`	`+ {`
	`87`	`+ var close = frame.CloseStatus != null;`
	`88`	`+ string message;`
	`89`	`+ if (close)`
	`90`	`+ {`
	`91`	`+ message = $"Close: {frame.CloseStatus.Value} {frame.CloseStatusDescription}";`
	`92`	`+ }`
	`93`	`+ else`
	`94`	`+ {`
	`95`	`+ string content = "<<binary>>";`
	`96`	`+ if (frame.MessageType == WebSocketMessageType.Text)`
	`97`	`+ {`
	`98`	`+ content = Encoding.UTF8.GetString(buffer, 0, frame.Count);`
	`99`	`+ }`
	`100`	`+ message = $"{frame.MessageType}: Len={frame.Count}, Fin={frame.EndOfMessage}: {content}";`
	`101`	`+ }`
	`102`	`+ logger.LogDebug("Received Frame " + message);`
	`103`	`+ }`
`74`	`104`	`}`
`75`	`105`	`}`
Original file line number	Diff line number	Diff line change
`@@ -615,12 +615,7 @@ private async Task<WebSocketReceiveResult> ReceiveAsyncPrivate(ArraySegment<byte`
`615`	`615`	`// Make sure we have the first two bytes, which includes the start of the payload length.`
`616`	`616`	`if (_receiveBufferCount < 2)`
`617`	`617`	`{`
`618`		`- await EnsureBufferContainsAsync(2, cancellationToken, throwOnPrematureClosure: false).ConfigureAwait(false);`
`619`		`- if (_receiveBufferCount < 2)`
`620`		`- {`
`621`		`- // The connection closed; nothing more to read.`
`622`		`- return new WebSocketReceiveResult(0, WebSocketMessageType.Text, true);`
`623`		`- }`
	`618`	`+ await EnsureBufferContainsAsync(2, cancellationToken, throwOnPrematureClosure: true).ConfigureAwait(false);`
`624`	`619`	`}`
`625`	`620`
`626`	`621`	`// Then make sure we have the full header based on the payload length.`
Original file line number	Diff line number	Diff line change
`@@ -10,30 +10,31 @@ namespace Microsoft.AspNetCore.WebSockets.Test`
`10`	`10`	`// A duplex wrapper around a read and write stream.`
`11`	`11`	`public class DuplexStream : Stream`
`12`	`12`	`{`
`13`		`- private readonly Stream _readStream;`
`14`		`- private readonly Stream _writeStream;`
	`13`	`+ public BufferStream ReadStream { get; }`
	`14`	`+ public BufferStream WriteStream { get; }`
`15`	`15`
`16`	`16`	`public DuplexStream()`
`17`	`17`	`: this (new BufferStream(), new BufferStream())`
`18`	`18`	`{`
`19`	`19`	`}`
`20`	`20`
`21`		`- public DuplexStream(Stream readStream, Stream writeStream)`
	`21`	`+ public DuplexStream(BufferStream readStream, BufferStream writeStream)`
`22`	`22`	`{`
`23`		`- _readStream = readStream;`
`24`		`- _writeStream = writeStream;`
	`23`	`+ ReadStream = readStream;`
	`24`	`+ WriteStream = writeStream;`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`public DuplexStream CreateReverseDuplexStream()`
`28`	`28`	`{`
`29`		`- return new DuplexStream(_writeStream, _readStream);`
	`29`	`+ return new DuplexStream(WriteStream, ReadStream);`
`30`	`30`	`}`
`31`	`31`
	`32`	`+`
`32`	`33`	`#region Properties`
`33`	`34`
`34`	`35`	`public override bool CanRead`
`35`	`36`	`{`
`36`		`- get { return _readStream.CanRead; }`
	`37`	`+ get { return ReadStream.CanRead; }`
`37`	`38`	`}`
`38`	`39`
`39`	`40`	`public override bool CanSeek`
`@@ -43,12 +44,12 @@ public override bool CanSeek`
`43`	`44`
`44`	`45`	`public override bool CanTimeout`
`45`	`46`	`{`
`46`		`- get { return _readStream.CanTimeout \|\| _writeStream.CanTimeout; }`
	`47`	`+ get { return ReadStream.CanTimeout \|\| WriteStream.CanTimeout; }`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`public override bool CanWrite`
`50`	`51`	`{`
`51`		`- get { return _writeStream.CanWrite; }`
	`52`	`+ get { return WriteStream.CanWrite; }`
`52`	`53`	`}`
`53`	`54`
`54`	`55`	`public override long Length`
`@@ -64,14 +65,14 @@ public override long Position`
`64`	`65`
`65`	`66`	`public override int ReadTimeout`
`66`	`67`	`{`
`67`		`- get { return _readStream.ReadTimeout; }`
`68`		`- set { _readStream.ReadTimeout = value; }`
	`68`	`+ get { return ReadStream.ReadTimeout; }`
	`69`	`+ set { ReadStream.ReadTimeout = value; }`
`69`	`70`	`}`
`70`	`71`
`71`	`72`	`public override int WriteTimeout`
`72`	`73`	`{`
`73`		`- get { return _writeStream.WriteTimeout; }`
`74`		`- set { _writeStream.WriteTimeout = value; }`
	`74`	`+ get { return WriteStream.WriteTimeout; }`
	`75`	`+ set { WriteStream.WriteTimeout = value; }`
`75`	`76`	`}`
`76`	`77`
`77`	`78`	`#endregion Properties`
`@@ -90,33 +91,33 @@ public override void SetLength(long value)`
`90`	`91`
`91`	`92`	`public override int Read(byte[] buffer, int offset, int count)`
`92`	`93`	`{`
`93`		`- return _readStream.Read(buffer, offset, count);`
	`94`	`+ return ReadStream.Read(buffer, offset, count);`
`94`	`95`	`}`
`95`	`96`
`96`	`97`	`#if !NETCOREAPP1_0`
`97`	`98`	`public override int ReadByte()`
`98`	`99`	`{`
`99`		`- return _readStream.ReadByte();`
	`100`	`+ return ReadStream.ReadByte();`
`100`	`101`	`}`
`101`	`102`
`102`	`103`	`public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)`
`103`	`104`	`{`
`104`		`- return _readStream.BeginRead(buffer, offset, count, callback, state);`
	`105`	`+ return ReadStream.BeginRead(buffer, offset, count, callback, state);`
`105`	`106`	`}`
`106`	`107`
`107`	`108`	`public override int EndRead(IAsyncResult asyncResult)`
`108`	`109`	`{`
`109`		`- return _readStream.EndRead(asyncResult);`
	`110`	`+ return ReadStream.EndRead(asyncResult);`
`110`	`111`	`}`
`111`	`112`
`112`	`113`	`public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)`
`113`	`114`	`{`
`114`		`- return _readStream.ReadAsync(buffer, offset, count, cancellationToken);`
	`115`	`+ return ReadStream.ReadAsync(buffer, offset, count, cancellationToken);`
`115`	`116`	`}`
`116`	`117`
`117`	`118`	`public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)`
`118`	`119`	`{`
`119`		`- return _readStream.CopyToAsync(destination, bufferSize, cancellationToken);`
	`120`	`+ return ReadStream.CopyToAsync(destination, bufferSize, cancellationToken);`
`120`	`121`	`}`
`121`	`122`	`#endif`
`122`	`123`
`@@ -126,39 +127,39 @@ public override Task CopyToAsync(Stream destination, int bufferSize, Cancellatio`
`126`	`127`
`127`	`128`	`public override void Write(byte[] buffer, int offset, int count)`
`128`	`129`	`{`
`129`		`- _writeStream.Write(buffer, offset, count);`
	`130`	`+ WriteStream.Write(buffer, offset, count);`
`130`	`131`	`}`
`131`	`132`
`132`	`133`	`#if !NETCOREAPP1_0`
`133`	`134`	`public override void WriteByte(byte value)`
`134`	`135`	`{`
`135`		`- _writeStream.WriteByte(value);`
	`136`	`+ WriteStream.WriteByte(value);`
`136`	`137`	`}`
`137`	`138`
`138`	`139`	`public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)`
`139`	`140`	`{`
`140`		`- return _writeStream.BeginWrite(buffer, offset, count, callback, state);`
	`141`	`+ return WriteStream.BeginWrite(buffer, offset, count, callback, state);`
`141`	`142`	`}`
`142`	`143`
`143`	`144`	`public override void EndWrite(IAsyncResult asyncResult)`
`144`	`145`	`{`
`145`		`- _writeStream.EndWrite(asyncResult);`
	`146`	`+ WriteStream.EndWrite(asyncResult);`
`146`	`147`	`}`
`147`	`148`
`148`	`149`	`public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)`
`149`	`150`	`{`
`150`		`- return _writeStream.WriteAsync(buffer, offset, count, cancellationToken);`
	`151`	`+ return WriteStream.WriteAsync(buffer, offset, count, cancellationToken);`
`151`	`152`	`}`
`152`	`153`
`153`	`154`	`public override Task FlushAsync(CancellationToken cancellationToken)`
`154`	`155`	`{`
`155`		`- return _writeStream.FlushAsync(cancellationToken);`
	`156`	`+ return WriteStream.FlushAsync(cancellationToken);`
`156`	`157`	`}`
`157`	`158`	`#endif`
`158`	`159`
`159`	`160`	`public override void Flush()`
`160`	`161`	`{`
`161`		`- _writeStream.Flush();`
	`162`	`+ WriteStream.Flush();`
`162`	`163`	`}`
`163`	`164`
`164`	`165`	`#endregion Write`
`@@ -167,8 +168,8 @@ protected override void Dispose(bool disposing)`
`167`	`168`	`{`
`168`	`169`	`if (disposing)`
`169`	`170`	`{`
`170`		`- _readStream.Dispose();`
`171`		`- _writeStream.Dispose();`
	`171`	`+ ReadStream.Dispose();`
	`172`	`+ WriteStream.Dispose();`
`172`	`173`	`}`
`173`	`174`	`base.Dispose(disposing);`
`174`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,9 +8,13 @@ internal class WebSocketPair`
`8`	`8`	`{`
`9`	`9`	`public WebSocket ClientSocket { get; }`
`10`	`10`	`public WebSocket ServerSocket { get; }`
	`11`	`+ public DuplexStream ServerStream { get; }`
	`12`	`+ public DuplexStream ClientStream { get; }`
`11`	`13`
`12`		`- public WebSocketPair(WebSocket clientSocket, WebSocket serverSocket)`
	`14`	`+ public WebSocketPair(DuplexStream serverStream, DuplexStream clientStream, WebSocket clientSocket, WebSocket serverSocket)`
`13`	`15`	`{`
	`16`	`+ ClientStream = clientStream;`
	`17`	`+ ServerStream = serverStream;`
`14`	`18`	`ClientSocket = clientSocket;`
`15`	`19`	`ServerSocket = serverSocket;`
`16`	`20`	`}`
`@@ -22,6 +26,8 @@ public static WebSocketPair Create()`
`22`	`26`	`var clientStream = serverStream.CreateReverseDuplexStream();`
`23`	`27`
`24`	`28`	`return new WebSocketPair(`
	`29`	`+ serverStream,`
	`30`	`+ clientStream,`
`25`	`31`	`clientSocket: WebSocketFactory.CreateClientWebSocket(clientStream, null, TimeSpan.FromMinutes(2), 1024),`
`26`	`32`	`serverSocket: WebSocketFactory.CreateServerWebSocket(serverStream, null, TimeSpan.FromMinutes(2), 1024));`
`27`	`33`	`}`