public virtual void OnOpenWebSocket()
{
if (WebSocketListener.Server == null || !Settings.Instance.Server.EnableWebSocketRoomInfo)
{
return;
}
var service = WebSocketListener.Server.WebSocketServices[$"/room/{roomId}"];
try
{
RoomInfo roomInfo = GetRoomInfo();
WebSocketPacket packet = new WebSocketPacket(CommandType.GetRoomInfo, roomInfo);
string serialized = JsonConvert.SerializeObject(packet);
service?.Sessions.BroadcastAsync(serialized, null);
if (roomInfo.roomState == RoomState.Preparing)
{
ReadyPlayers readyPlayers = new ReadyPlayers(_readyPlayers.Count, roomClients.Count);
packet = new WebSocketPacket(CommandType.PlayerReady, readyPlayers);
serialized = JsonConvert.SerializeObject(packet);
service?.Sessions.BroadcastAsync(serialized, null);
}
}catch (Exception e)
{
Logger.Instance.Warning("Unable to send RoomInfo to WebSocket client! Exception: " + e);
}
}
protected virtual async Task <uint> Send(WebSocketPacket packet, bool checkIfAuthenticated = true)
{
if (!this.Connected)
{
throw new InvalidOperationException("Client is not connected");
}
if (checkIfAuthenticated && !this.Authenticated)
{
throw new InvalidOperationException("Client is not authenticated");
}
await this.AssignPacketID(packet);
string packetJson = JsonConvert.SerializeObject(packet);
await this.Send(packetJson);
if (this.OnPacketSentOccurred != null)
{
this.OnPacketSentOccurred(this, packet);
}
return(packet.id);
}
private void ReceiveMessageCallback(IAsyncResult Result)
{
ConnectedSocket.EndReceive(Result);
WebSocketFrame CurrentFrame = new WebSocketFrame(ReceiveBuffer, ConnectedSocket);
CurrentFrame.ReceivePayload(ConnectedSocket);
if (CurrentFrame.PayloadOpCode == WebSocketOpCode.ConnectionCloseFrame)
{
ConnectedServer.DisconnectUser(this);
return;
}
if (CurrentPacket == null)
{
CurrentPacket = new WebSocketPacket(CurrentFrame);
}
CurrentPacket.AddFrame(CurrentFrame);
if (CurrentFrame.HeaderFrame.FinalPacket)
{
ConnectedServer.Receive(this, CurrentPacket.Payload, CurrentPacket.PayloadOpCode);
CurrentPacket = null;
GC.Collect();
}
Array.Clear(ReceiveBuffer, 0, ReceiveBuffer.Length);
ConnectedSocket.BeginReceive(ReceiveBuffer, 0, 2, SocketFlags.None, ReceiveMessageCallback, null);
}
//TODO: Implement fragmentationg (add async for this)
private void Send(WebSocketPacket packet)
{
byte[] crlf = new byte[4];
crlf[0] = 0x0D;
crlf[1] = 0x0A;
crlf[2] = 0x0D;
crlf[3] = 0x0A;
using (MemoryStream memoryStream = new MemoryStream())
{
BinaryWriter writer = new BinaryWriter(memoryStream);
writer.Write((byte)(0b1000_0000 | (byte)packet.OpCode));
writer.Write(crlf);
byte masked = (byte)(packet.Masked ? 0b1000_0000 : 0);
if (packet.PayloadLength > short.MaxValue)
{
writer.Write((byte)(masked | 127));
writer.Write(crlf);
writer.Write(IPAddress.HostToNetworkOrder((long)packet.PayloadLength));
writer.Write(crlf);
}
else if (packet.PayloadLength > 125)
{
writer.Write((byte)(masked | 126));
writer.Write(crlf);
writer.Write(IPAddress.HostToNetworkOrder((short)packet.PayloadLength));
writer.Write(crlf);
}
else
{
writer.Write((byte)(masked | (byte)packet.PayloadLength));
writer.Write(crlf);
}
if (packet.PayloadLength > 0)
{
byte[] data = packet.PayloadData;
if (packet.MaskingKey != 0)
{
writer.Write(IPAddress.HostToNetworkOrder(packet.MaskingKey));
writer.Write(crlf);
data = Mask(packet.PayloadData, packet.MaskingKey);
}
memoryStream.Write(data, 0, data.Length);
writer.Write(crlf);
}
stream.Write(memoryStream.ToArray(), 0, (int)memoryStream.Length);
stream.Flush();
}
}
public Token PacketToToken(WebSocketPacket aPacket)
{
var byteArray = aPacket.GetByteArray();
var packetString = WebSocketConvert.BytesToString(byteArray, WebSocketTypeEncoding.UTF8);
var dictionary = JsonConvert.DeserializeObject<Dictionary<string, object>>(packetString);
var dictionaryToken = new DictionaryToken();
dictionaryToken.SetDictionary(dictionary);
return dictionaryToken;
}
private void AssignPacketID(WebSocketPacket packet)
{
// This while loop is to protected from the packet ID wrapping around.
// This is highly unlikely as it would require more than 4 billion packets to be sent.
while (packet.id == 0)
{
packet.id = (uint)Interlocked.Increment(ref currentPacketId);
}
}
public Token PacketToToken(WebSocketPacket aPacket)
{
//DictionaryToken lDicToken = new DictionaryToken();
//JavaScriptSerializer lJavaScriptSerializer = new JavaScriptSerializer();
//Dictionary<string, object> lDic = lJavaScriptSerializer.Deserialize<Dictionary<string, object>>(
// WebSocketConvert.BytesToString(aPacket.GetByteArray(), WebSocketTypeEncoding.ASCII));
//lDicToken.SetDictionary(lDic);
//return lDicToken;
throw new Exception("Not implemented yet");
}
public Token PacketToToken(WebSocketPacket aPacket)
{
//DictionaryToken lDicToken = new DictionaryToken();
//JavaScriptSerializer lJavaScriptSerializer = new JavaScriptSerializer();
//Dictionary<string, object> lDic = lJavaScriptSerializer.Deserialize<Dictionary<string, object>>(
// WebSocketConvert.BytesToString(aPacket.GetByteArray(), WebSocketTypeEncoding.ASCII));
//lDicToken.SetDictionary(lDic);
//return lDicToken;
throw new Exception("Not implemented yet");
}
public Token PacketToToken(WebSocketPacket aPacket)
{
var byteArray = aPacket.GetByteArray();
var packetString = WebSocketConvert.BytesToString(byteArray, WebSocketTypeEncoding.UTF8);
var dictionary = JsonConvert.DeserializeObject <Dictionary <string, object> >(packetString);
var dictionaryToken = new DictionaryToken();
dictionaryToken.SetDictionary(dictionary);
return(dictionaryToken);
}
private void Emit(SportfunCommand command)
{
JObject wsPacket = new WebSocketPacket
{
Type = "game",
LinkId = _linkId,
Body = command
};
Emit("command", wsPacket);
}
private void _httpServer_WSDataReceived(object sender, WebSocketDataReceivedEventArgs args)
{
WebSocketPacket wspacket = args.DataPacket;
if (wspacket.DataType == WSPacketType.Text)
{
string strText = Encoding.UTF8.GetString(wspacket.Data.Array, wspacket.Data.Offset, wspacket.Data.Count);
string strRecv = $"[{args.ClientID}] {strText}\r\n";
ServerRecvText += strRecv;
}
}
public void Send(byte[] data)
{
WebSocketPacket packet = new WebSocketPacket
{
Fin = true,
Masked = maskingKey != 0,
MaskingKey = maskingKey,
OpCode = OpCode.Binary,
PayloadData = data
};
Send(packet);
}
public void Send(string message)
{
WebSocketPacket packet = new WebSocketPacket
{
Fin = true,
Masked = maskingKey != 0,
MaskingKey = maskingKey,
OpCode = OpCode.Text,
PayloadData = Encoding.UTF8.GetBytes(message)
};
Send(packet);
}
private void AssignLatestSequence(WebSocketPacket packet)
{
if (packet is MethodPacket)
{
MethodPacket mPacket = (MethodPacket)packet;
mPacket.seq = this.lastSequenceNumber;
}
else if (packet is ReplyPacket)
{
ReplyPacket rPacket = (ReplyPacket)packet;
rPacket.seq = this.lastSequenceNumber;
}
}
private async Task AssignPacketID(WebSocketPacket packet)
{
if (packet.id == 0)
{
await this.packetIDSemaphore.WaitAsync();
this.randomPacketIDSeed -= 1000;
Random random = new Random(this.randomPacketIDSeed);
packet.id = (uint)random.Next(100, int.MaxValue);
this.packetIDSemaphore.Release();
}
}
public void ProcessOnTextMessage(WebSocketPacket packet)
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
StatusList.Items.Add("Packet received from server.");
var token = _webSocketTokenClient.PacketToToken(packet as WebSocketRawPacket);
if (token.Type.ToUpperInvariant().Equals("WELCOME"))
{
StatusList.Items.Add("welcome message received from server");
return;
}
EchoMessageResult.Text = token.GetString("data");
});
}
public virtual void BroadcastWebSocket(CommandType commandType, object data)
{
if (WebSocketListener.Server == null || !Settings.Instance.Server.EnableWebSocketRoomInfo)
{
return;
}
WebSocketPacket packet = new WebSocketPacket(commandType, data);
string serialized = JsonConvert.SerializeObject(packet);
var service = WebSocketListener.Server.WebSocketServices[$"/room/{roomId}"];
service?.Sessions.BroadcastAsync(serialized, null);
}
/// <summary>
/// Processes a JSON packet received from the server.
/// </summary>
/// <param name="packet">The packet JSON</param>
/// <returns>An awaitable Task</returns>
protected override Task ProcessReceivedPacket(string packet)
{
List <JToken> packetJTokens = new List <JToken>();
JToken packetJToken = JToken.Parse(packet);
if (packetJToken is JArray)
{
foreach (JToken t in (JArray)packetJToken)
{
packetJTokens.Add(t);
}
}
else
{
packetJTokens.Add(packetJToken);
}
foreach (JToken token in packetJTokens)
{
WebSocketPacket webSocketPacket = token.ToObject <WebSocketPacket>();
string data = JSONSerializerHelper.SerializeToString(token);
this.OnPacketReceivedOccurred?.Invoke(this, webSocketPacket);
if (webSocketPacket.type.Equals("method"))
{
MethodPacket methodPacket = JsonConvert.DeserializeObject <MethodPacket>(data);
this.SendSpecificPacket(methodPacket, this.OnMethodOccurred);
}
else if (webSocketPacket.type.Equals("reply"))
{
ReplyPacket replyPacket = JsonConvert.DeserializeObject <ReplyPacket>(data);
if (this.replyIDListeners.ContainsKey(replyPacket.id))
{
this.replyIDListeners[replyPacket.id] = replyPacket;
}
this.SendSpecificPacket(replyPacket, this.OnReplyOccurred);
}
else if (webSocketPacket.type.Equals("event"))
{
EventPacket eventPacket = JsonConvert.DeserializeObject <EventPacket>(data);
this.SendSpecificPacket(eventPacket, this.OnEventOccurred);
}
}
return(Task.FromResult(0));
}
protected void WebSocketClient_OnPacketSentOccurred(object sender, WebSocketPacket e)
{
if (e is MethodPacket)
{
MethodPacket mPacket = (MethodPacket)e;
Logger.Log(string.Format(Environment.NewLine + "WebSocket Method Sent: {0} - {1} - {2} - {3} - {4}" + Environment.NewLine, e.id, e.type, mPacket.method, mPacket.arguments, mPacket.parameters));
}
else if (e is ReplyPacket)
{
ReplyPacket rPacket = (ReplyPacket)e;
Logger.Log(string.Format(Environment.NewLine + "WebSocket Reply Sent: {0} - {1} - {2} - {3} - {4}" + Environment.NewLine, e.id, e.type, rPacket.result, rPacket.error, rPacket.data));
}
else
{
Logger.Log(string.Format(Environment.NewLine + "WebSocket Packet Sent: {0} - {1}" + Environment.NewLine, e.id, e.type));
}
}
public virtual void OnOpenWebSocket()
{
if (WebSocketListener.Server == null || !Settings.Instance.Server.EnableWebSocketRoomInfo)
{
return;
}
var service = WebSocketListener.Server.WebSocketServices[$"/channel/{channelId}"];
try
{
WebSocketPacket packet = new WebSocketPacket(CommandType.GetChannelInfo, channelInfo);
string serialized = JsonConvert.SerializeObject(packet);
service?.Sessions.BroadcastAsync(serialized, null);
}
catch (Exception e)
{
Logger.Instance.Warning("Unable to send ChannelInfo to WebSocket client! Exception: " + e);
}
}
public static void CallWithTimeout(Action<WebSocketPacket> aAction, int aTimeoutMilliseconds, WebSocketPacket lPacket)
{
Thread lThreadToKill = null;
Action lWrappedAction = () =>
{
lThreadToKill = Thread.CurrentThread;
aAction(lPacket);
};
IAsyncResult lResult = lWrappedAction.BeginInvoke(null, null);
if (lResult.AsyncWaitHandle.WaitOne(aTimeoutMilliseconds))
{
lWrappedAction.EndInvoke(lResult);
}
else
{
lThreadToKill.Abort();
throw new TimeoutException("Timeout");
}
}
private async Task <WebSocketPacket> ReadPacketHeaderAsync()
{
WebSocketPacket packet = new WebSocketPacket();
byte flags = await ReadByteAsync();
packet.Fin = (flags & 0b1000_0000) != 0;
packet.OpCode = (OpCode)(flags & 0b0000_1111);
byte lengthByte = await ReadByteAsync();
packet.Masked = (lengthByte & 0b1000_0000) != 0;
lengthByte &= 0b0111_1111;
long length = lengthByte;
if (lengthByte == 127)
{
length = IPAddress.NetworkToHostOrder(await ReadLongAsync());
}
else if (lengthByte == 126)
{
length = IPAddress.NetworkToHostOrder(await ReadShortAsync());
}
packet.PayloadData = new byte[length];
if (packet.Masked)
{
packet.MaskingKey = IPAddress.NetworkToHostOrder(await ReadIntAsync());
}
await ReadBytesAsync(packet.PayloadData, (int)length);
if (packet.Masked)
{
packet.PayloadData = Mask(packet.PayloadData, packet.MaskingKey);
}
return(packet);
}
protected async Task <ReplyPacket> SendAndListen(WebSocketPacket packet, bool checkIfAuthenticated = true)
{
ReplyPacket replyPacket = null;
this.AssignPacketID(packet);
this.replyIDListeners[packet.id] = null;
await this.Send(packet, checkIfAuthenticated);
await this.WaitForResponse(() =>
{
if (this.replyIDListeners.ContainsKey(packet.id) && this.replyIDListeners[packet.id] != null)
{
replyPacket = this.replyIDListeners[packet.id];
return(true);
}
return(false);
});
this.replyIDListeners.Remove(packet.id);
return(replyPacket);
}
public void ProcessOnBinaryMessage(WebSocketPacket aDataPacket)
{
}
public Token PacketToToken(WebSocketPacket aPacket)
{
throw new Exception("Not implemented yet");
}
protected async override Task <uint> Send(WebSocketPacket packet, bool checkIfAuthenticated = true)
{
this.AssignLatestSequence(packet);
return(await base.Send(packet, checkIfAuthenticated));
}
public static IWebSocketPacket protocolToRawPacket(NetworkStream aIS)
{
int lFlags = aIS.ReadByte();
if (lFlags == -1)
{
return(null);
}
byte[] lBuff = new byte[0];
bool lFragmented = false;
if ((lFlags & 0x80) == 0x00)
{
lFragmented = true;
}
bool lMasked = true;
int[] lMask = new int[4];
int lOpcode = lFlags & 0x0F;
WebSocketFrameType lFrameType = (WebSocketFrameType)lOpcode;
if (lFrameType.Equals(WebSocketFrameType.INVALID))
{
throw new WebSocketException(WebSocketMessage.INVALID_FRAME_TYPE);
}
else
{
long lPayloadLen = Read(aIS);
lMasked = (lPayloadLen & 0x80) == 0x80;
lPayloadLen &= 0x7F;
if (lPayloadLen == 126)
{
lPayloadLen = Read(aIS) & 0xFF;
lPayloadLen = (lPayloadLen << 8) ^ (Read(aIS) & 0xFF);
}
else if (lPayloadLen == 127)
{
lPayloadLen = Read(aIS) & 0xFF;
lPayloadLen = (lPayloadLen << 8) ^ (Read(aIS) & 0xFF);
lPayloadLen = (lPayloadLen << 8) ^ (Read(aIS) & 0xFF);
lPayloadLen = (lPayloadLen << 8) ^ (Read(aIS) & 0xFF);
lPayloadLen = (lPayloadLen << 8) ^ (Read(aIS) & 0xFF);
lPayloadLen = (lPayloadLen << 8) ^ (Read(aIS) & 0xFF);
lPayloadLen = (lPayloadLen << 8) ^ (Read(aIS) & 0xFF);
lPayloadLen = (lPayloadLen << 8) ^ (Read(aIS) & 0xFF);
}
if (lMasked)
{
lMask[0] = Read(aIS) & 0xFF;
lMask[1] = Read(aIS) & 0xFF;
lMask[2] = Read(aIS) & 0xFF;
lMask[3] = Read(aIS) & 0xFF;
}
if (lPayloadLen > 0)
{
if (lMasked)
{
int j = 0;
while (lPayloadLen-- > 0)
{
WriteByte(ref lBuff, Convert.ToByte(Read(aIS) ^ lMask[j]));
j++;
j &= 3;
}
}
else
{
while (lPayloadLen-- > 0)
{
WriteByte(ref lBuff, (byte)Read(aIS));
}
}
}
}
IWebSocketPacket lRes = new WebSocketPacket(lFrameType, lBuff);
return(lRes);
}
internal static byte[] RawToProtocolPacket(WebSocketPacket aDataPacket)
{
byte[] lBuff = new byte[2];
WebSocketFrameType lFrameType = aDataPacket.GetFrameType();
int lTargetType = (int)lFrameType;
if (lTargetType.Equals(-1))
throw new WebSocketRuntimeException("Cannot construct a packet with unknown packet type: " + lFrameType);
if (aDataPacket.IsEndFrame())
lBuff[0] = (byte)(lTargetType | 0x80);
else
lBuff[0] = (byte)(lTargetType);
int lPayloadLen = aDataPacket.GetByteArray().Length;
if (lPayloadLen < 126)
lBuff[1] = (byte)(lPayloadLen | 0x80);
else if (lPayloadLen >= 126 && lPayloadLen < 0xFFFF)
{
lBuff[1] = (byte)(126 | 0x80);
int lSize = lBuff.Length;
lBuff = CopyOf(lBuff, lSize + 2);
lBuff[lSize] = (byte)((lPayloadLen >> 8) & 0xFF);
lBuff[lSize + 1] = (byte)(lPayloadLen & 0xFF);
}
else if (lPayloadLen >= 0xFFFF)
{
lBuff[1] = (byte)(127 | 0x80);
long lLen = (long)lPayloadLen;
int lSize = lBuff.Length;
lBuff = CopyOf(lBuff, lSize + 8);
lBuff[lSize] = (byte)(lLen >> 56);
lBuff[lSize + 1] = (byte)(lLen >> 48);
lBuff[lSize + 2] = (byte)(lLen >> 40);
lBuff[lSize + 3] = (byte)(lLen >> 32);
lBuff[lSize + 4] = (byte)(lLen >> 24);
lBuff[lSize + 5] = (byte)(lLen >> 16);
lBuff[lSize + 6] = (byte)(lLen >> 8);
lBuff[lSize + 7] = (byte)lLen;
}
int lSizes = lBuff.Length;
lBuff = CopyOf(lBuff, lSizes + 4);
lBuff[lSizes] = (byte)mRan.Next(0, 255);
lBuff[lSizes + 1] = (byte)mRan.Next(0, 255);
lBuff[lSizes + 2] = (byte)mRan.Next(0, 255);
lBuff[lSizes + 3] = (byte)mRan.Next(0, 255);
byte[] lMask = new byte[4];
Array.Copy(lBuff, lBuff.Length - 4, lMask, 0, 4);
byte[] lBuffData = new byte[aDataPacket.GetByteArray().Length];
Array.Copy(aDataPacket.GetByteArray(), 0, lBuffData, 0, lBuffData.Length);
byte[] lMaskedData = new byte[lBuffData.Length];
int lPos = 0;
for (int i = 0; i < lBuffData.Length; i++)
{
lMaskedData[i] = (byte)Convert.ToInt32(lBuffData[i] ^ lMask[lPos]);
if (lPos == 3)
lPos = 0;
else
lPos++;
}
lBuff = CopyOf(lBuff, lBuff.Length + lMaskedData.Length);
Array.Copy(lMaskedData, 0, lBuff, lBuff.Length - lMaskedData.Length, lMaskedData.Length);
return lBuff;
}
public void ProcessOnFragment(WebSocketPacket aFragment, int aIndex, int aTotal)
{
}
public static void CallWithTimeout(Action <WebSocketPacket> aAction, int aTimeoutMilliseconds, WebSocketPacket lPacket)
{
Thread lThreadToKill = null;
Action lWrappedAction = () =>
{
lThreadToKill = Thread.CurrentThread;
aAction(lPacket);
};
IAsyncResult lResult = lWrappedAction.BeginInvoke(null, null);
if (lResult.AsyncWaitHandle.WaitOne(aTimeoutMilliseconds))
{
lWrappedAction.EndInvoke(lResult);
}
else
{
lThreadToKill.Abort();
throw new TimeoutException("Timeout");
}
}
protected async Task <T> SendAndListen <T>(WebSocketPacket packet, bool checkIfAuthenticated = true)
{
ReplyPacket reply = await this.SendAndListen(packet);
return(this.GetSpecificReplyResultValue <T>(reply));
}
public static byte[] RawToProtocolPacket(WebSocketPacket aDataPacket)
{
byte[] lBuff = new byte[2];
WebSocketFrameType lFrameType = aDataPacket.GetFrameType();
int lTargetType = (int)lFrameType;
if (lTargetType.Equals(-1))
{
throw new WebSocketRuntimeException("Cannot construct a packet with unknown packet type: " + lFrameType);
}
if (aDataPacket.IsEndFrame())
{
lBuff[0] = (byte)(lTargetType | 0x80);
}
else
{
lBuff[0] = (byte)(lTargetType);
}
int lPayloadLen = aDataPacket.GetByteArray().Length;
if (lPayloadLen < 126)
{
lBuff[1] = (byte)(lPayloadLen | 0x80);
}
else if (lPayloadLen >= 126 && lPayloadLen < 0xFFFF)
{
lBuff[1] = (byte)(126 | 0x80);
int lSize = lBuff.Length;
lBuff = CopyOf(lBuff, lSize + 2);
lBuff[lSize] = (byte)((lPayloadLen >> 8) & 0xFF);
lBuff[lSize + 1] = (byte)(lPayloadLen & 0xFF);
}
else if (lPayloadLen >= 0xFFFF)
{
lBuff[1] = (byte)(127 | 0x80);
long lLen = (long)lPayloadLen;
int lSize = lBuff.Length;
lBuff = CopyOf(lBuff, lSize + 8);
lBuff[lSize] = (byte)(lLen >> 56);
lBuff[lSize + 1] = (byte)(lLen >> 48);
lBuff[lSize + 2] = (byte)(lLen >> 40);
lBuff[lSize + 3] = (byte)(lLen >> 32);
lBuff[lSize + 4] = (byte)(lLen >> 24);
lBuff[lSize + 5] = (byte)(lLen >> 16);
lBuff[lSize + 6] = (byte)(lLen >> 8);
lBuff[lSize + 7] = (byte)lLen;
}
int lSizes = lBuff.Length;
lBuff = CopyOf(lBuff, lSizes + 4);
lBuff[lSizes] = (byte)mRan.Next(0, 255);
lBuff[lSizes + 1] = (byte)mRan.Next(0, 255);
lBuff[lSizes + 2] = (byte)mRan.Next(0, 255);
lBuff[lSizes + 3] = (byte)mRan.Next(0, 255);
byte[] lMask = new byte[4];
Array.Copy(lBuff, lBuff.Length - 4, lMask, 0, 4);
byte[] lBuffData = new byte[aDataPacket.GetByteArray().Length];
Array.Copy(aDataPacket.GetByteArray(), 0, lBuffData, 0, lBuffData.Length);
byte[] lMaskedData = new byte[lBuffData.Length];
int lPos = 0;
for (int i = 0; i < lBuffData.Length; i++)
{
lMaskedData[i] = (byte)Convert.ToInt32(lBuffData[i] ^ lMask[lPos]);
if (lPos == 3)
{
lPos = 0;
}
else
{
lPos++;
}
}
lBuff = CopyOf(lBuff, lBuff.Length + lMaskedData.Length);
Array.Copy(lMaskedData, 0, lBuff, lBuff.Length - lMaskedData.Length, lMaskedData.Length);
return(lBuff);
}
public Token PacketToToken(WebSocketPacket aPacket)
{
throw new Exception("Not implemented yet");
}
