public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
//Close handshake was sent from client side, now got a handshake response
if (session.State == WebSocketState.Closing)
{
//Not NormalClosure
if (commandInfo.CloseStatusCode != session.ProtocolProcessor.CloseStatusCode.NormalClosure &&
(commandInfo.CloseStatusCode > 0 || !string.IsNullOrEmpty(commandInfo.Text)))
{
session.FireError(new Exception(string.Format("{0}: {1}", commandInfo.CloseStatusCode, commandInfo.Text)));
}
session.CloseWithouHandshake();
return;
}
//Got server side closing handshake request, send response now
var statusCode = commandInfo.CloseStatusCode;
if (statusCode <= 0)
{
statusCode = session.ProtocolProcessor.CloseStatusCode.NoStatusCode;
}
session.Close(statusCode, commandInfo.Text);
}
public override bool VerifyHandshake(WebSocket websocket, WebSocketCommandInfo handshakeInfo, out string description)
{
var challenge = handshakeInfo.Data;
if (challenge.Length != challenge.Length)
{
description = m_Error_ChallengeLengthNotMatch;
return(false);
}
for (var i = 0; i < m_ExpectedChallenge.Length; i++)
{
if (challenge[i] != m_ExpectedChallenge[i])
{
description = m_Error_ChallengeNotMatch;
return(false);
}
}
if (!handshakeInfo.Text.ParseMimeHeader(websocket.Items))
{
description = m_Error_InvalidHandshake;
return(false);
}
description = string.Empty;
return(true);
}
public override bool VerifyHandshake(WebSocket websocket, WebSocketCommandInfo handshakeInfo, out string description)
{
byte[] data = handshakeInfo.Data;
if (data.Length != data.Length)
{
description = "challenge length doesn't match";
return(false);
}
for (int i = 0; i < m_ExpectedChallenge.Length; i++)
{
if (data[i] != m_ExpectedChallenge[i])
{
description = "challenge doesn't match";
return(false);
}
}
string verbLine = string.Empty;
if (!handshakeInfo.Text.ParseMimeHeader(websocket.Items, out verbLine))
{
description = "invalid handshake";
return(false);
}
if (!ValidateVerbLine(verbLine))
{
description = verbLine;
return(false);
}
description = string.Empty;
return(true);
}
public StringCommandInfo ParseSubCommand(WebSocketCommandInfo commandInfo)
{
var cmd = commandInfo.Data.Trim();
int pos = cmd.IndexOf(' ');
string name;
string param;
if (pos > 0)
{
name = cmd.Substring(0, pos);
param = cmd.Substring(pos + 1);
}
else
{
name = cmd;
param = string.Empty;
}
string[] paramArray;
if (!string.IsNullOrEmpty(param))
{
paramArray = param.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
}
else
{
paramArray = new string[0];
}
return new StringCommandInfo(name, param, paramArray);
}
public override bool VerifyHandshake(WebSocket websocket, WebSocketCommandInfo handshakeInfo, out string description)
{
var challenge = handshakeInfo.Data;
if (challenge.Length != challenge.Length)
{
description = m_Error_ChallengeLengthNotMatch;
return false;
}
for (var i = 0; i < m_ExpectedChallenge.Length; i++)
{
if (challenge[i] != m_ExpectedChallenge[i])
{
description = m_Error_ChallengeNotMatch;
return false;
}
}
if (!handshakeInfo.Text.ParseMimeHeader(websocket.Items))
{
description = m_Error_InvalidHandshake;
return false;
}
description = string.Empty;
return true;
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
var dict = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
var verbLine = string.Empty;
commandInfo.Text.ParseMimeHeader(dict, out verbLine);
string websocketVersion = dict.GetValue(m_WebSocketVersion, string.Empty);
if (!session.NotSpecifiedVersion)
{
if (string.IsNullOrEmpty(websocketVersion))
{
session.FireError(new Exception("the server doesn't support the websocket protocol version your client was using"));
}
else
{
session.FireError(new Exception(string.Format("the server(version: {0}) doesn't support the websocket protocol version your client was using", websocketVersion)));
}
session.CloseWithoutHandshake();
return;
}
if (string.IsNullOrEmpty(websocketVersion))
{
session.FireError(new Exception("unknown server protocol version"));
session.CloseWithoutHandshake();
return;
}
var versions = websocketVersion.Split(m_ValueSeparator, StringSplitOptions.RemoveEmptyEntries);
var versionValues = new int[versions.Length];
for (var i = 0; i < versions.Length; i++)
{
int value;
if (!int.TryParse(versions[i], out value))
{
session.FireError(new Exception("invalid websocket version"));
session.CloseWithoutHandshake();
return;
}
versionValues[i] = value;
}
if (!session.GetAvailableProcessor(versionValues))
{
session.FireError(new Exception("unknown server protocol version"));
session.CloseWithoutHandshake();
return;
}
session.ProtocolProcessor.SendHandshake(session);
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
var dict = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
commandInfo.Text.ParseMimeHeader(dict);
string websocketVersion = dict.GetValue(m_WebSocketVersion, string.Empty);
if (!session.NotSpecifiedVersion)
{
if (string.IsNullOrEmpty(websocketVersion))
session.FireError(new Exception("the server doesn't support the websocket protocol version your client was using"));
else
session.FireError(new Exception(string.Format("the server(version: {0}) doesn't support the websocket protocol version your client was using", websocketVersion)));
session.CloseWithoutHandshake();
return;
}
if (string.IsNullOrEmpty(websocketVersion))
{
session.FireError(new Exception("unknown server protocol version"));
session.CloseWithoutHandshake();
return;
}
var versions = websocketVersion.Split(',');
versions = versions.Where((x) => x.Trim().Length > 0).ToArray();
var versionValues = new int[versions.Length];
for (var i = 0; i < versions.Length; i++)
{
try
{
int value = int.Parse(versions[i]);
versionValues[i] = value;
}
catch (FormatException)
{
session.FireError(new Exception("invalid websocket version"));
session.CloseWithoutHandshake();
return;
}
}
if (!session.GetAvailableProcessor(versionValues))
{
session.FireError(new Exception("unknown server protocol version"));
session.CloseWithoutHandshake();
return;
}
session.ProtocolProcessor.SendHandshake(session);
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
if (!session.ProtocolProcessor.VerifyHandshake(session, commandInfo, out var description))
{
session.FireError(new Exception(description));
session.Close((int)CloseStatusCode.ProtocolError, description);
return;
}
session.OnHandshaked();
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
string description;
if (!session.ProtocolProcessor.VerifyHandshake(session, commandInfo, out description))
{
session.Close(session.ProtocolProcessor.CloseStatusCode.ProtocolError, description);
return;
}
session.OnHandshaked();
}
// Token: 0x0600068F RID: 1679 RVA: 0x0001ABAC File Offset: 0x00018DAC
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
string text;
if (!session.ProtocolProcessor.VerifyHandshake(session, commandInfo, out text))
{
session.FireError(new Exception(text));
session.Close((int)session.ProtocolProcessor.CloseStatusCode.ProtocolError, text);
return;
}
session.OnHandshaked();
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
string description;
if (!session.ProtocolProcessor.VerifyHandshake(session, commandInfo, out description))
{
session.Close(session.ProtocolProcessor.CloseStatusCode.ProtocolError, description);
return;
}
session.OnHandshaked();
}
// sends data
void socketServer_CommandHandler(WebSocketSession session, WebSocketCommandInfo commandInfo)
{
int? value = (int.Parse(commandInfo.Data.ToString()));
ThermoTemps temp = commService.GetTemperatures(value);
System.Web.Script.Serialization.JavaScriptSerializer oSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
string sJSON = oSerializer.Serialize(temp);
SendToAll(session.Cookies["name"] + ": " + sJSON);
// SendToAll(session.Cookies["name"] + ": " + commService.ReverseCommunication(commandInfo.Data));
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
var dict = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
var verbLine = string.Empty;
commandInfo.Text.ParseMimeHeader(dict, out verbLine);
string websocketVersion = dict.GetValue(m_WebSocketVersion, string.Empty);
if (!session.NotSpecifiedVersion)
{
if (string.IsNullOrEmpty(websocketVersion))
session.FireError(new Exception("the server doesn't support the websocket protocol version your client was using"));
else
session.FireError(new Exception(string.Format("the server(version: {0}) doesn't support the websocket protocol version your client was using", websocketVersion)));
session.CloseWithoutHandshake();
return;
}
if (string.IsNullOrEmpty(websocketVersion))
{
session.FireError(new Exception("unknown server protocol version"));
session.CloseWithoutHandshake();
return;
}
var versions = websocketVersion.Split(m_ValueSeparator, StringSplitOptions.RemoveEmptyEntries);
var versionValues = new int[versions.Length];
for (var i = 0; i < versions.Length; i++)
{
int value;
if (!int.TryParse(versions[i], out value))
{
session.FireError(new Exception("invalid websocket version"));
session.CloseWithoutHandshake();
return;
}
versionValues[i] = value;
}
if (!session.GetAvailableProcessor(versionValues))
{
session.FireError(new Exception("unknown server protocol version"));
session.CloseWithoutHandshake();
return;
}
session.ProtocolProcessor.SendHandshake(session);
}
// Token: 0x060005BD RID: 1469 RVA: 0x00019544 File Offset: 0x00017744
public override WebSocketCommandInfo GetCommandInfo(byte[] readBuffer, int offset, int length, out int left)
{
WebSocketCommandInfo commandInfo = base.GetCommandInfo(readBuffer, offset, length, out left);
if (commandInfo == null)
{
return(null);
}
if (!HandshakeReader.BadRequestCode.Equals(commandInfo.Key))
{
base.NextCommandReader = new DraftHybi10DataReader();
}
return(commandInfo);
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
Dictionary <string, object> valueContainer = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
string verbLine = string.Empty;
commandInfo.Text.ParseMimeHeader(valueContainer, out verbLine);
string value = valueContainer.GetValue("Sec-WebSocket-Version", string.Empty);
if (!session.NotSpecifiedVersion)
{
if (string.IsNullOrEmpty(value))
{
session.FireError(new Exception("the server doesn't support the websocket protocol version your client was using"));
}
else
{
session.FireError(new Exception($"the server(version: {value}) doesn't support the websocket protocol version your client was using"));
}
session.CloseWithoutHandshake();
return;
}
if (string.IsNullOrEmpty(value))
{
session.FireError(new Exception("unknown server protocol version"));
session.CloseWithoutHandshake();
return;
}
string[] array = value.Split(m_ValueSeparator, StringSplitOptions.RemoveEmptyEntries);
int[] array2 = new int[array.Length];
for (int i = 0; i < array.Length; i++)
{
if (!int.TryParse(array[i], out int result))
{
session.FireError(new Exception("invalid websocket version"));
session.CloseWithoutHandshake();
return;
}
array2[i] = result;
}
if (!session.GetAvailableProcessor(array2))
{
session.FireError(new Exception("unknown server protocol version"));
session.CloseWithoutHandshake();
}
else
{
session.ProtocolProcessor.SendHandshake(session);
}
}
// Token: 0x0600068C RID: 1676 RVA: 0x0001AB4C File Offset: 0x00018D4C
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
if (session.StateCode == 2)
{
session.CloseWithoutHandshake();
return;
}
short num = commandInfo.CloseStatusCode;
if (num <= 0)
{
num = session.ProtocolProcessor.CloseStatusCode.NoStatusCode;
}
session.Close((int)num, commandInfo.Text);
}
public override bool VerifyHandshake(WebSocket websocket, WebSocketCommandInfo handshakeInfo, out string description)
{
var handshake = handshakeInfo.Text;
if (string.IsNullOrEmpty(handshake))
{
description = m_Error_InvalidHandshake;
return(false);
}
var verbLine = string.Empty;
if (!handshakeInfo.Text.ParseMimeHeader(websocket.Items, out verbLine))
{
description = m_Error_InvalidHandshake;
return(false);
}
if (!ValidateVerbLine(verbLine))
{
description = verbLine;
return(false);
}
if (!string.IsNullOrEmpty(websocket.SubProtocol))
{
var protocol = websocket.Items.GetValue("Sec-WebSocket-Protocol", string.Empty);
if (!websocket.SubProtocol.Equals(protocol, StringComparison.OrdinalIgnoreCase))
{
description = m_Error_SubProtocolNotMatch;
return(false);
}
}
var acceptKey = websocket.Items.GetValue("Sec-WebSocket-Accept", string.Empty);
var expectedAcceptKey = websocket.Items.GetValue(m_ExpectedAcceptKey, string.Empty);
if (!expectedAcceptKey.Equals(acceptKey, StringComparison.OrdinalIgnoreCase))
{
description = m_Error_AcceptKeyNotMatch;
return(false);
}
//more validations
description = string.Empty;
return(true);
}
public override bool VerifyHandshake(
WebSocket websocket,
WebSocketCommandInfo handshakeInfo,
out string description)
{
if (string.IsNullOrEmpty(handshakeInfo.Text))
{
description = "invalid handshake";
return(false);
}
string verbLine = string.Empty;
if (!handshakeInfo.Text.ParseMimeHeader(websocket.Items, out verbLine))
{
description = "invalid handshake";
return(false);
}
if (!this.ValidateVerbLine(verbLine))
{
description = verbLine;
return(false);
}
if (!string.IsNullOrEmpty(websocket.SubProtocol))
{
string str = websocket.Items.GetValue <string> ("Sec-WebSocket-Protocol", string.Empty);
if (!websocket.SubProtocol.Equals(str, StringComparison.OrdinalIgnoreCase))
{
description = "subprotocol doesn't match";
return(false);
}
}
string str1 = websocket.Items.GetValue <string> ("Sec-WebSocket-Accept", string.Empty);
if (!websocket.Items.GetValue <string> (this.m_ExpectedAcceptKey, string.Empty)
.Equals(str1, StringComparison.OrdinalIgnoreCase))
{
description = "accept key doesn't match";
return(false);
}
description = string.Empty;
return(true);
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
//Close handshake was sent from client side, now got a handshake response
if (session.StateCode == WebSocketStateConst.Closing)
{
session.CloseWithoutHandshake();
return;
}
//Got server side closing handshake request, send response now
var statusCode = commandInfo.CloseStatusCode;
if (statusCode <= 0)
statusCode = session.ProtocolProcessor.CloseStatusCode.NoStatusCode;
session.Close(statusCode, commandInfo.Text);
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
//Close handshake was sent from client side, now got a handshake response
if (session.StateCode == WebSocketStateConst.Closing)
{
session.CloseWithoutHandshake();
return;
}
//Got server side closing handshake request, send response now
var statusCode = commandInfo.CloseStatusCode;
if (statusCode <= 0)
{
statusCode = session.ProtocolProcessor.CloseStatusCode.NoStatusCode;
}
session.Close(statusCode, commandInfo.Text);
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
var dict = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
commandInfo.Text.ParseMimeHeader(dict, out _);
var websocketVersion = dict.GetValue(m_WebSocketVersion, string.Empty);
if (string.IsNullOrEmpty(websocketVersion))
{
session.FireError(new Exception("unknown server protocol version"));
session.CloseWithoutHandshake();
return;
}
var versions = websocketVersion.Split(m_ValueSeparator, StringSplitOptions.RemoveEmptyEntries);
var versionValues = new int[versions.Length];
for (var i = 0; i < versions.Length; i++)
{
if (!int.TryParse(versions[i], out var value))
{
session.FireError(new Exception("invalid websocket version"));
session.CloseWithoutHandshake();
return;
}
versionValues[i] = value;
}
if (!versionValues.Contains(13))
{
session.FireError(new Exception("unknown server protocol version"));
session.CloseWithoutHandshake();
return;
}
session.ProtocolProcessor.SendHandshake(session);
}
public override void ExecuteCommand (WebSocket session, WebSocketCommandInfo commandInfo) {
Dictionary<string, object> valueContainer =
new Dictionary<string, object> ((IEqualityComparer<string>) StringComparer.OrdinalIgnoreCase);
string verbLine = string.Empty;
commandInfo.Text.ParseMimeHeader ((IDictionary<string, object>) valueContainer, out verbLine);
string str = valueContainer.GetValue<string> ("Sec-WebSocket-Version", string.Empty);
if (!session.NotSpecifiedVersion) {
if (string.IsNullOrEmpty (str))
session.FireError (
new Exception ("the server doesn't support the websocket protocol version your client was using"));
else
session.FireError (new Exception (string.Format (
"the server(version: {0}) doesn't support the websocket protocol version your client was using",
(object) str)));
session.CloseWithoutHandshake ();
} else if (string.IsNullOrEmpty (str)) {
session.FireError (new Exception ("unknown server protocol version"));
session.CloseWithoutHandshake ();
} else {
string[] strArray = str.Split (BadRequest.m_ValueSeparator, StringSplitOptions.RemoveEmptyEntries);
int[] availableVersions = new int[strArray.Length];
for (int index = 0; index < strArray.Length; ++index) {
int result;
if (!int.TryParse (strArray[index], out result)) {
session.FireError (new Exception ("invalid websocket version"));
session.CloseWithoutHandshake ();
return;
}
availableVersions[index] = result;
}
if (!session.GetAvailableProcessor (availableVersions)) {
session.FireError (new Exception ("unknown server protocol version"));
session.CloseWithoutHandshake ();
} else
session.ProtocolProcessor.SendHandshake (session);
}
}
public override WebSocketCommandInfo FindCommand(SocketContext context, byte[] readBuffer, int offset, int length, bool isReusableBuffer)
{
AddArraySegment(readBuffer, offset, length, isReusableBuffer);
if (m_StartPos < 0)
{
m_StartPos = BufferSegments.IndexOf(WebSocketConstant.StartByte);
if (m_StartPos < 0)
{
//Continue to read following bytes to seek start pos
NextCommandReader = this;
return null;
}
}
int endPos = BufferSegments.IndexOf(WebSocketConstant.EndByte, m_StartPos, BufferSegments.Count - m_StartPos);
if (endPos < 0)
{
//Continue to search end byte
NextCommandReader = this;
return null;
}
var commandInfo = new WebSocketCommandInfo(Encoding.UTF8.GetString(BufferSegments.ToArrayData(m_StartPos + 1, endPos - m_StartPos - 1)));
BufferSegments.ClearSegements();
int left = BufferSegments.Count - endPos - 1;
if (left > 0)
AddArraySegment(readBuffer, offset + length - left, left, isReusableBuffer);
m_StartPos = -1;
NextCommandReader = this;
return commandInfo;
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
//Close handshake was sent from client side, now got a handshake response
if (session.State == WebSocketState.Closing)
{
//Not NormalClosure
if (commandInfo.CloseStatusCode != session.ProtocolProcessor.CloseStatusCode.NormalClosure &&
(commandInfo.CloseStatusCode > 0 || !string.IsNullOrEmpty(commandInfo.Text)))
{
session.FireError(new Exception(string.Format("{0}: {1}", commandInfo.CloseStatusCode, commandInfo.Text)));
}
session.CloseWithouHandshake();
return;
}
//Got server side closing handshake request, send response now
var statusCode = commandInfo.CloseStatusCode;
if (statusCode <= 0)
statusCode = session.ProtocolProcessor.CloseStatusCode.NoStatusCode;
session.Close(statusCode, commandInfo.Text);
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
session.FireMessageReceived(commandInfo.Text);
}
void m_WebSocketServer_CommandHandler(WebSocketSession session, WebSocketCommandInfo commandInfo)
{
Console.WriteLine("Server:" + commandInfo.Data);
session.SendResponse(commandInfo.Data);
}
public override WebSocketCommandInfo GetCommandInfo(byte[] readBuffer, int offset, int length, out int left)
{
//haven't receive handshake header
if (m_ReceivedChallengeLength < 0)
{
var commandInfo = base.GetCommandInfo(readBuffer, offset, length, out left);
if (commandInfo == null)
{
return(null);
}
//Bad request
if (BadRequestCode.Equals(commandInfo.Key))
{
return(commandInfo);
}
m_ReceivedChallengeLength = 0;
m_HandshakeCommand = commandInfo;
var challengeOffset = offset + length - left;
if (left < m_ExpectedChallengeLength)
{
if (left > 0)
{
Buffer.BlockCopy(readBuffer, challengeOffset, m_Challenges, 0, left);
m_ReceivedChallengeLength = left;
left = 0;
}
return(null);
}
else if (left == m_ExpectedChallengeLength)
{
Buffer.BlockCopy(readBuffer, challengeOffset, m_Challenges, 0, left);
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
left = 0;
return(m_HandshakeCommand);
}
else
{
Buffer.BlockCopy(readBuffer, challengeOffset, m_Challenges, 0, m_ExpectedChallengeLength);
left -= m_ExpectedChallengeLength;
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
return(m_HandshakeCommand);
}
}
else
{
int receivedTotal = m_ReceivedChallengeLength + length;
if (receivedTotal < m_ExpectedChallengeLength)
{
Buffer.BlockCopy(readBuffer, offset, m_Challenges, m_ReceivedChallengeLength, length);
left = 0;
m_ReceivedChallengeLength = receivedTotal;
return(null);
}
else if (receivedTotal == m_ExpectedChallengeLength)
{
Buffer.BlockCopy(readBuffer, offset, m_Challenges, m_ReceivedChallengeLength, length);
left = 0;
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
return(m_HandshakeCommand);
}
else
{
var parsedLen = m_ExpectedChallengeLength - m_ReceivedChallengeLength;
Buffer.BlockCopy(readBuffer, offset, m_Challenges, m_ReceivedChallengeLength, parsedLen);
left = length - parsedLen;
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
return(m_HandshakeCommand);
}
}
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
session.LastActiveTime = DateTime.Now;
session.ProtocolProcessor.SendPong(session, commandInfo.Text);
}
public override WebSocketCommandInfo GetCommandInfo(byte[] readBuffer, int offset, int length, out int left)
{
left = 0;
int num = 0;
if (!m_Type.HasValue)
{
byte value = readBuffer[offset];
num = 1;
m_Type = value;
}
if ((m_Type.Value & 0x80) == 0)
{
byte b = byte.MaxValue;
for (int i = offset + num; i < offset + length; i++)
{
if (readBuffer[i] == b)
{
left = length - (i - offset + 1);
if (base.BufferSegments.Count <= 0)
{
WebSocketCommandInfo result = new WebSocketCommandInfo(1.ToString(), Encoding.UTF8.GetString(readBuffer, offset + num, i - offset - num));
Reset(clearBuffer: false);
return(result);
}
base.BufferSegments.AddSegment(readBuffer, offset + num, i - offset - num, toBeCopied: false);
WebSocketCommandInfo result2 = new WebSocketCommandInfo(1.ToString(), base.BufferSegments.Decode(Encoding.UTF8));
Reset(clearBuffer: true);
return(result2);
}
}
AddArraySegment(readBuffer, offset + num, length - num);
return(null);
}
while (!m_Length.HasValue)
{
if (length <= num)
{
return(null);
}
byte b2 = readBuffer[num];
if (b2 == 0 && m_Type.Value == byte.MaxValue)
{
WebSocketCommandInfo result3 = new WebSocketCommandInfo(8.ToString());
Reset(clearBuffer: true);
return(result3);
}
int num2 = b2 & 0x7F;
m_TempLength = m_TempLength * 128 + num2;
num++;
if ((b2 & 0x80) != 128)
{
m_Length = m_TempLength;
break;
}
}
int num3 = m_Length.Value - base.BufferSegments.Count;
int num4 = length - num;
if (num4 < num3)
{
AddArraySegment(readBuffer, num, length - num);
return(null);
}
left = num4 - num3;
if (base.BufferSegments.Count <= 0)
{
WebSocketCommandInfo result4 = new WebSocketCommandInfo(1.ToString(), Encoding.UTF8.GetString(readBuffer, offset + num, num3));
Reset(clearBuffer: false);
return(result4);
}
base.BufferSegments.AddSegment(readBuffer, offset + num, num3, toBeCopied: false);
WebSocketCommandInfo result5 = new WebSocketCommandInfo(base.BufferSegments.Decode(Encoding.UTF8));
Reset(clearBuffer: true);
return(result5);
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
session.FireMessageReceived(commandInfo.Text);
}
public abstract bool VerifyHandshake(WebSocket websocket, WebSocketCommandInfo handshakeInfo, out string description);
public override WebSocketCommandInfo GetCommandInfo(
byte[] readBuffer,
int offset,
int length,
out int left)
{
left = 0;
int offset1 = 0;
if (!this.m_Type.HasValue)
{
byte num = readBuffer[offset];
offset1 = 1;
this.m_Type = new byte?(num);
}
if (((int)this.m_Type.Value & 128) == 0)
{
byte maxValue = byte.MaxValue;
for (int index = offset + offset1; index < offset + length; ++index)
{
if ((int)readBuffer[index] == (int)maxValue)
{
left = length - (index - offset + 1);
if (this.BufferSegments.Count <= 0)
{
WebSocketCommandInfo socketCommandInfo = new WebSocketCommandInfo(1.ToString (),
Encoding.UTF8.GetString(readBuffer, offset + offset1, index - offset - offset1));
this.Reset(false);
return(socketCommandInfo);
}
this.BufferSegments.AddSegment(readBuffer, offset + offset1, index - offset - offset1, false);
WebSocketCommandInfo socketCommandInfo1 =
new WebSocketCommandInfo(1.ToString (), this.BufferSegments.Decode(Encoding.UTF8));
this.Reset(true);
return(socketCommandInfo1);
}
}
this.AddArraySegment(readBuffer, offset + offset1, length - offset1);
return((WebSocketCommandInfo)null);
}
while (!this.m_Length.HasValue)
{
if (length <= offset1)
{
return((WebSocketCommandInfo)null);
}
byte num = readBuffer[offset1];
if (num == (byte)0 && this.m_Type.Value == byte.MaxValue)
{
WebSocketCommandInfo socketCommandInfo = new WebSocketCommandInfo(8.ToString ());
this.Reset(true);
return(socketCommandInfo);
}
this.m_TempLength = this.m_TempLength * 128 + ((int)num & (int)sbyte.MaxValue);
++offset1;
if (((int)num & 128) != 128)
{
this.m_Length = new int?(this.m_TempLength);
break;
}
}
int num1 = this.m_Length.Value - this.BufferSegments.Count;
int num2 = length - offset1;
if (num2 < num1)
{
this.AddArraySegment(readBuffer, offset1, length - offset1);
return((WebSocketCommandInfo)null);
}
left = num2 - num1;
if (this.BufferSegments.Count <= 0)
{
WebSocketCommandInfo socketCommandInfo = new WebSocketCommandInfo(1.ToString (),
Encoding.UTF8.GetString(readBuffer, offset + offset1, num1));
this.Reset(false);
return(socketCommandInfo);
}
this.BufferSegments.AddSegment(readBuffer, offset + offset1, num1, false);
WebSocketCommandInfo socketCommandInfo2 = new WebSocketCommandInfo(this.BufferSegments.Decode(Encoding.UTF8));
this.Reset(true);
return(socketCommandInfo2);
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
session.LastActiveTime = DateTime.Now;
session.LastPongResponse = commandInfo.Text;
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
session.LastActiveTime = DateTime.Now;
session.ProtocolProcessor.SendPong(session, commandInfo.Text);
}
public override WebSocketCommandInfo GetCommandInfo(byte[] readBuffer, int offset, int length, out int left)
{
//haven't receive handshake header
if (m_ReceivedChallengeLength < 0)
{
var commandInfo = base.GetCommandInfo(readBuffer, offset, length, out left);
if (commandInfo == null)
return null;
//Bad request
if (BadRequestCode.Equals(commandInfo.Key))
return commandInfo;
m_ReceivedChallengeLength = 0;
m_HandshakeCommand = commandInfo;
var challengeOffset = offset + length - left;
if (left < m_ExpectedChallengeLength)
{
if (left > 0)
{
Buffer.BlockCopy(readBuffer, challengeOffset, m_Challenges, 0, left);
m_ReceivedChallengeLength = left;
left = 0;
}
return null;
}
else if (left == m_ExpectedChallengeLength)
{
Buffer.BlockCopy(readBuffer, challengeOffset, m_Challenges, 0, left);
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
left = 0;
return m_HandshakeCommand;
}
else
{
Buffer.BlockCopy(readBuffer, challengeOffset, m_Challenges, 0, m_ExpectedChallengeLength);
left -= m_ExpectedChallengeLength;
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
return m_HandshakeCommand;
}
}
else
{
int receivedTotal = m_ReceivedChallengeLength + length;
if (receivedTotal < m_ExpectedChallengeLength)
{
Buffer.BlockCopy(readBuffer, offset, m_Challenges, m_ReceivedChallengeLength, length);
left = 0;
m_ReceivedChallengeLength = receivedTotal;
return null;
}
else if (receivedTotal == m_ExpectedChallengeLength)
{
Buffer.BlockCopy(readBuffer, offset, m_Challenges, m_ReceivedChallengeLength, length);
left = 0;
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
return m_HandshakeCommand;
}
else
{
var parsedLen = m_ExpectedChallengeLength - m_ReceivedChallengeLength;
Buffer.BlockCopy(readBuffer, offset, m_Challenges, m_ReceivedChallengeLength, parsedLen);
left = length - parsedLen;
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
return m_HandshakeCommand;
}
}
}
void socketServer_CommandHandler(WebSocketSession session, WebSocketCommandInfo commandInfo)
{
lock (m_SessionSyncRoot)
{
string messageType = GetTypeFromMessage(commandInfo.Data);
string message = buildJSONMessage(GetDataFromMessage(commandInfo.Data), messageType, session);
List<string> messages = ApplicationData.Data as List<string>;
if (messages == null)
{
messages = new List<string>();
ApplicationData.Data = messages;
}
messages.Add(message);
ApplicationData.Data = messages;
SendToAll(message);
}
}
public override WebSocketCommandInfo GetCommandInfo(
byte[] readBuffer,
int offset,
int length,
out int left)
{
if (this.m_ReceivedChallengeLength < 0)
{
WebSocketCommandInfo commandInfo = base.GetCommandInfo(readBuffer, offset, length, out left);
if (commandInfo == null)
{
return((WebSocketCommandInfo)null);
}
if (HandshakeReader.BadRequestCode.Equals(commandInfo.Key))
{
return(commandInfo);
}
this.m_ReceivedChallengeLength = 0;
this.m_HandshakeCommand = commandInfo;
int srcOffset = offset + length - left;
if (left < this.m_ExpectedChallengeLength)
{
if (left > 0)
{
Buffer.BlockCopy((Array)readBuffer, srcOffset, (Array)this.m_Challenges, 0, left);
this.m_ReceivedChallengeLength = left;
left = 0;
}
return((WebSocketCommandInfo)null);
}
if (left == this.m_ExpectedChallengeLength)
{
Buffer.BlockCopy((Array)readBuffer, srcOffset, (Array)this.m_Challenges, 0, left);
this.SetDataReader();
this.m_HandshakeCommand.Data = this.m_Challenges;
left = 0;
return(this.m_HandshakeCommand);
}
Buffer.BlockCopy((Array)readBuffer, srcOffset, (Array)this.m_Challenges, 0, this.m_ExpectedChallengeLength);
left -= this.m_ExpectedChallengeLength;
this.SetDataReader();
this.m_HandshakeCommand.Data = this.m_Challenges;
return(this.m_HandshakeCommand);
}
int num = this.m_ReceivedChallengeLength + length;
if (num < this.m_ExpectedChallengeLength)
{
Buffer.BlockCopy((Array)readBuffer, offset, (Array)this.m_Challenges, this.m_ReceivedChallengeLength,
length);
left = 0;
this.m_ReceivedChallengeLength = num;
return((WebSocketCommandInfo)null);
}
if (num == this.m_ExpectedChallengeLength)
{
Buffer.BlockCopy((Array)readBuffer, offset, (Array)this.m_Challenges, this.m_ReceivedChallengeLength,
length);
left = 0;
this.SetDataReader();
this.m_HandshakeCommand.Data = this.m_Challenges;
return(this.m_HandshakeCommand);
}
int count = this.m_ExpectedChallengeLength - this.m_ReceivedChallengeLength;
Buffer.BlockCopy((Array)readBuffer, offset, (Array)this.m_Challenges, this.m_ReceivedChallengeLength, count);
left = length - count;
this.SetDataReader();
this.m_HandshakeCommand.Data = this.m_Challenges;
return(this.m_HandshakeCommand);
}
public override bool VerifyHandshake(WebSocket websocket, WebSocketCommandInfo handshakeInfo, out string description)
{
var handshake = handshakeInfo.Text;
if (string.IsNullOrEmpty(handshake))
{
description = m_Error_InvalidHandshake;
return false;
}
if (!handshakeInfo.Text.ParseMimeHeader(websocket.Items))
{
description = m_Error_InvalidHandshake;
return false;
}
if (!string.IsNullOrEmpty(websocket.SubProtocol))
{
var protocol = websocket.Items.GetValue("Sec-WebSocket-Protocol", string.Empty);
if (!websocket.SubProtocol.Equals(protocol, StringComparison.OrdinalIgnoreCase))
{
description = m_Error_SubProtocolNotMatch;
return false;
}
}
var acceptKey = websocket.Items.GetValue("Sec-WebSocket-Accept", string.Empty);
var expectedAcceptKey = websocket.Items.GetValue(m_ExpectedAcceptKey, string.Empty);
if (!expectedAcceptKey.Equals(acceptKey, StringComparison.OrdinalIgnoreCase))
{
description = m_Error_AcceptKeyNotMatch;
return false;
}
//more validations
description = string.Empty;
return true;
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
session.FireDataReceived(commandInfo.Data);
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
session.FireDataReceived(commandInfo.Data);
}
// Token: 0x0600059E RID: 1438 RVA: 0x00018A48 File Offset: 0x00016C48
public override WebSocketCommandInfo GetCommandInfo(byte[] readBuffer, int offset, int length, out int left)
{
left = 0;
int num = 0;
if (this.m_Type == null)
{
byte value = readBuffer[offset];
num = 1;
this.m_Type = new byte?(value);
}
if ((this.m_Type.Value & 128) == 0)
{
byte maxValue = byte.MaxValue;
int i = offset + num;
while (i < offset + length)
{
if (readBuffer[i] == maxValue)
{
left = length - (i - offset + 1);
if (base.BufferSegments.Count <= 0)
{
WebSocketCommandInfo result = new WebSocketCommandInfo(1.ToString(), Encoding.UTF8.GetString(readBuffer, offset + num, i - offset - num));
this.Reset(false);
return(result);
}
base.BufferSegments.AddSegment(readBuffer, offset + num, i - offset - num, false);
WebSocketCommandInfo result2 = new WebSocketCommandInfo(1.ToString(), base.BufferSegments.Decode(Encoding.UTF8));
this.Reset(true);
return(result2);
}
else
{
i++;
}
}
base.AddArraySegment(readBuffer, offset + num, length - num);
return(null);
}
while (this.m_Length == null)
{
if (length <= num)
{
return(null);
}
byte b = readBuffer[num];
if (b == 0 && this.m_Type.Value == 255)
{
WebSocketCommandInfo result3 = new WebSocketCommandInfo(8.ToString());
this.Reset(true);
return(result3);
}
int num2 = (int)(b & 127);
this.m_TempLength = this.m_TempLength * 128 + num2;
num++;
if ((b & 128) != 128)
{
this.m_Length = new int?(this.m_TempLength);
break;
}
}
int num3 = this.m_Length.Value - base.BufferSegments.Count;
int num4 = length - num;
if (num4 < num3)
{
base.AddArraySegment(readBuffer, num, length - num);
return(null);
}
left = num4 - num3;
if (base.BufferSegments.Count <= 0)
{
WebSocketCommandInfo result4 = new WebSocketCommandInfo(1.ToString(), Encoding.UTF8.GetString(readBuffer, offset + num, num3));
this.Reset(false);
return(result4);
}
base.BufferSegments.AddSegment(readBuffer, offset + num, num3, false);
WebSocketCommandInfo result5 = new WebSocketCommandInfo(base.BufferSegments.Decode(Encoding.UTF8));
this.Reset(true);
return(result5);
}
public override WebSocketCommandInfo GetCommandInfo(byte[] readBuffer, int offset, int length, out int left)
{
if (m_ReceivedChallengeLength < 0)
{
WebSocketCommandInfo commandInfo = base.GetCommandInfo(readBuffer, offset, length, out left);
if (commandInfo == null)
{
return(null);
}
if (HandshakeReader.BadRequestCode.Equals(commandInfo.Key))
{
return(commandInfo);
}
m_ReceivedChallengeLength = 0;
m_HandshakeCommand = commandInfo;
int srcOffset = offset + length - left;
if (left < m_ExpectedChallengeLength)
{
if (left > 0)
{
Buffer.BlockCopy(readBuffer, srcOffset, m_Challenges, 0, left);
m_ReceivedChallengeLength = left;
left = 0;
}
return(null);
}
if (left == m_ExpectedChallengeLength)
{
Buffer.BlockCopy(readBuffer, srcOffset, m_Challenges, 0, left);
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
left = 0;
return(m_HandshakeCommand);
}
Buffer.BlockCopy(readBuffer, srcOffset, m_Challenges, 0, m_ExpectedChallengeLength);
left -= m_ExpectedChallengeLength;
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
return(m_HandshakeCommand);
}
int num = m_ReceivedChallengeLength + length;
if (num < m_ExpectedChallengeLength)
{
Buffer.BlockCopy(readBuffer, offset, m_Challenges, m_ReceivedChallengeLength, length);
left = 0;
m_ReceivedChallengeLength = num;
return(null);
}
if (num == m_ExpectedChallengeLength)
{
Buffer.BlockCopy(readBuffer, offset, m_Challenges, m_ReceivedChallengeLength, length);
left = 0;
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
return(m_HandshakeCommand);
}
int num2 = m_ExpectedChallengeLength - m_ReceivedChallengeLength;
Buffer.BlockCopy(readBuffer, offset, m_Challenges, m_ReceivedChallengeLength, num2);
left = length - num2;
SetDataReader();
m_HandshakeCommand.Data = m_Challenges;
return(m_HandshakeCommand);
}
public override WebSocketCommandInfo GetCommandInfo(byte[] readBuffer, int offset, int length, out int left)
{
left = 0;
var skipByteCount = 0;
if (!m_Type.HasValue)
{
byte startByte = readBuffer[offset];
skipByteCount = 1;
m_Type = startByte;
}
//0xxxxxxx: Collect protocol data by end mark
if ((m_Type.Value & 0x80) == 0x00)
{
byte lookForByte = 0xFF;
int i;
for (i = offset + skipByteCount; i < offset + length; i++)
{
if (readBuffer[i] == lookForByte)
{
left = length - (i - offset + 1);
if (BufferSegments.Count <= 0)
{
var commandInfo = new WebSocketCommandInfo(OpCode.Text.ToString(), Encoding.UTF8.GetString(readBuffer, offset + skipByteCount, i - offset - skipByteCount));
Reset(false);
return commandInfo;
}
else
{
this.BufferSegments.AddSegment(readBuffer, offset + skipByteCount, i - offset - skipByteCount, false);
var commandInfo = new WebSocketCommandInfo(OpCode.Text.ToString(), BufferSegments.Decode(Encoding.UTF8));
Reset(true);
return commandInfo;
}
}
}
this.AddArraySegment(readBuffer, offset + skipByteCount, length - skipByteCount);
return null;
}
else//10000000: Collect protocol data by length
{
while (!m_Length.HasValue)
{
if (length <= skipByteCount)
{
//No data to read
return null;
}
byte lengthByte = readBuffer[skipByteCount];
//Closing handshake
if (lengthByte == 0x00 && m_Type.Value == m_ClosingHandshakeType)
{
var commandInfo = new WebSocketCommandInfo(OpCode.Close.ToString());
Reset(true);
return commandInfo;
}
int thisLength = (int)(lengthByte & 0x7F);
m_TempLength = m_TempLength * 128 + thisLength;
skipByteCount++;
if ((lengthByte & 0x80) != 0x80)
{
m_Length = m_TempLength;
break;
}
}
int requiredSize = m_Length.Value - BufferSegments.Count;
int leftSize = length - skipByteCount;
if (leftSize < requiredSize)
{
this.AddArraySegment(readBuffer, skipByteCount, length - skipByteCount);
return null;
}
else
{
left = leftSize - requiredSize;
if (BufferSegments.Count <= 0)
{
var commandInfo = new WebSocketCommandInfo(OpCode.Text.ToString(), Encoding.UTF8.GetString(readBuffer, offset + skipByteCount, requiredSize));
Reset(false);
return commandInfo;
}
else
{
this.BufferSegments.AddSegment(readBuffer, offset + skipByteCount, requiredSize, false);
var commandInfo = new WebSocketCommandInfo(BufferSegments.Decode(Encoding.UTF8));
Reset(true);
return commandInfo;
}
}
}
}
public abstract bool VerifyHandshake(WebSocket websocket, WebSocketCommandInfo handshakeInfo, out string description);
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
session.LastActiveTime = DateTime.Now;
session.LastPongResponse = commandInfo.Text;
}
public override WebSocketCommandInfo GetCommandInfo(byte[] readBuffer, int offset, int length, out int left)
{
left = 0;
var skipByteCount = 0;
if (!m_Type.HasValue)
{
byte startByte = readBuffer[offset];
skipByteCount = 1;
m_Type = startByte;
}
//0xxxxxxx: Collect protocol data by end mark
if ((m_Type.Value & 0x80) == 0x00)
{
byte lookForByte = 0xFF;
int i;
for (i = offset + skipByteCount; i < offset + length; i++)
{
if (readBuffer[i] == lookForByte)
{
left = length - (i - offset + 1);
if (BufferSegments.Count <= 0)
{
var commandInfo = new WebSocketCommandInfo(OpCode.Text.ToString(), Encoding.UTF8.GetString(readBuffer, offset + skipByteCount, i - offset - skipByteCount));
Reset(false);
return(commandInfo);
}
else
{
this.BufferSegments.AddSegment(readBuffer, offset + skipByteCount, i - offset - skipByteCount, false);
var commandInfo = new WebSocketCommandInfo(OpCode.Text.ToString(), BufferSegments.Decode(Encoding.UTF8));
Reset(true);
return(commandInfo);
}
}
}
this.AddArraySegment(readBuffer, offset + skipByteCount, length - skipByteCount);
return(null);
}
else //10000000: Collect protocol data by length
{
while (!m_Length.HasValue)
{
if (length <= skipByteCount)
{
//No data to read
return(null);
}
byte lengthByte = readBuffer[skipByteCount];
//Closing handshake
if (lengthByte == 0x00 && m_Type.Value == m_ClosingHandshakeType)
{
var commandInfo = new WebSocketCommandInfo(OpCode.Close.ToString());
Reset(true);
return(commandInfo);
}
int thisLength = (int)(lengthByte & 0x7F);
m_TempLength = m_TempLength * 128 + thisLength;
skipByteCount++;
if ((lengthByte & 0x80) != 0x80)
{
m_Length = m_TempLength;
break;
}
}
int requiredSize = m_Length.Value - BufferSegments.Count;
int leftSize = length - skipByteCount;
if (leftSize < requiredSize)
{
this.AddArraySegment(readBuffer, skipByteCount, length - skipByteCount);
return(null);
}
else
{
left = leftSize - requiredSize;
if (BufferSegments.Count <= 0)
{
var commandInfo = new WebSocketCommandInfo(OpCode.Text.ToString(), Encoding.UTF8.GetString(readBuffer, offset + skipByteCount, requiredSize));
Reset(false);
return(commandInfo);
}
else
{
this.BufferSegments.AddSegment(readBuffer, offset + skipByteCount, requiredSize, false);
var commandInfo = new WebSocketCommandInfo(BufferSegments.Decode(Encoding.UTF8));
Reset(true);
return(commandInfo);
}
}
}
}
