public void Initialize()
{
wsProtocol = new WebSocketProtocol()
{
Port = PORT, Address = hostAddress
};
}
private void WebSocket(IApplicationBuilder app)
{
app.Run(async context =>
{
var upgradeFeature = context.Features.Get <IHttpUpgradeFeature>();
// Generate WebSocket response headers
string key = context.Request.Headers[Constants.Headers.SecWebSocketKey].ToString();
var responseHeaders = HandshakeHelpers.GenerateResponseHeaders(key);
foreach (var headerPair in responseHeaders)
{
context.Response.Headers[headerPair.Key] = headerPair.Value;
}
// Upgrade the connection
Stream opaqueTransport = await upgradeFeature.UpgradeAsync();
// Get the WebSocket object
var ws = WebSocketProtocol.CreateFromStream(opaqueTransport, isServer: true, subProtocol: null, keepAliveInterval: TimeSpan.FromMinutes(2));
var appLifetime = app.ApplicationServices.GetRequiredService <IApplicationLifetime>();
await Echo(ws, appLifetime.ApplicationStopping);
});
}
public static async Task ManagedWebSocket_ReceiveUTF8SplitAcrossMultipleBuffers()
{
// 1 character - 2 bytes
byte[] payload = Encoding.UTF8.GetBytes("\u00E6");
var frame = new byte[payload.Length + 2];
frame[0] = 0x81; // FIN = true, Opcode = Text
frame[1] = (byte)payload.Length;
Array.Copy(payload, 0, frame, 2, payload.Length);
using (var stream = new MemoryStream(frame, writable: true))
{
WebSocket websocket = WebSocketProtocol.CreateFromStream(stream, false, "null", Timeout.InfiniteTimeSpan);
// read first half of the multi-byte character
var recvBuffer = new byte[1];
WebSocketReceiveResult result = await websocket.ReceiveAsync(new ArraySegment <byte>(recvBuffer), CancellationToken.None);
Assert.False(result.EndOfMessage);
Assert.Equal(1, result.Count);
Assert.Equal(0xc3, recvBuffer[0]);
// read second half of the multi-byte character
result = await websocket.ReceiveAsync(new ArraySegment <byte>(recvBuffer), CancellationToken.None);
Assert.True(result.EndOfMessage);
Assert.Equal(1, result.Count);
Assert.Equal(0xa6, recvBuffer[0]);
}
}
public void DisposeTest()
{
var wsProtocol = new WebSocketProtocol();
wsProtocol.Port = 4884;
wsProtocol.Listen();
wsProtocol.Dispose();
Assert.IsFalse(wsProtocol.Listening);
}
public override async Task ProcessRequestAsync()
{
DoUpgrade();
await Connection.Transport.Output.FlushAsync();
using (var ws = WebSocketProtocol.CreateFromStream(new DuplexStream(Connection.Transport), isServer: true, subProtocol: null, keepAliveInterval: TimeSpan.FromMinutes(2), new byte[14]))
{
await ProcessAsync(ws);
}
}
public static WebSocketPair Create()
{
// Create streams
var serverStream = new DuplexStream();
var clientStream = serverStream.CreateReverseDuplexStream();
return(new WebSocketPair(
serverStream,
clientStream,
clientSocket: WebSocketProtocol.CreateFromStream(clientStream, isServer: false, subProtocol: null, keepAliveInterval: TimeSpan.FromMinutes(2)),
serverSocket: WebSocketProtocol.CreateFromStream(serverStream, isServer: true, subProtocol: null, keepAliveInterval: TimeSpan.FromMinutes(2))));
}
public void ConnectTest()
{
try
{
wsProtocol.Listen();
WebSocketProtocol ipvClient = this.CreateWSClientProtocol();
var socket = ipvClient.Connect(serverAddress, PORT);
Assert.IsTrue(socket.Connected, "A connection could not be established.");
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
public async Task ConnectAsyncTaskTest()
{
try
{
wsProtocol.Listen();
WebSocketProtocol ipvClient = this.CreateWSClientProtocol();
var wsSocket = await ipvClient.ConnectAsync(serverAddress, PORT);
Assert.IsNotNull(wsSocket);
Assert.IsTrue(wsSocket.Connected);
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
public void CreateFromStream_InvalidArguments_Throws()
{
AssertExtensions.Throws <ArgumentNullException>("stream",
() => WebSocketProtocol.CreateFromStream(null, true, "subProtocol", TimeSpan.FromSeconds(30), default(Memory <byte>)));
AssertExtensions.Throws <ArgumentException>("stream",
() => WebSocketProtocol.CreateFromStream(new MemoryStream(new byte[100], writable: false), true, "subProtocol", TimeSpan.FromSeconds(30), default(Memory <byte>)));
AssertExtensions.Throws <ArgumentException>("stream",
() => WebSocketProtocol.CreateFromStream(new UnreadableStream(), true, "subProtocol", TimeSpan.FromSeconds(30), default(Memory <byte>)));
AssertExtensions.Throws <ArgumentException>("subProtocol",
() => WebSocketProtocol.CreateFromStream(new MemoryStream(), true, " ", TimeSpan.FromSeconds(30), default(Memory <byte>)));
AssertExtensions.Throws <ArgumentException>("subProtocol",
() => WebSocketProtocol.CreateFromStream(new MemoryStream(), true, "\xFF", TimeSpan.FromSeconds(30), default(Memory <byte>)));
AssertExtensions.Throws <ArgumentOutOfRangeException>("keepAliveInterval", () =>
WebSocketProtocol.CreateFromStream(new MemoryStream(), true, "subProtocol", TimeSpan.FromSeconds(-2), default(Memory <byte>)));
}
public async Task <WebSocket> AcceptAsync(WebSocketAcceptContext acceptContext)
{
if (!IsWebSocketRequest)
{
throw new InvalidOperationException("Not a WebSocket request."); // TODO: LOC
}
string subProtocol = null;
if (acceptContext != null)
{
subProtocol = acceptContext.SubProtocol;
}
TimeSpan keepAliveInterval = _options.KeepAliveInterval;
int receiveBufferSize = _options.ReceiveBufferSize;
var advancedAcceptContext = acceptContext as ExtendedWebSocketAcceptContext;
if (advancedAcceptContext != null)
{
if (advancedAcceptContext.ReceiveBufferSize.HasValue)
{
receiveBufferSize = advancedAcceptContext.ReceiveBufferSize.Value;
}
if (advancedAcceptContext.KeepAliveInterval.HasValue)
{
keepAliveInterval = advancedAcceptContext.KeepAliveInterval.Value;
}
}
string key = string.Join(", ", _context.Request.Headers[Constants.Headers.SecWebSocketKey]);
var responseHeaders = HandshakeHelpers.GenerateResponseHeaders(key, subProtocol);
foreach (var headerPair in responseHeaders)
{
_context.Response.Headers[headerPair.Key] = headerPair.Value;
}
Stream opaqueTransport = await _upgradeFeature.UpgradeAsync(); // Sets status code to 101
// Allocate a buffer for receive (default is 4k)
var buffer = new byte[receiveBufferSize];
return(WebSocketProtocol.CreateFromStream(opaqueTransport, isServer: true, subProtocol: subProtocol, keepAliveInterval: keepAliveInterval, buffer: buffer));
}
public void OnConnectionRequestedTest()
{
ManualResetEventSlim mevent = new ManualResetEventSlim(false);
wsProtocol.Listen();
mevent.Reset();
bool eventInvoked = false;
wsProtocol.OnConnectionRequested += (socket) =>
{
eventInvoked = true;
mevent.Set();
};
WebSocketProtocol ipvClient = this.CreateWSClientProtocol();
var clientSocket = ipvClient.Connect(serverAddress, PORT);
mevent.Wait(10000);
Assert.IsTrue(eventInvoked);
}
protected override void OnReciveTextPacket(WebSocketProtocol aSender, IWebSocketPacket e)
{
if (recivePacket != null)
{
recivePacket(aSender, e);
}
try
{
JsonObject lTextjson = new JsonObject(e.GetString());
IToken lToken = PacketToToken(e);
string lType = lToken.GetType();
lock (PendingResponseQueue)
{
if (!lType.Equals(WebSocketMessage.WELCOME) && !lType.Equals(WebSocketMessage.GOODBYTE))
{
try
{
int lUTID = lToken.GetInt(WebSocketMessage.UTID);
int lCode = lToken.GetInt(WebSocketMessage.CODE);
PendingResponseQueue lPRQI = PendingResponseQueue[lUTID];
if (lPRQI != null)
{
bool lSuccess = false;
if (lCode == 0)
{
lSuccess = true;
}
TokenResponse lResponse = new TokenResponse(mPendingResponseQueue[lUTID].Token, lToken, lSuccess);
lPRQI.PendingResponse.Invoke(this, lResponse);
PendingResponseQueue.Remove(lUTID);
}
}
catch (Exception) { }
}
}
OnReciveTokenText(lToken);
}
catch (Exception) { }
}
public void Initialize()
{
ManualResetEvent mevent = new ManualResetEvent(false);
ipv4Server = new WebSocketProtocol()
{
Port = PORT, Address = hostAddress
};
ipv4Server.Port = PORT;
ipv4Server.OnConnectionRequested += (socket) =>
{
ipv4ServerClient = socket;
mevent.Set();
};
ipv4Server.Listen();
mevent.Reset();
ipv4Client = this.CreateWSClientProtocol().Connect(serverAddress, PORT);
mevent.WaitOne(1000);
}
private static async Task <WebSocket> Upgrade(HttpContext context)
{
var upgradeFeature = context.Features.Get <IHttpUpgradeFeature>();
// Generate WebSocket response headers
string key = context.Request.Headers[Constants.Headers.SecWebSocketKey].ToString();
var responseHeaders = HandshakeHelpers.GenerateResponseHeaders(key);
foreach (var headerPair in responseHeaders)
{
context.Response.Headers[headerPair.Key] = headerPair.Value;
}
// Upgrade the connection
Stream opaqueTransport = await upgradeFeature.UpgradeAsync();
// Get the WebSocket object
var ws = WebSocketProtocol.CreateFromStream(opaqueTransport, isServer: true, subProtocol: null, keepAliveInterval: TimeSpan.FromMinutes(2));
return(ws);
}
public void ConnectAsyncCallbackTest()
{
ManualResetEventSlim mevent = new ManualResetEventSlim(false);
mevent.Reset();
try
{
wsProtocol.Listen();
WebSocketProtocol ipvClient = this.CreateWSClientProtocol();
bool connected = false;
ipvClient.ConnectAsync((socket) =>
{
connected = socket.Connected;
mevent.Set();
}, serverAddress, PORT);
mevent.Wait(1000);
Assert.IsTrue(condition: connected, message: "A connection could not be established.");
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
public async Task WebSocketProtocol_CreateFromConnectedStream_Succeeds(Uri echoUri)
{
Uri uri = new UriBuilder(echoUri)
{
Scheme = (echoUri.Scheme == "ws") ? "http" : "https"
}.Uri;
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
KeyValuePair <string, string> secKeyAndSecWebSocketAccept = CreateSecKeyAndSecWebSocketAccept();
AddWebSocketHeaders(request, secKeyAndSecWebSocketAccept.Key);
DirectManagedHttpClientHandler handler = DirectManagedHttpClientHandler.CreateHandler();
using (HttpResponseMessage response = await handler.SendAsync(request, CancellationToken.None).ConfigureAwait(false))
{
Assert.Equal(HttpStatusCode.SwitchingProtocols, response.StatusCode);
using (Stream connectedStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
Assert.True(connectedStream.CanRead);
Assert.True(connectedStream.CanWrite);
using (WebSocket socket = WebSocketProtocol.CreateFromStream(connectedStream, false, null, TimeSpan.FromSeconds(10)))
{
Assert.NotNull(socket);
Assert.Equal(WebSocketState.Open, socket.State);
string expected = "Hello World!";
ArraySegment <byte> buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes(expected));
await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
buffer = new ArraySegment <byte>(new byte[buffer.Count]);
await socket.ReceiveAsync(buffer, CancellationToken.None);
Assert.Equal(expected, Encoding.UTF8.GetString(buffer.Array));
}
}
}
}
protected override WebSocket CreateFromStream(Stream stream, bool isServer, string subProtocol, TimeSpan keepAliveInterval) => WebSocketProtocol.CreateFromStream(stream, isServer, subProtocol, keepAliveInterval);
public async Task WebSocketProtocol_CreateFromConnectedStream_Succeeds(Uri echoUri)
{
using (var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
bool secure = echoUri.Scheme == "wss";
client.Connect(echoUri.Host, secure ? 443 : 80);
Stream stream = new NetworkStream(client, ownsSocket: false);
if (secure)
{
SslStream ssl = new SslStream(stream, leaveInnerStreamOpen: true, delegate { return(true); });
await ssl.AuthenticateAsClientAsync(echoUri.Host);
stream = ssl;
}
using (stream)
{
using (var writer = new StreamWriter(stream, Encoding.ASCII, bufferSize: 1, leaveOpen: true))
{
await writer.WriteAsync($"GET {echoUri.PathAndQuery} HTTP/1.1\r\n");
await writer.WriteAsync($"Host: {echoUri.Host}\r\n");
await writer.WriteAsync($"Upgrade: websocket\r\n");
await writer.WriteAsync($"Connection: Upgrade\r\n");
await writer.WriteAsync($"Sec-WebSocket-Version: 13\r\n");
await writer.WriteAsync($"Sec-WebSocket-Key: {Convert.ToBase64String(Guid.NewGuid().ToByteArray())}\r\n");
await writer.WriteAsync($"\r\n");
}
using (var reader = new StreamReader(stream, Encoding.ASCII, detectEncodingFromByteOrderMarks: false, bufferSize: 1, leaveOpen: true))
{
string statusLine = await reader.ReadLineAsync();
Assert.NotEmpty(statusLine);
Assert.Equal("HTTP/1.1 101 Switching Protocols", statusLine);
while (!string.IsNullOrEmpty(await reader.ReadLineAsync()))
{
;
}
}
using (WebSocket socket = WebSocketProtocol.CreateFromStream(stream, false, null, TimeSpan.FromSeconds(10)))
{
Assert.NotNull(socket);
Assert.Equal(WebSocketState.Open, socket.State);
string expected = "Hello World!";
ArraySegment <byte> buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes(expected));
await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
buffer = new ArraySegment <byte>(new byte[buffer.Count]);
await socket.ReceiveAsync(buffer, CancellationToken.None);
Assert.Equal(expected, Encoding.UTF8.GetString(buffer.Array));
}
}
}
}
public void CreateFromStream_ValidBufferSizes_Succeed(int bufferSize)
{
Assert.NotNull(WebSocketProtocol.CreateFromStream(new MemoryStream(), false, null, Timeout.InfiniteTimeSpan, new Memory <byte>(new byte[bufferSize])));
Assert.NotNull(WebSocketProtocol.CreateFromStream(new MemoryStream(), true, null, Timeout.InfiniteTimeSpan, new Memory <byte>(new byte[bufferSize])));
}
public override BaseProtocol SpawnProtocol(ulong type, Variant parameters)
{
BaseProtocol pResult = null;
switch (type)
{
case ProtocolTypes.PT_TCP:
pResult = new TCPProtocol();
break;
case ProtocolTypes.PT_UDP:
pResult = new UDPProtocol();
break;
case ProtocolTypes.PT_INBOUND_SSL:
pResult = new InboundSSLProtocol();
break;
case ProtocolTypes.PT_OUTBOUND_SSL:
pResult = new OutboundSSLProtocol();
break;
case ProtocolTypes.PT_INBOUND_RTMP:
pResult = new InboundRTMPProtocol();
break;
case ProtocolTypes.PT_INBOUND_RTMPS_DISC:
break;
case ProtocolTypes.PT_OUTBOUND_RTMP:
pResult = new OutboundRTMPProtocol();
break;
case ProtocolTypes.PT_INBOUND_RTMFP:
pResult = new InboundRTMFPProtocol();
break;
case ProtocolTypes.PT_INBOUND_CLUSTER:
pResult = new InboundClusterProtocol();
break;
case ProtocolTypes.PT_OUTBOUND_CLUSTER:
pResult = new OutboundClusterProtocol();
break;
case ProtocolTypes.PT_RTSP:
pResult = new RtspProtocol();
break;
case ProtocolTypes.PT_RTP_NAT_TRAVERSAL:
pResult = new NATTraversalProtocol();
break;
case ProtocolTypes.PT_INBOUND_RTP:
pResult = new InboundRtpProtocol();
break;
case ProtocolTypes.PT_RTCP:
pResult = new RtcpProtocol();
break;
case ProtocolTypes.PT_INBOUND_WEBSOCKET:
pResult = new WebSocketProtocol();
break;
case ProtocolTypes.PT_INBOUND_WEBRTC_SIGNAL:
pResult = new WebRtcSignalProtocol();
break;
case ProtocolTypes.PT_INBOUND_MP4:
pResult = new Mp4Protocol();
break;
default:
Logger.FATAL("Spawning protocol {0} not yet implemented",
type.TagToString());
break;
}
if (pResult != null)
{
if (!pResult.Initialize(parameters))
{
Logger.FATAL("Unable to initialize protocol {0}",
type.TagToString());
pResult = null;
}
}
return(pResult);
}
