public async Task <WebSocket> ConnectAsync(HttpWebRequest request, CancellationToken cancellationToken)
{
HttpWebResponse response;
using (cancellationToken.Register(request.Abort)) {
response = (HttpWebResponse)await request.GetResponseAsync();
}
InspectResponse?.Invoke(response);
// TODO: Validate handshake
HttpStatusCode statusCode = response.StatusCode;
if (statusCode != HttpStatusCode.SwitchingProtocols)
{
response.Dispose();
throw new InvalidOperationException("Incomplete handshake, invalid status code: " + statusCode);
}
// TODO: Validate Sec-WebSocket-Key/Sec-WebSocket-Accept
string subProtocol = response.Headers[Constants.Headers.SecWebSocketProtocol];
if (!string.IsNullOrEmpty(subProtocol) && !SubProtocols.Contains(subProtocol, StringComparer.OrdinalIgnoreCase))
{
throw new InvalidOperationException("Incomplete handshake, the server specified an unknown sub-protocol: " + subProtocol);
}
var stream = response.GetResponseStream();
return(CommonWebSocket.CreateClientWebSocket(stream, subProtocol, KeepAliveInterval, ReceiveBufferSize, UseZeroMask));
}
private Handshake GetHandshakeResponse(Handshake handshakeRequest)
{
Handshake handshakeResponse;
if (handshakeRequest.ReservedOctects != 0)
{
handshakeResponse = new Handshake(HandshakeErrorCode.UseOfReservedBits);
}
else
{
SerializerType serializerType = handshakeRequest.SerializerType;
string requestedSubprotocol = GetSubProtocol(serializerType);
if (!SubProtocols.Contains(requestedSubprotocol))
{
handshakeResponse = new Handshake(HandshakeErrorCode.SerializerUnsupported);
}
else
{
handshakeResponse = new Handshake(MaxSize, serializerType);
}
}
return(handshakeResponse);
}
public async Task <WebSocket> ConnectAsync(Uri uri, CancellationToken cancellationToken)
{
WebSocketFeature webSocketFeature = null;
var contextBuilder = new HttpContextBuilder(_application, AllowSynchronousIO, PreserveExecutionContext);
contextBuilder.Configure(context =>
{
var request = context.Request;
var scheme = uri.Scheme;
scheme = (scheme == "ws") ? "http" : scheme;
scheme = (scheme == "wss") ? "https" : scheme;
request.Scheme = scheme;
if (!request.Host.HasValue)
{
request.Host = uri.IsDefaultPort
? new HostString(HostString.FromUriComponent(uri).Host)
: HostString.FromUriComponent(uri);
}
request.Path = PathString.FromUriComponent(uri);
request.PathBase = PathString.Empty;
if (request.Path.StartsWithSegments(_pathBase, out var remainder))
{
request.Path = remainder;
request.PathBase = _pathBase;
}
request.QueryString = QueryString.FromUriComponent(uri);
request.Headers.Add(HeaderNames.Connection, new string[] { "Upgrade" });
request.Headers.Add(HeaderNames.Upgrade, new string[] { "websocket" });
request.Headers.Add(HeaderNames.SecWebSocketVersion, new string[] { "13" });
request.Headers.Add(HeaderNames.SecWebSocketKey, new string[] { CreateRequestKey() });
if (SubProtocols.Any())
{
request.Headers.Add(HeaderNames.SecWebSocketProtocol, SubProtocols.ToArray());
}
request.Body = Stream.Null;
// WebSocket
webSocketFeature = new WebSocketFeature(context);
context.Features.Set <IHttpWebSocketFeature>(webSocketFeature);
ConfigureRequest?.Invoke(context.Request);
});
var httpContext = await contextBuilder.SendAsync(cancellationToken);
if (httpContext.Response.StatusCode != StatusCodes.Status101SwitchingProtocols)
{
throw new InvalidOperationException("Incomplete handshake, status code: " + httpContext.Response.StatusCode);
}
if (webSocketFeature.ClientWebSocket == null)
{
throw new InvalidOperationException("Incomplete handshake");
}
return(webSocketFeature.ClientWebSocket);
}
public async Task <WebSocket> ConnectAsync(Uri uri, CancellationToken cancellationToken)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
CancellationTokenRegistration cancellation = cancellationToken.Register(() => request.Abort());
request.Headers[Constants.Headers.SecWebSocketVersion] = Constants.Headers.SupportedVersion;
if (SubProtocols.Count > 0)
{
request.Headers[Constants.Headers.SecWebSocketProtocol] = string.Join(", ", SubProtocols);
}
if (ConfigureRequest != null)
{
ConfigureRequest(request);
}
HttpWebResponse response = (HttpWebResponse)await request.GetResponseAsync();
cancellation.Dispose();
if (InspectResponse != null)
{
InspectResponse(response);
}
// TODO: Validate handshake
HttpStatusCode statusCode = response.StatusCode;
if (statusCode != HttpStatusCode.SwitchingProtocols)
{
response.Dispose();
throw new InvalidOperationException("Incomplete handshake, invalid status code: " + statusCode);
}
// TODO: Validate Sec-WebSocket-Key/Sec-WebSocket-Accept
string subProtocol = response.Headers[Constants.Headers.SecWebSocketProtocol];
if (!string.IsNullOrEmpty(subProtocol) && !SubProtocols.Contains(subProtocol, StringComparer.OrdinalIgnoreCase))
{
throw new InvalidOperationException("Incomplete handshake, the server specified an unknown sub-protocol: " + subProtocol);
}
Stream stream = response.GetResponseStream();
return(CommonWebSocket.CreateClientWebSocket(stream, subProtocol, KeepAliveInterval, ReceiveBufferSize, useZeroMask: UseZeroMask));
}
