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) { 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); }