public WebSocketRfc6455(Stream clientStream, WebSocketListenerOptions options, IPEndPoint local, IPEndPoint remote, WebSocketHttpRequest httpRequest, IReadOnlyList<IWebSocketMessageExtensionContext> extensions)
{
if (clientStream == null)
throw new ArgumentNullException("clientStream");
if (options == null)
throw new ArgumentNullException("options");
if (local == null)
throw new ArgumentNullException("local");
if (remote == null)
throw new ArgumentNullException("remote");
if (extensions == null)
throw new ArgumentNullException("extensions");
if (httpRequest == null)
throw new ArgumentNullException("httpRequest");
_remoteEndpoint = remote;
_localEndpoint = local;
_httpRequest = httpRequest;
Connection = new WebSocketConnectionRfc6455(clientStream, options);
_extensions = extensions;
}
public void ShouldThrowWhenUnsupportedType()
{
var request = new WebSocketHttpRequest {Headers = {{"Bad", "Request"}}};
Assert.Throws<WebSocketException>(() => HandlerFactory.BuildHandler(request, x => {}, () => {}, x => { }, x => { }, x => { }));
}
public void ShouldReadHeadersFromRequest()
{
const string origin = "http://blah.com/path/to/page";
const string host = "blah.com";
const string path = "/path/to/page";
var clientIp = IPAddress.Parse("127.0.0.1");
const int clientPort = 0;
var request =
new WebSocketHttpRequest
{
Headers =
{
{ "Origin", origin },
{ "Host", host },
},
Path = path
};
var info = WebSocketConnectionInfo.Create(request, clientIp, clientPort);
Assert.AreEqual(origin, info.Origin);
Assert.AreEqual(host, info.Host);
Assert.AreEqual(path, info.Path);
Assert.AreEqual(clientIp, info.ClientIpAddress);
}
public static IHandler Create(WebSocketHttpRequest request)
{
return new ComposableHandler
{
Handshake = sub => FlashSocketPolicyRequestHandler.Handshake(request, sub),
};
}
public void ShouldReadResourceLine()
{
WebSocketHttpRequest request = RequestParser.Parse(ValidRequestArray());
Assert.AreEqual("GET", request.Method);
Assert.AreEqual("/demo", request.Path);
}
public void ShouldHaveId()
{
var request = new WebSocketHttpRequest();
var info = WebSocketConnectionInfo.Create(request, null, 1);
Assert.AreNotEqual(default(Guid), info.Id);
}
public static byte[] Handshake(WebSocketHttpRequest request)
{
FleckLog.Debug("Building Draft76 Response");
var builder = new StringBuilder();
builder.Append("HTTP/1.1 101 WebSocket Protocol Handshake\r\n");
builder.Append("Upgrade: WebSocket\r\n");
builder.Append("Connection: Upgrade\r\n");
builder.AppendFormat("Sec-WebSocket-Origin: {0}\r\n", request["Origin"]);
builder.AppendFormat("Sec-WebSocket-Location: {0}://{1}{2}\r\n", request.Scheme, request["Host"], request.Path);
if (request.Headers.ContainsKey("Sec-WebSocket-Protocol"))
builder.AppendFormat("Sec-WebSocket-Protocol: {0}\r\n", request["Sec-WebSocket-Protocol"]);
builder.Append("\r\n");
var key1 = request["Sec-WebSocket-Key1"];
var key2 = request["Sec-WebSocket-Key2"];
var challenge = new ArraySegment<byte>(request.Bytes, request.Bytes.Length - 8, 8);
var answerBytes = CalculateAnswerBytes(key1, key2, challenge);
byte[] byteResponse = Encoding.ASCII.GetBytes(builder.ToString());
int byteResponseLength = byteResponse.Length;
Array.Resize(ref byteResponse, byteResponseLength + answerBytes.Length);
Array.Copy(answerBytes, 0, byteResponse, byteResponseLength, answerBytes.Length);
return byteResponse;
}
public static byte[] BuildHandshake(WebSocketHttpRequest request, string subProtocol)
{
FleckLog.Debug("Building Hybi-14 Response");
var builder = new StringBuilder();
builder.Append("HTTP/1.1 101 Switching Protocols\r\n");
builder.Append("Upgrade: websocket\r\n");
builder.Append("Connection: Upgrade\r\n");
if (subProtocol != null)
{
builder.AppendFormat("Sec-WebSocket-Protocol: {0}\r\n", subProtocol);
}
var responseKey = CreateResponseKey(request["Sec-WebSocket-Key"]);
builder.AppendFormat("Sec-WebSocket-Accept: {0}\r\n", responseKey);
builder.Append("\r\n");
#if !PORTABLE
return(Encoding.ASCII.GetBytes(builder.ToString()));
#else
return(Encoding.GetEncoding("ISO-8859-1").GetBytes(builder.ToString()));
#endif
}
public static string GetLogin(this WebSocketHttpRequest request)
{
var login = request.Cookies?[LoginField]?.Value;
var sign = request.Cookies?[LoginField + ".sig"]?.Value;
return(GetLogin(login, sign));
}
public void ShouldReadHeadersFromRequest()
{
const string origin = "http://blah.com/path/to/page";
const string host = "blah.com";
const string subprotocol = "Submarine!";
const string path = "/path/to/page";
const string clientIp = "127.0.0.1";
const int clientPort = 0;
var request =
new WebSocketHttpRequest
{
Headers =
{
{ "Origin", origin },
{ "Host", host },
{ "Sec-WebSocket-Protocol", subprotocol }
},
Path = path
};
var info = WebSocketConnectionInfo.Create(request, clientIp, clientPort);
Assert.AreEqual(origin, info.Origin);
Assert.AreEqual(host, info.Host);
Assert.AreEqual(subprotocol, info.SubProtocol);
Assert.AreEqual(path, info.Path);
Assert.AreEqual(clientIp, info.ClientIpAddress);
}
private async Task <bool> CheckHttpHeaders(WebSocketHttpRequest request, WebSocketHttpResponse response)
{
await Task.Run(() =>
{
if (authorization.Length > 0)
{
var authHeader = request.Headers["Authorization"];
if (authHeader == null || authHeader != authorization)
{
response.Status = HttpStatusCode.Unauthorized;
Log("Rejected Authorization header: " + authHeader, LogLevels.Debug);
}
}
for (int i = authorizationHandlers.Count - 1; i >= 0; i--)
{
try
{
if (!(bool)authorizationHandlers[i](request.RemoteEndPoint.ToString(), request.Headers.ToString()))
{
response.Status = HttpStatusCode.Unauthorized;
}
}
catch (Exception e)
{
Log("An error occurred while calling an authentication handler: " + e.Message, LogLevels.Debug);
authorizationHandlers.RemoveAt(i);
}
}
});
return(true);
}
public IWebSocketHttpRequest ParseRequest(HttpRequest websocketRequest, WebSocketMessageType type, byte[] data)
{
var parsed = JsonConvert.DeserializeObject <JsonWebSocketHttpRequest>(Encoding.UTF8.GetString(data));
var request = new WebSocketHttpRequest
{
CommandId = parsed.Id,
ContentType = parsed.ContentType,
Method = parsed.Method,
Path = parsed.Path,
QueryString = parsed.QueryString
};
if (parsed.Content != null)
{
request.Content = Encoding.UTF8.GetBytes(parsed.Content);
}
if (parsed.Headers != null && parsed.Headers.Count > 0)
{
request.Headers =
new Dictionary <string, string[]>(
parsed.Headers.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Split(';')));
}
return(request);
}
public void ShouldProvideAdditionalHeaders()
{
const string origin = "http://blah.com/path/to/page";
const string host = "blah.com";
const string subprotocol = "Submarine!";
const string username = "******";
const string secret = "Secret";
const string clientIp = "127.0.0.1";
const string cookies = "chocolate=yummy; oatmeal=alsoyummy";
const int clientPort = 0;
const string negotiatedSubProtocol = "Negotiated";
var request =
new WebSocketHttpRequest {
Headers =
{
{ "Origin", origin },
{ "Host", host },
{ "Sec-WebSocket-Protocol", subprotocol },
{ "Username", username },
{ "Cookie", cookies }
}
};
var info = WebSocketConnectionInfo.Create(request, clientIp, clientPort, negotiatedSubProtocol);
var headers = info.Headers;
string usernameValue = null;
Assert.IsNotNull(headers);
Assert.AreEqual(5, headers.Count);
Assert.True(headers.TryGetValue("Username", out usernameValue));
Assert.True(usernameValue.Equals(username));
Assert.True(headers.ContainsKey("Cookie"));
}
public static byte[] Handshake(WebSocketHttpRequest request, string subProtocol)
{
FleckLog.Debug("Building Draft76 Response");
Log.Insert(DateTime.Now, "Draft76Handler.cs", string.Format("Building Draft76 Response"), "white");
var builder = new StringBuilder();
builder.Append("HTTP/1.1 101 WebSocket Protocol Handshake\r\n");
builder.Append("Upgrade: WebSocket\r\n");
builder.Append("Connection: Upgrade\r\n");
builder.AppendFormat("Sec-WebSocket-Origin: {0}\r\n", request["Origin"]);
builder.AppendFormat("Sec-WebSocket-Location: {0}://{1}{2}\r\n", request.Scheme, request["Host"], request.Path);
if (subProtocol != null)
{
builder.AppendFormat("Sec-WebSocket-Protocol: {0}\r\n", subProtocol);
}
builder.Append("\r\n");
var key1 = request["Sec-WebSocket-Key1"];
var key2 = request["Sec-WebSocket-Key2"];
var challenge = new ArraySegment <byte>(request.Bytes, request.Bytes.Length - 8, 8);
var answerBytes = CalculateAnswerBytes(key1, key2, challenge);
byte[] byteResponse = Encoding.ASCII.GetBytes(builder.ToString());
int byteResponseLength = byteResponse.Length;
Array.Resize(ref byteResponse, byteResponseLength + answerBytes.Length);
Array.Copy(answerBytes, 0, byteResponse, byteResponseLength, answerBytes.Length);
return(byteResponse);
}
public void Setup()
{
_request = new WebSocketHttpRequest();
_onMessage = delegate { };
_handler = Draft76Handler.Create(_request, s => _onMessage(s));
}
public void Setup()
{
_request = new WebSocketHttpRequest();
_onMessage = delegate { };
_handler = Draft76Handler.Create(_request, s => _onMessage(s));
}
public static IHandler Create(WebSocketHttpRequest request, Action <string> onMessage)
{
return(new ComposableHandler(
textFrame: FrameText,
handshake: sub => Handshake(request, sub),
receiveData: data => ReceiveData(onMessage, data)));
}
public void ShouldReturnHandlerForValidHeaders()
{
var request = new WebSocketHttpRequest {Headers = {{"Sec-WebSocket-Key1", "BLAH"}}};
var handler = HandlerFactory.BuildHandler(request, x => { }, () => { }, x => { }, x => { }, x => { });
Assert.IsNotNull(handler);
}
public void ShouldReadHeadersFromRequest()
{
const string origin = "http://blah.com/path/to/page";
const string host = "blah.com";
const string subprotocol = "Submarine!";
const string path = "/path/to/page";
const string clientIp = "127.0.0.1";
const int clientPort = 0;
const string negotiatedSubProtocol = "Negotiated";
var request =
new WebSocketHttpRequest
{
Headers =
{
{"Origin", origin},
{"Host", host},
{"Sec-WebSocket-Protocol", subprotocol}
},
Path = path
};
var info = WebSocketConnectionInfo.Create(request, clientIp, clientPort, negotiatedSubProtocol);
Assert.AreEqual(origin, info.Origin);
Assert.AreEqual(host, info.Host);
Assert.AreEqual(subprotocol, info.SubProtocol);
Assert.AreEqual(path, info.Path);
Assert.AreEqual(clientIp, info.ClientIpAddress);
Assert.AreEqual(negotiatedSubProtocol, info.NegotiatedSubProtocol);
}
public static IHandler Create(WebSocketHttpRequest request)
{
return(new ComposableHandler
{
Handshake = sub => FlashSocketPolicyRequestHandler.Handshake(request, sub),
});
}
public override WebSocket CreateWebSocket(Stream stream, WebSocketListenerOptions options, IPEndPoint localEndpoint, IPEndPoint remoteEndpoint, WebSocketHttpRequest httpRequest, WebSocketHttpResponse httpResponse, List<IWebSocketMessageExtensionContext> negotiatedExtensions)
{
var webSocket = new WebSocketRfc6455(stream, options, localEndpoint, remoteEndpoint, httpRequest, httpResponse, negotiatedExtensions);
if (OnPingReceived != null)
webSocket.OnPingReceived = OnPingReceived;
return webSocket;
}
public void ShouldThrowWhenUnsupportedType()
{
var request = new WebSocketHttpRequest {
Headers = { { "Bad", "Request" } }
};
Assert.Throws <WebSocketException>(() => HandlerFactory.BuildHandler(request, x => {}, () => {}, x => { }, x => { }, x => { }));
}
public void Setup()
{
_request = new WebSocketHttpRequest();
_onClose = delegate { };
_onMessage = delegate { };
_handler = Hybi13Handler.Create(_request, s => _onMessage(s), () => _onClose());
}
public void Setup()
{
_request = new WebSocketHttpRequest();
_onClose = delegate { };
_onMessage = delegate { };
_handler = Hybi13Handler.Create(_request, s => _onMessage(s), () => _onClose());
}
public void ShouldReadHeaders()
{
WebSocketHttpRequest request = RequestParser.Parse(ValidRequestArray());
Assert.AreEqual("example.com", request.Headers ["Host"]);
Assert.AreEqual("Upgrade", request.Headers ["Connection"]);
Assert.AreEqual("12998 5 Y3 1 .P00", request.Headers ["Sec-WebSocket-Key2"]);
Assert.AreEqual("http://example.com", request.Headers ["Origin"]);
}
public void ShouldReturnHandlerForValidHeaders()
{
var request = new WebSocketHttpRequest {
Headers = { { "Sec-WebSocket-Key1", "BLAH" } }
};
var handler = HandlerFactory.BuildHandler(request, x => { }, () => { }, x => { }, x => { }, x => { });
Assert.IsNotNull(handler);
}
public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage)
{
return new ComposableHandler
{
Frame = Draft76Handler.FrameText,
Handshake = () => Draft76Handler.Handshake(request),
RecieveData = data => RecieveData(onMessage, data)
};
}
public static IHandler Create(WebSocketHttpRequest request, Action <string> onMessage)
{
return(new ComposableHandler
{
TextFrame = Draft76Handler.FrameText,
Handshake = sub => Draft76Handler.Handshake(request, sub),
ReceiveData = data => ReceiveData(onMessage, data)
});
}
public void HeadersShouldBeCaseInsensitive()
{
WebSocketHttpRequest request = RequestParser.Parse(ValidRequestArray());
Assert.IsTrue(request.Headers.ContainsKey("Sec-WebSocket-Protocol"));
Assert.IsTrue(request.Headers.ContainsKey("sec-websocket-protocol"));
Assert.IsTrue(request.Headers.ContainsKey("sec-WEBsocket-protoCOL"));
Assert.IsTrue(request.Headers.ContainsKey("UPGRADE"));
Assert.IsTrue(request.Headers.ContainsKey("CONNectiON"));
}
public VtortolaWebSocketHttpRequest(WebSocketHttpRequest request)
{
mRequestUri = request.RequestUri;
mHttpVersion = request.HttpVersion.ToString();
mCookies = request.Cookies;
mHeaders = ExtractHeaders(request.Headers);
mWebSocketVersion = request.WebSocketVersion;
mWebSocketExtensions =
request.WebSocketExtensions.Select(x => x.Name).ToArray();
mItems = request.Items;
}
public void ShouldReadSecWebSocketOrigin()
{
const string origin = "http://example.com/myPath";
var request =
new WebSocketHttpRequest {
Headers = { { "Sec-WebSocket-Origin", origin } }
};
var info = WebSocketConnectionInfo.Create(request, null, 1, null);
Assert.AreEqual(origin, info.Origin);
}
public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage, Action onClose)
{
var readState = new ReadState();
return new ComposableHandler
{
Handshake = () => Hybi13Handler.BuildHandshake(request),
Frame = s => Hybi13Handler.FrameData(Encoding.UTF8.GetBytes(s), FrameType.Text),
Close = i => Hybi13Handler.FrameData(i.ToBigEndianBytes<ushort>(), FrameType.Close),
RecieveData = d => Hybi13Handler.ReceiveData(d, readState, (op, data) => Hybi13Handler.ProcessFrame(op, data, onMessage, onClose))
};
}
public bool TryNegotiate(WebSocketHttpRequest request, out WebSocketExtension extensionResponse, out IWebSocketMessageExtensionContext context)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
extensionResponse = DefaultResponse;
context = new WebSocketDeflateContext();
return(true);
}
public static IHandler Create(WebSocketHttpRequest request, Action <string> onMessage, Action onClose)
{
var readState = new ReadState();
return(new ComposableHandler
{
Handshake = () => Hybi13Handler.BuildHandshake(request),
Frame = s => Hybi13Handler.FrameData(Encoding.UTF8.GetBytes(s), FrameType.Text),
Close = i => Hybi13Handler.FrameData(i.ToBigEndianBytes <ushort>(), FrameType.Close),
ReceiveData = d => Hybi13Handler.ReceiveData(d, readState, (op, data) => Hybi13Handler.ProcessFrame(op, data, onMessage, onClose))
});
}
public void ShouldReadSecWebSocketOrigin()
{
const string origin = "http://example.com/myPath";
var request =
new WebSocketHttpRequest
{
Headers = { {"Sec-WebSocket-Origin", origin} }
};
var info = WebSocketConnectionInfo.Create(request, null, 1, null);
Assert.AreEqual(origin, info.Origin);
}
public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage, Fleck2Extensions.Action onClose, Action<byte[]> onBinary)
{
var readState = new ReadState();
return new ComposableHandler
{
Handshake = () => BuildHandshake(request),
TextFrame = data => FrameData(Encoding.UTF8.GetBytes(data), FrameType.Text),
BinaryFrame = data => FrameData(data, FrameType.Binary),
CloseFrame = i => FrameData(i.ToBigEndianBytes<ushort>(), FrameType.Close),
ReceiveData = bytes => ReceiveData(bytes, readState, (op, data) => ProcessFrame(op, data, onMessage, onClose, onBinary))
};
}
public void ShouldParseCookies()
{
const string cookie = "chocolate=tasty; cabbage=not so much";
var request =
new WebSocketHttpRequest
{
Headers = { {"Cookie", cookie} }
};
var info = WebSocketConnectionInfo.Create(request, null, 1, null);
Assert.AreEqual(info.Cookies["chocolate"], "tasty");
Assert.AreEqual(info.Cookies["cabbage"], "not so much");
}
public void ShouldParseCookies()
{
const string cookie = "chocolate=tasty; cabbage=not so much";
var request =
new WebSocketHttpRequest {
Headers = { { "Cookie", cookie } }
};
var info = WebSocketConnectionInfo.Create(request, null, 1, null);
Assert.AreEqual(info.Cookies["chocolate"], "tasty");
Assert.AreEqual(info.Cookies["cabbage"], "not so much");
}
public static IHandler Create(WebSocketHttpRequest request, Action <string> onMessage, Fleck2Extensions.Action onClose, Action <byte[]> onBinary)
{
var readState = new ReadState();
return(new ComposableHandler
{
Handshake = () => BuildHandshake(request),
TextFrame = data => FrameData(Encoding.UTF8.GetBytes(data), FrameType.Text),
BinaryFrame = data => FrameData(data, FrameType.Binary),
CloseFrame = i => FrameData(i.ToBigEndianBytes <ushort>(), FrameType.Close),
ReceiveData = bytes => ReceiveData(bytes, readState, (op, data) => ProcessFrame(op, data, onMessage, onClose, onBinary))
});
}
public static IHandler Create(WebSocketHttpRequest request, Action <string> onMessage, Action onClose, Action <byte[]> onBinary, Action <byte[]> onPing, Action <byte[]> onPong)
{
var readState = new ReadState();
return(new ComposableHandler(
handshake: sub => BuildHandshake(request, sub),
textFrame: s => FrameData(Encoding.UTF8.GetBytes(s), FrameType.Text),
binaryFrame: s => FrameData(s, FrameType.Binary),
pingFrame: s => FrameData(s, FrameType.Ping),
pongFrame: s => FrameData(s, FrameType.Pong),
closeFrame: i => FrameData(i.ToBigEndianBytes <ushort>(), FrameType.Close),
receiveData: d => ReceiveData(d, readState, (op, data) => ProcessFrame(op, data, onMessage, onClose, onBinary, onPing, onPong))
));
}
public Hybi13Handler(WebSocketHttpRequest request, IWebSocketConnection connection)
{
_request = request;
_connection = connection;
_data = ArrayPool <byte> .Shared.Rent(1 * 1024 * 1024); // 1 MB read buffer
_dataLen = 0;
_frameType = null;
_message = ArrayPool <byte> .Shared.Rent(1 * 1024 * 1024); // 1 MB message length
_messageLen = 0;
}
public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage, Action onClose, Action<byte[]> onBinary, Action<byte[]> onPing, Action<byte[]> onPong)
{
var readState = new ReadState();
return new ComposableHandler
{
Handshake = sub => Hybi13Handler.BuildHandshake(request, sub),
TextFrame = s => Hybi13Handler.FrameData(Encoding.UTF8.GetBytes(s), FrameType.Text),
BinaryFrame = s => Hybi13Handler.FrameData(s, FrameType.Binary),
PingFrame = s => Hybi13Handler.FrameData(s, FrameType.Ping),
PongFrame = s => Hybi13Handler.FrameData(s, FrameType.Pong),
CloseFrame = i => Hybi13Handler.FrameData(i.ToBigEndianBytes<ushort>(), FrameType.Close),
ReceiveData = d => Hybi13Handler.ReceiveData(d, readState, (op, data) => Hybi13Handler.ProcessFrame(op, data, onMessage, onClose, onBinary, onPing, onPong))
};
}
public static IHandler Create(WebSocketHttpRequest request, Action <string> onMessage, Action onClose, Action <byte[]> onBinary, Action <byte[]> onPing, Action <byte[]> onPong)
{
var readState = new ReadState();
return(new ComposableHandler
{
Handshake = sub => Hybi13Handler.BuildHandshake(request, sub),
TextFrame = s => Hybi13Handler.FrameData(Encoding.UTF8.GetBytes(s), FrameType.Text),
BinaryFrame = s => Hybi13Handler.FrameData(s, FrameType.Binary),
PingFrame = s => Hybi13Handler.FrameData(s, FrameType.Ping),
PongFrame = s => Hybi13Handler.FrameData(s, FrameType.Pong),
CloseFrame = i => Hybi13Handler.FrameData(IntExtensions.ToBigEndianBytes <ushort>(i), FrameType.Close),
ReceiveData = d => Hybi13Handler.ReceiveData(d, readState, (op, data) => Hybi13Handler.ProcessFrame(op, data, onMessage, onClose, onBinary, onPing, onPong))
});
}
public static byte[] BuildHandshake(WebSocketHttpRequest request)
{
FleckLog.Debug("Building Hybi-14 Response");
var builder = new StringBuilder();
builder.Append("HTTP/1.1 101 Switching Protocols\r\n");
builder.Append("Upgrade: websocket\r\n");
builder.Append("Connection: Upgrade\r\n");
var responseKey = CreateResponseKey(request["Sec-WebSocket-Key"]);
builder.AppendFormat("Sec-WebSocket-Accept: {0}\r\n", responseKey);
builder.Append("\r\n");
return Encoding.ASCII.GetBytes(builder.ToString());
}
internal static List <(string key, string value)> Query(this WebSocketHttpRequest request)
{
if (!request.RequestUri.ToString().Contains("?"))
{
return(new List <(string key, string value)>());
}
if (request.RequestUri.ToString().Count(x => x == '?') > 1)
{
throw new Exception("Unexpected query string symbols!");
}
return(request.RequestUri.ToString().Split(new[] { '?' }, StringSplitOptions.RemoveEmptyEntries)[1]
.Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Split(new[] { '=' }, StringSplitOptions.RemoveEmptyEntries))
.Select(x => x.Length == 2 ? CreateDecodedItem(x[0], x[1]) : CreateDecodedItem(x[0]))
.ToList());
}
public WebSocketRfc6455(Stream clientStream, WebSocketListenerOptions options, IPEndPoint local, IPEndPoint remote, WebSocketHttpRequest httpRequest, WebSocketHttpResponse httpResponse, IReadOnlyList<IWebSocketMessageExtensionContext> extensions)
:base(httpRequest, httpResponse)
{
Guard.ParameterCannotBeNull(clientStream, "clientStream");
Guard.ParameterCannotBeNull(options, "options");
Guard.ParameterCannotBeNull(local, "local");
Guard.ParameterCannotBeNull(remote, "remote");
Guard.ParameterCannotBeNull(extensions, "extensions");
Guard.ParameterCannotBeNull(httpRequest, "httpRequest");
_remoteEndpoint = remote;
_localEndpoint = local;
Connection = new WebSocketConnectionRfc6455(clientStream, options);
_extensions = extensions;
}
public static byte[] BuildHandshake(WebSocketHttpRequest request)
{
FleckLog.Debug("Building Hybi-14 Response");
var builder = new StringBuilder();
builder.Append("HTTP/1.1 101 Switching Protocols\r\n");
builder.Append("Upgrade: websocket\r\n");
builder.Append("Connection: Upgrade\r\n");
var responseKey = CreateResponseKey(request["Sec-WebSocket-Key"]);
builder.AppendFormat("Sec-WebSocket-Accept: {0}\r\n", responseKey);
builder.Append("\r\n");
return(Encoding.ASCII.GetBytes(builder.ToString()));
}
public static byte[] BuildHandshake(WebSocketHttpRequest request, string subProtocol)
{
FleckLog.Debug("Building Hybi-14 Response");
var builder = new StringBuilder();
builder.Append("HTTP/1.1 101 Switching Protocols\r\n");
builder.Append("Upgrade: websocket\r\n");
builder.Append("Connection: Upgrade\r\n");
if (subProtocol != null)
builder.AppendFormat("Sec-WebSocket-Protocol: {0}\r\n", subProtocol);
var responseKey = CreateResponseKey(request["Sec-WebSocket-Key"]);
builder.AppendFormat("Sec-WebSocket-Accept: {0}\r\n", responseKey);
builder.Append("\r\n");
#if !PORTABLE
return Encoding.ASCII.GetBytes(builder.ToString());
#else
return Encoding.GetEncoding("ISO-8859-1").GetBytes(builder.ToString());
#endif
}
public void ShouldProvideAdditionalHeaders()
{
const string origin = "http://blah.com/path/to/page";
const string host = "blah.com";
const string subprotocol = "Submarine!";
const string username = "******";
const string secret = "Secret";
const string clientIp = "127.0.0.1";
const string cookies = "chocolate=yummy; oatmeal=alsoyummy";
const int clientPort = 0;
const string negotiatedSubProtocol = "Negotiated";
var request =
new WebSocketHttpRequest
{
Headers =
{
{"Origin", origin},
{"Host", host},
{"Sec-WebSocket-Protocol", subprotocol},
{"Username", username},
{"Cookie", cookies}
}
};
var info = WebSocketConnectionInfo.Create(request, clientIp, clientPort, negotiatedSubProtocol);
var headers = info.Headers;
string usernameValue = null;
Assert.IsNotNull(headers);
Assert.AreEqual(5,headers.Count);
Assert.True(headers.TryGetValue("Username", out usernameValue));
Assert.True(usernameValue.Equals(username));
Assert.True(headers.ContainsKey("Cookie"));
}
/// <summary>
/// Creates a new instance of the <see cref="Hybi00Handler"/>.
/// </summary>
/// <param name="request">The <see cref="WebSocketHttpRequest"/> to handle.</param>
/// <returns>A <see cref="IHandler"/> to perform handling of subsequent requests.</returns>
public static IHandler Create(WebSocketHttpRequest request)
{
return new Hybi00Handler(request);
}
/// <summary>
/// Initializes a new instance of the <see cref="Hybi00Handler"/> class.
/// </summary>
/// <param name="request">The <see cref="WebSocketHttpRequest"/> to handle.</param>
private Hybi00Handler(WebSocketHttpRequest request)
{
this.request = request;
}
public bool TryNegotiate(WebSocketHttpRequest request, out WebSocketExtension extensionResponse, out IWebSocketMessageExtensionContext context)
{
extensionResponse = _response;
context = new WebSocketDeflateContext();
return true;
}
public void ShouldHaveId()
{
var request = new WebSocketHttpRequest();
var info = WebSocketConnectionInfo.Create(request, null, 1, null);
Assert.AreNotEqual(default(Guid), info.Id);
}
/// <summary>
/// Creates a new instance of the handler.
/// </summary>
/// <param name="request">The request to handle.</param>
/// <returns>A <see cref="IHandler"/> to perform handling of subsequent requests.</returns>
public static IHandler Create(WebSocketHttpRequest request)
{
return new Rfc6455Handler(request);
}
/// <summary>
/// Initializes a new instance of the <see cref="Rfc6455Handler"/> class.
/// </summary>
/// <param name="request">The <see cref="WebSocketHttpRequest"/> to handle.</param>
private Rfc6455Handler(WebSocketHttpRequest request)
{
this.request = request;
}
public static byte[] Handshake(WebSocketHttpRequest request, string subProtocol)
{
FleckLog.Debug("Building Flash Socket Policy Response");
return Encoding.UTF8.GetBytes(PolicyResponse);
}
public override WebSocket CreateWebSocket(Stream stream, WebSocketListenerOptions options, IPEndPoint localEndpoint, IPEndPoint remoteEndpoint, WebSocketHttpRequest webSocketHttpRequest, List<IWebSocketMessageExtensionContext> negotiatedExtensions)
{
return new WebSocketRfc6455(stream, options, localEndpoint, remoteEndpoint, webSocketHttpRequest, negotiatedExtensions);
}
public void Setup()
{
_request = new WebSocketHttpRequest();
_handler = FlashSocketPolicyRequestHandler.Create(_request);
}
