// 接收消息 private void MessageReceived(NetworkingPlayer player, Text frame, NetWorker sender) { try { JSONNode data = JSONNode.Parse(frame.ToString()); if (data["register"] != null) { Register(player, data["register"]); } else if (data["update"] != null) { Update(player, data["update"]); } else if (data["get"] != null) { Get(player, data["get"]); } } catch { // Ignore the message and disocnnect the requester server.Disconnect(player, true); } }
/// <summary> /// Disconnects Client /// </summary> /// <param name="client"></param> public void DisconnectClient(uint client) { try { myTcpServer.Disconnect(client); Debug.Console(2, this, Debug.ErrorLogLevel.Notice, "Disconnected client index: {0}", client); } catch (Exception ex) { Debug.Console(2, this, Debug.ErrorLogLevel.Error, "Error Disconnecting client index: {0}. Error: {1}", client, ex); } }
/// <summary> /// Secure Received Data Async Callback /// </summary> /// <param name="mySecureTCPServer"></param> /// <param name="clientIndex"></param> /// <param name="numberOfBytesReceived"></param> void TcpServerReceivedDataAsyncCallback(TCPServer myTCPServer, uint clientIndex, int numberOfBytesReceived) { if (numberOfBytesReceived > 0) { string received = "Nothing"; try { byte[] bytes = myTCPServer.GetIncomingDataBufferForSpecificClient(clientIndex); received = System.Text.Encoding.GetEncoding(28591).GetString(bytes, 0, numberOfBytesReceived); if (WaitingForSharedKey.Contains(clientIndex)) { received = received.Replace("\r", ""); received = received.Replace("\n", ""); if (received != SharedKey) { byte[] b = Encoding.GetEncoding(28591).GetBytes("Shared key did not match server. Disconnecting"); Debug.Console(1, this, Debug.ErrorLogLevel.Warning, "Client at index {0} Shared key did not match the server, disconnecting client. Key: {1}", clientIndex, received); myTCPServer.SendData(clientIndex, b, b.Length); myTCPServer.Disconnect(clientIndex); return; } WaitingForSharedKey.Remove(clientIndex); byte[] success = Encoding.GetEncoding(28591).GetBytes("Shared Key Match"); myTCPServer.SendDataAsync(clientIndex, success, success.Length, null); OnServerClientReadyForCommunications(clientIndex); Debug.Console(1, this, Debug.ErrorLogLevel.Notice, "Client with index {0} provided the shared key and successfully connected to the server", clientIndex); } else if (!string.IsNullOrEmpty(checkHeartbeat(clientIndex, received))) { onTextReceived(received, clientIndex); } } catch (Exception ex) { Debug.Console(2, this, Debug.ErrorLogLevel.Error, "Error Receiving data: {0}. Error: {1}", received, ex); } if (myTCPServer.GetServerSocketStatusForSpecificClient(clientIndex) == SocketStatus.SOCKET_STATUS_CONNECTED) { myTCPServer.ReceiveDataAsync(clientIndex, TcpServerReceivedDataAsyncCallback); } } else { // If numberOfBytesReceived <= 0 myTCPServer.Disconnect(); } }
public void ServerDataReceivedCallback(TCPServer server, uint clientIndex, int bytesReceived) { if (bytesReceived <= 0) { CrestronConsole.PrintLine("ServerDataReceivedCallback error: server's connection with client " + clientIndex + " has been closed."); server.Disconnect(clientIndex); // A connection has closed, so another client may connect if the server stopped listening // due to the maximum number of clients connecting if ((server.State & ServerState.SERVER_NOT_LISTENING) > 0) { server.WaitForConnectionAsync(ServerConnectedCallback); } } else { CrestronConsole.PrintLine("\n------ incoming message -----------"); byte[] recvd_bytes = new byte[bytesReceived]; // Copy the received bytes into a local buffer so that they can be echoed back. // Do not pass the reference to the incoming data buffer itself to the SendDataAsync method Array.Copy(server.GetIncomingDataBufferForSpecificClient(clientIndex), recvd_bytes, bytesReceived); // The server in this example expects ASCII text from the client, but any other encoding is possible string recvd_msg = ASCIIEncoding.ASCII.GetString(recvd_bytes, 0, bytesReceived); CrestronConsole.PrintLine("Client " + clientIndex + " says: " + recvd_msg + "\r\nEchoing back to client " + clientIndex + "..."); // echo the received message back to the client who sent it server.SendDataAsync(clientIndex, recvd_bytes, recvd_bytes.Length, ServerDataSentCallback); // Begin waiting for another message from that same client server.ReceiveDataAsync(clientIndex, ServerDataReceivedCallback); CrestronConsole.PrintLine("---------- end of message ----------"); } }
private void SocketOnSocketStatusChange(TCPServer myTcpServer, uint clientIndex, SocketStatus serverSocketStatus) { if (_connections == null) { _connections = new Dictionary <uint, SocketStatus>(); } CloudLog.Debug("{0} Connection Status for ClientIndex {1}, {2}", GetType().Name, clientIndex, serverSocketStatus); _connections[clientIndex] = serverSocketStatus; if (serverSocketStatus != SocketStatus.SOCKET_STATUS_CONNECTED) { return; } if (_threads == null) { _threads = new Dictionary <uint, Thread>(); } if (!_threads.ContainsKey(clientIndex) || _threads[clientIndex].ThreadState != Thread.eThreadStates.ThreadRunning) { try { _threads[clientIndex] = new Thread(ReceiveHandler, clientIndex) { Name = string.Format("{0} Rx Handler for client index {1}", GetType().Name, clientIndex), Priority = Thread.eThreadPriority.HighPriority }; } catch (Exception e) { CloudLog.Exception(e, "Error starting RX Handler thread for client index {0}", clientIndex); _socket.Disconnect(clientIndex); } } }
/// <summary> /// Unsecure Received Data Async Callback /// </summary> /// <param name="myTCPServer"></param> /// <param name="clientIndex"></param> /// <param name="numberOfBytesReceived"></param> void UnsecureReceivedDataAsyncCallback(TCPServer myTCPServer, uint clientIndex, int numberOfBytesReceived) { if (numberOfBytesReceived > 0) { string received = "Nothing"; byte[] bytes = myTCPServer.GetIncomingDataBufferForSpecificClient(clientIndex); received = System.Text.Encoding.GetEncoding(28591).GetString(bytes, 0, numberOfBytesReceived); if (WaitingForSharedKey.Contains(clientIndex)) { received = received.Replace("\r", ""); received = received.Replace("\n", ""); if (received != SharedKey) { byte[] b = Encoding.GetEncoding(28591).GetBytes("Shared key did not match server. Disconnecting"); Debug.Console(2, "Client at index {0} Shared key did not match the server, disconnecting client", clientIndex); ErrorLog.Error("Client at index {0} Shared key did not match the server, disconnecting client", clientIndex); myTCPServer.SendDataAsync(clientIndex, b, b.Length, null); myTCPServer.Disconnect(clientIndex); } if (myTCPServer.NumberOfClientsConnected > 0) { myTCPServer.ReceiveDataAsync(UnsecureReceivedDataAsyncCallback); } WaitingForSharedKey.Remove(clientIndex); byte[] skResponse = Encoding.GetEncoding(28591).GetBytes("Shared Key Match, Connected and ready for communication"); myTCPServer.SendDataAsync(clientIndex, skResponse, skResponse.Length, null); myTCPServer.ReceiveDataAsync(UnsecureReceivedDataAsyncCallback); } else { myTCPServer.ReceiveDataAsync(UnsecureReceivedDataAsyncCallback); Debug.Console(2, "Secure Server Listening on Port: {0}, client IP: {1}, NumberOfBytesReceived: {2}, Received: {3}\r\n", myTCPServer.PortNumber, myTCPServer.GetAddressServerAcceptedConnectionFromForSpecificClient(clientIndex), numberOfBytesReceived, received); onTextReceived(received); } checkHeartbeat(clientIndex, received); } if (myTCPServer.GetServerSocketStatusForSpecificClient(clientIndex) == SocketStatus.SOCKET_STATUS_CONNECTED) { myTCPServer.ReceiveDataAsync(clientIndex, UnsecureReceivedDataAsyncCallback); } }
void HeartbeatTimer_CallbackFunction(object o) { uint clientIndex = (uint)o; string address = Secure ? SecureServer.GetAddressServerAcceptedConnectionFromForSpecificClient(clientIndex) : UnsecureServer.GetAddressServerAcceptedConnectionFromForSpecificClient(clientIndex); ErrorLog.Error("Heartbeat not received for Client at IP: {0}, DISCONNECTING BECAUSE HEARTBEAT REQUIRED IS TRUE", address); Debug.Console(2, "Heartbeat not received for Client at IP: {0}, DISCONNECTING BECAUSE HEARTBEAT REQUIRED IS TRUE", address); SendTextToClient("Heartbeat not received by server, closing connection", clientIndex); if (Secure) { SecureServer.Disconnect(clientIndex); } else { UnsecureServer.Disconnect(clientIndex); } HeartbeatTimerDictionary.Remove(clientIndex); }
/// <summary> /// The callback for receiving data from the insecure server client. /// </summary> /// <param name="server">The server the callback is executed on.</param> /// <param name="clientIndex">The index of the client data is received from.</param> /// <param name="count">The number of bytes of data received.</param> private void ReceiveDataCallback(TCPServer server, uint clientIndex, int count) { if (count <= 0) { if (server.ClientConnected(clientIndex)) { server.ReceiveDataAsync(clientIndex, ReceiveDataCallback); } return; } var dataBuffer = server.GetIncomingDataBufferForSpecificClient(clientIndex); var data = Encoding.UTF8.GetString(dataBuffer, 0, count); if (Regex.IsMatch(data, "^GET", RegexOptions.IgnoreCase)) { var key = Regex.Match(data, "Sec-WebSocket-Key: (.*)").Groups[1].Value.Trim(); key = key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; byte[] keySha1 = Crestron.SimplSharp.Cryptography.SHA1.Create().ComputeHash(Encoding.UTF8.GetBytes(key)); string sha64 = Convert.ToBase64String(keySha1); var responseMessage = "HTTP/1.1 101 Switching Protocols\r\n" + "Connection: Upgrade\r\n" + "Upgrade: websocket\r\n" + "Sec-WebSocket-Accept: " + sha64 + "\r\n\r\n"; this.Send(responseMessage, clientIndex, false); } else { CrestronConsole.PrintLine("Received '{0}' bytes.", count); bool fin = (dataBuffer[0] & 128) != 0; bool mask = (dataBuffer[1] & 128) != 0; int opcode = dataBuffer[0] & 15; ulong dataLength = (ulong)(dataBuffer[1] - 128); ulong offset = 2; if (opcode == 0x0) { CrestronConsole.PrintLine("Received continuation frame opcode."); } else if (opcode == 0x1) { CrestronConsole.PrintLine("Received text frame opcode."); } else if (opcode == 0x2) { CrestronConsole.PrintLine("Received binary frame opcode."); } else if (opcode >= 0x3 && opcode <= 0x7) { CrestronConsole.PrintLine("Received reserved non-control opcode."); } else if (opcode == 0x8) { this.Send(new byte[] { BitConverter.GetBytes(0x88)[0], BitConverter.GetBytes(0x00)[0] }, clientIndex, false); server.Disconnect(clientIndex); CrestronConsole.PrintLine("Received disconnect OpCode. Disconnected."); return; } else if (opcode == 0x9) { this.Send(new byte[] { BitConverter.GetBytes(0x8A)[0], BitConverter.GetBytes(0x00)[0] }, clientIndex, false); CrestronConsole.PrintLine("Received Ping and sent a Pong."); if (server.ClientConnected(clientIndex)) { server.ReceiveDataAsync(clientIndex, ReceiveDataCallback); } return; } else if (opcode == 0xA) { CrestronConsole.PrintLine("Received Pong."); if (server.ClientConnected(clientIndex)) { server.ReceiveDataAsync(clientIndex, ReceiveDataCallback); } return; } else if (opcode >= 0xB && opcode <= 0xF) { CrestronConsole.PrintLine("Received reserved control frame opcode."); } if (dataLength == 126) { CrestronConsole.PrintLine("Data length is 126."); dataLength = BitConverter.ToUInt16(new byte[] { dataBuffer[3], dataBuffer[2] }, 0); offset = 4; } else if (dataLength == 127) { CrestronConsole.PrintLine("Data length is 127."); dataLength = BitConverter.ToUInt64(new byte[] { dataBuffer[9], dataBuffer[8], dataBuffer[7], dataBuffer[6], dataBuffer[5], dataBuffer[4], dataBuffer[3], dataBuffer[2] }, 0); offset = 10; } if (dataLength == 0) { CrestronConsole.PrintLine("Data length was zero."); this.Send(string.Format("{0}>", InitialParametersClass.ControllerPromptName), clientIndex, true); } else if (mask) { byte[] de = new byte[dataLength]; byte[] mk = new byte[4] { dataBuffer[offset], dataBuffer[offset + 1], dataBuffer[offset + 2], dataBuffer[offset + 3] }; offset += 4; for (ulong i = 0; i < dataLength; i++) { de[i] = (byte)(dataBuffer[offset + i] ^ mk[i % 4]); } var text = Encoding.UTF8.GetString(de, 0, de.Length); var dr = DataReceived; if (dr != null) { dr.Invoke(text, clientIndex); } } else { CrestronConsole.PrintLine("Data length was '{0}', but mask bit not set. Invalid message received.", dataLength); } } if (server.ClientConnected(clientIndex)) { server.ReceiveDataAsync(clientIndex, ReceiveDataCallback); } }
/** * Method: replyAndEndConnection * Access: private * @return: void * @param: string _msg * @param: uint _cli * Description: Encodes and transmits string _msg to connected client _cli, then disconnects the client and * listens for a new connection. */ private void replyAndEndConnection(string _msg, uint _cli) { Server.SendData(_cli, Encoding.ASCII.GetBytes(_msg), _msg.Length); Server.Disconnect(_cli); Server.WaitForConnectionAsync(new TCPServerClientConnectCallback(clientConnectHandler)); }
private void ServerClose(uint clientIndex) { _server.Disconnect(clientIndex); }
public void ReceiveCallback(TCPServer server, uint clientIndex, int bytesReceived, object obj) { new Thread((o) => { string message = Encoding.ASCII.GetString(server.GetIncomingDataBufferForSpecificClient(clientIndex), 0, bytesReceived); ErrorLog.Notice("server received {0} bytes from client\r\n{1}", bytesReceived, message); if (Regex.IsMatch(message, "^temp:ambient", RegexOptions.IgnoreCase)) { Match temp = Regex.Match(message, @"(?<=temp:ambient:)\d+", RegexOptions.IgnoreCase); system.TempControl.ambient(int.Parse(temp.Value)); } if (Regex.IsMatch(message, "^drop:client", RegexOptions.IgnoreCase)) { Match client = Regex.Match(message, @"(?<=drop:client:)\d+", RegexOptions.IgnoreCase); server.Disconnect(uint.Parse(client.Value)); } /*else if (Regex.IsMatch(message, "^temp:", RegexOptions.IgnoreCase)) * { * string action = Regex.Match(message, @"(?<=temp:)\w+", RegexOptions.IgnoreCase).Value; * system.TempControl.GetType().GetMethod(action).Invoke(system.TempControl, null); * } * else if (Regex.IsMatch(message, "^garage:", RegexOptions.IgnoreCase)) * { * string action = Regex.Match(message, @"(?<=garage:)\w+", RegexOptions.IgnoreCase).Value; * action = Regex.Replace(action, "open|close", "toggle"); * system.GarageControl.GetType().GetMethod(action).Invoke(system.GarageControl, null); * }*/ switch (message) { case "garage:open": case "garage:close": system.GarageControl.toggle(); break; case "garage:release": system.GarageControl.release(); break; case "temp:raise": system.TempControl.raise(); break; case "temp:lower": system.TempControl.lower(); break; case "temp:on": system.TempControl.on(); break; case "temp:off": system.TempControl.off(); break; } server.ReceiveDataAsync(clientIndex, ReceiveCallback, null); return(clientIndex); }, null); }
public void NotifyClients(string data) { byte[] buffer = Encoding.ASCII.GetBytes(data); try { new Thread((o) => { foreach (var client in clients) { if (server.ClientConnected(client.Key)) { server.SendDataAsync(client.Key, buffer, buffer.Length, null); } else { ErrorLog.Notice("Client {0} Disconnection Status: {1}", client.Key, server.Disconnect(client.Key)); clients.Remove(client.Key); } } return(clients); }, null); } catch (Exception ex) { ErrorLog.Notice("Something Went Wrong While Trying To Send Data To Client\r\n{1}", ex.Message); } }
public void DisposeServer() { server.Disconnect(false); WaitFor(() => { return(!server.IsBound); }); }
public void Disconnect(Socket socket) => server.Disconnect(socket);