public static void Connect(string host, int port) { if (client != null) Disconnect(); lastStatus = NetConnectionStatus.None; players.Clear(); NetPeerConfiguration config = new NetPeerConfiguration("HumanityAgainstCards") { MaximumHandshakeAttempts = 1, ConnectionTimeout = 10, PingInterval = 1 }; client = new NetClient(config); client.Start(); client.Connect(host, port); Hand = new List<Card>(); CurrentBlackCard = null; gotBrainTumorOnce = false; InMatch = false; Console.WriteLine("Client running..."); }
public void OnStatusMessage(object sender, NetConnectionStatus status, String reason) { if (StatusMessage != null) { StatusMessage(sender, new StatusMessageArgs((NetworkHelper.NetConnectionStatus)status, reason)); } }
public void Dispatch(NetConnectionStatus status) { LidgrenStatusMessage message = new LidgrenStatusMessage(status); //Just dispatch as a real status message this.OnNetworkMessageReceive(message, null); }
/// <summary> /// Waits until specified status in not cleared. /// </summary> public static void WaitForStatusCleared(this NetConnection connection, NetConnectionStatus status) { while (connection.Status == status) { Thread.Sleep(5); } }
public LidgrenStatusChangeMessageContext(NetIncomingMessage incomingMessage) : base(incomingMessage) { LidgrenStatus = (NetConnectionStatus)incomingMessage.ReadByte(); //Generate a Lidgren status message for dispatching GeneratedStatusMessage = new LidgrenStatusMessage(LidgrenStatus); }
public override void StatusChanged(NetConnectionStatus status, string message, NetConnection connection) { if (status==NetConnectionStatus.Connected) { string serverInfo = connection.RemoteHailMessage.PeekString(); gameClient.SetState( new Loading( gameClient, connection.RemoteHailMessage.PeekString() ) ); } if (status==NetConnectionStatus.Disconnected) { gameClient.SetState( new Disconnected( gameClient, message ) ); } }
public NetStatusChangedEventArgs( NetConnection connection, NetConnectionStatus oldStatus, NetConnectionStatus newStatus, string reason ) { m_connection = connection; m_oldStatus = oldStatus; m_newStatus = newStatus; m_reason = reason; }
internal NetConnection(NetPeer peer, IPEndPoint remoteEndpoint) { m_peer = peer; m_peerConfiguration = m_peer.Configuration; m_status = NetConnectionStatus.None; m_visibleStatus = NetConnectionStatus.None; m_remoteEndpoint = remoteEndpoint; m_sendChannels = new NetSenderChannelBase[NetConstants.NumTotalChannels]; m_receiveChannels = new NetReceiverChannelBase[NetConstants.NumTotalChannels]; m_queuedAcks = new NetQueue<NetTuple<NetMessageType, int>>(4); m_statistics = new NetConnectionStatistics(this); m_averageRoundtripTime = -1.0f; }
internal NetConnection(NetPeer peer, NetEndPoint remoteEndPoint) { m_peer = peer; m_peerConfiguration = m_peer.Configuration; m_status = NetConnectionStatus.None; m_outputtedStatus = NetConnectionStatus.None; m_visibleStatus = NetConnectionStatus.None; m_remoteEndPoint = remoteEndPoint; m_sendChannels = new NetSenderChannelBase[NetConstants.NumTotalChannels]; m_receiveChannels = new NetReceiverChannelBase[NetConstants.NumTotalChannels]; m_queuedOutgoingAcks = new NetQueue<NetTuple<NetMessageType, int>>(4); m_queuedIncomingAcks = new NetQueue<NetTuple<NetMessageType, int>>(4); m_statistics = new NetConnectionStatistics(this); m_averageRoundtripTime = -1.0f; m_currentMTU = m_peerConfiguration.MaximumTransmissionUnit; }
internal void SetStatus(NetConnectionStatus status, string reason) { // Connecting status is given to NetConnection at startup, so we must treat it differently if (m_status == status && status != NetConnectionStatus.Connecting) return; //m_owner.LogWrite("New connection status: " + status + " (" + reason + ")"); NetConnectionStatus oldStatus = m_status; m_status = status; if (m_status == NetConnectionStatus.Connected) { // no need for further hole punching m_owner.CeaseHolePunching(m_remoteEndPoint); } m_owner.NotifyStatusChange(this, reason); }
private void ConnectionStatusChanged(NetConnectionStatus currentStatus, string message) { System.Diagnostics.Debug.WriteLine($"connection status changed to {currentStatus}"); switch (currentStatus) { case NetConnectionStatus.Connected: EventQueue.Enqueue(new StatusUpdate.JoinedGame()); break; case NetConnectionStatus.Disconnected: EventQueue.Enqueue(new StatusUpdate.LeftGame(message, !IsAttemptingToDisconnect)); break; default: break; } }
internal NetConnection(NetBase owner, IPEndPoint remoteEndPoint, byte[] localHailData, byte[] remoteHailData) { m_owner = owner; m_remoteEndPoint = remoteEndPoint; m_localHailData = localHailData; m_remoteHailData = remoteHailData; m_futureClose = double.MaxValue; m_throttleDebt = owner.m_config.m_throttleBytesPerSecond; // slower start m_statistics = new NetConnectionStatistics(this, 1.0f); m_unsentMessages = new NetQueue<OutgoingNetMessage>(6); m_lockedUnsentMessages = new NetQueue<OutgoingNetMessage>(3); m_status = NetConnectionStatus.Connecting; // to prevent immediate removal on heartbeat thread InitializeReliability(); InitializeFragmentation(); InitializeStringTable(); //InitializeCongestionControl(32); }
public override void StatusChanged(NetConnectionStatus status, string message, NetConnection connection) { if (status==NetConnectionStatus.Disconnected) { disconnectReason = message; } }
/// <summary> /// Called when NetClient changed its status /// </summary> /// <param name="status"></param> /// <param name="message"></param> /// <param name="connection"></param> public override void StatusChanged(NetConnectionStatus status, string message, NetConnection connection) { if (status==NetConnectionStatus.Disconnected) { gameClient.SetState( new Disconnected(gameClient, message) ); } }
public override void OnStatusChange(NetConnection connection, NetConnectionStatus status) { switch (status) { case NetConnectionStatus.None: break; case NetConnectionStatus.InitiatedConnect: break; case NetConnectionStatus.RespondedAwaitingApproval: break; case NetConnectionStatus.RespondedConnect: break; case NetConnectionStatus.Connected: { AddConnection(connection); } break; case NetConnectionStatus.Disconnecting: for (int i = 0; i < players.Count; i++) { if (players[i] == connection.Tag) { var memory = new MemoryStream(); var writer = new BinaryWriter(memory); players[i].Status = Player.StatusTypes.Left; writer.Write((byte) Gamemode.Signature.PlayerLeft); writer.Write(players[i].ClientId); SendData(memory.ToArray(), Gamemode.Signature.Custom); writer.Close(); memory.Close(); players.RemoveAt(i); break; } } break; case NetConnectionStatus.Disconnected: break; default: break; } }
public StatusChangedEventArgs(NetConnectionStatus setStatus, string setReason) { status = setStatus; reason = setReason; }
public void Connect(IPEndPoint endPoint) { DisconnectReason = null; NetPeerConfiguration config = new NetPeerConfiguration("MulTUNG"); Client = new NetClient(config); Client.Start(); var approval = Client.CreateMessage(); approval.Write(MulTUNG.Version.ToString()); approval.Write(Username); var conn = Client.Connect(endPoint, approval); ThreadPool.QueueUserWorkItem(o => { var c = o as NetConnection; int elapsed = 0; while (true) { Thread.Sleep(50); elapsed += 50; if ((c.Status != NetConnectionStatus.Connected && elapsed >= Constants.WaitForConnection) || DisconnectReason != null) { Network.IsClient = false; string status = MulTUNG.Status = "Couldn't connect to remote server." + (DisconnectReason != null ? " Check the console for more details." : ""); IGConsole.Error("Couldn't connect to remote server: " + DisconnectReason); Thread.Sleep(3000); MulTUNG.ShowMainMenuCanvases(); MulTUNG.ShowStatusWindow = false; MulTUNG.Status = ""; break; } else if (c.Status == NetConnectionStatus.Connected) { Network.IsClient = true; MulTUNG.SynchronizationContext.Send(_ => { SaveManager.SaveName = MulTUNG.ForbiddenSaveName; World.DeleteSave(); SceneManager.LoadScene("gameplay"); EverythingHider.HideEverything(); }, null); while (ModUtilities.IsOnMainMenu) { Thread.Sleep(500); } Thread.Sleep(1000); IsInGameplay = true; EnterEvent.Set(); InitWorld(); break; } } }, conn); ThreadPool.QueueUserWorkItem(_ => { NetIncomingMessage msg; while (Client.Status == NetPeerStatus.Running) { msg = Client.WaitMessage(int.MaxValue); if (msg == null) { continue; } switch (msg.MessageType) { case NetIncomingMessageType.Data: var packet = PacketDeserializer.DeserializePacket(new MessagePacketReader(msg)); if (Network.ProcessPacket(packet, this.PlayerID)) { PacketLog.LogReceive(packet); } break; case NetIncomingMessageType.StatusChanged: var status = (NetConnectionStatus)msg.ReadByte(); Log.WriteLine("Status: " + status); if (status == NetConnectionStatus.Disconnected) { string reason = msg.ReadString(); if (!string.IsNullOrEmpty(reason)) { DisconnectReason = reason; } Disconnect(); } LastStatus = Client.ConnectionStatus; break; } Client.Recycle(msg); } }); }
private void receiveMessage() { NetIncomingMessage im; while ((im = session.ReadMessage()) != null) { switch (im.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.VerboseDebugMessage: Console.WriteLine(im.ReadString() + "\n"); break; case NetIncomingMessageType.UnconnectedData: Console.WriteLine(im.ReadString()); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)im.ReadByte(); // When a new player connects, the host is charged to find a suitable default name between player1 and player4 // depending on what names are available. The host then sends the new list of player names to the other players if (status == NetConnectionStatus.Connected) { /*packetWriter = session.CreateMessage(); * packetWriter.Write((Byte)ConnectedMessageType.Chat); * packetWriter.Write("Hello"); * session.SendMessage(packetWriter, im.SenderConnection, NetDeliveryMethod.ReliableOrdered);*/ } if (status == NetConnectionStatus.Disconnected) { } // Don't need this for now string reason = im.ReadString(); Console.WriteLine(status.ToString() + ": " + reason); break; case NetIncomingMessageType.Data: ConnectedMessageType connectedMessageType = (ConnectedMessageType)im.ReadByte(); switch (connectedMessageType) { case ConnectedMessageType.EndRoundInfo: packetWriter = session.CreateMessage(); packetWriter.Write((Byte)ConnectedMessageType.EndRoundInfo); packetWriter.Write(im.ReadString()); session.SendMessage(packetWriter, im.SenderConnection, NetDeliveryMethod.ReliableOrdered); break; case ConnectedMessageType.Ping: packetWriter = session.CreateMessage(); packetWriter.Write((Byte)ConnectedMessageType.PingReply); session.SendMessage(packetWriter, session.Connections, NetDeliveryMethod.ReliableOrdered, 0); break; case ConnectedMessageType.PingReply: pingSent = false; Console.WriteLine(watch.ElapsedMilliseconds); break; } break; default: Console.WriteLine("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes \n"); break; } } }
/// <summary> /// Invokes ConnectionStatusChanged event. /// </summary> /// <param name="sender">NetConnection</param> /// <param name="status">The current status of the connection</param> /// <param name="remoteId">The remote ID of the connection</param> protected virtual void OnConnectionStatusChanged(object sender, NetConnectionStatus status, Guid remoteId) { ConnectionStatusChanged?.Invoke(sender, new ConnectionStatusChangedEventArgs(status, remoteId)); }
private void MGServer_DoWork(object sender, DoWorkEventArgs e) { BackgroundWorker worker = sender as BackgroundWorker; NetPeerConfiguration config = new NetPeerConfiguration(applicationIdentifier); config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); config.EnableMessageType(NetIncomingMessageType.NatIntroductionSuccess); if (availableSession == null) { config.Port = port; } // create and start server peer = new NetServer(config); peer.Start(); myLocalAddress = GetMyLocalIpAddress(); IPAddress adr = IPAddress.Parse(myLocalAddress); myLocalEndPoint = new IPEndPoint(adr, port); // force a little wait until we have a LocalGamer otherwise things // break. This is the first item in the queue so it shouldnt take long before we // can continue. while (session.LocalGamers.Count <= 0) { Thread.Sleep(10); } if (availableSession != null) { if (!this.online) { peer.Connect(availableSession.EndPoint); } else { RequestNATIntroduction(availableSession.EndPoint, peer); } } else { if (this.online) { IPAddress ipaddr = NetUtility.Resolve(masterServer); if (ipaddr != null) { m_masterServer = new IPEndPoint(ipaddr, masterserverport); LocalNetworkGamer localMe = session.LocalGamers [0]; NetOutgoingMessage om = peer.CreateMessage(); om.Write((byte)0); om.Write(session.AllGamers.Count); om.Write(localMe.Gamertag); om.Write(session.PrivateGamerSlots); om.Write(session.MaxGamers); om.Write(localMe.IsHost); om.Write(myLocalEndPoint); om.Write(peer.Configuration.AppIdentifier); // send up session properties int[] propertyData = new int[session.SessionProperties.Count * 2]; NetworkSessionProperties.WriteProperties(session.SessionProperties, propertyData); for (int x = 0; x < propertyData.Length; x++) { om.Write(propertyData [x]); } peer.SendUnconnectedMessage(om, m_masterServer); // send message to peer } else { throw new Exception("Could not resolve live host"); } } } // run until we are done do { NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.UnconnectedData: break; case NetIncomingMessageType.NatIntroductionSuccess: #if !WINDOWS_PHONE Game.Instance.Log("NAT punch through OK " + msg.SenderEndpoint); #endif peer.Connect(msg.SenderEndpoint); break; case NetIncomingMessageType.DiscoveryRequest: // // Server received a discovery request from a client; send a discovery response (with no extra data attached) // // Get the primary local gamer LocalNetworkGamer localMe = session.LocalGamers [0]; NetOutgoingMessage om = peer.CreateMessage(); om.Write(session.RemoteGamers.Count); om.Write(localMe.Gamertag); om.Write(session.PrivateGamerSlots); om.Write(session.MaxGamers); om.Write(localMe.IsHost); int[] propertyData = new int[session.SessionProperties.Count * 2]; NetworkSessionProperties.WriteProperties(session.SessionProperties, propertyData); for (int x = 0; x < propertyData.Length; x++) { om.Write(propertyData [x]); } peer.SendDiscoveryResponse(om, msg.SenderEndpoint); break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: // // Just print diagnostic messages to console // #if !WINDOWS_PHONE Game.Instance.Log(msg.ReadString()); #endif break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); if (status == NetConnectionStatus.Disconnected) { #if !WINDOWS_PHONE Game.Instance.Log(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " disconnected! from " + msg.SenderEndpoint); #endif CommandGamerLeft cgj = new CommandGamerLeft(msg.SenderConnection.RemoteUniqueIdentifier); CommandEvent cmde = new CommandEvent(cgj); session.commandQueue.Enqueue(cmde); } if (status == NetConnectionStatus.Connected) { // // A new player just connected! // if (!pendingGamers.ContainsKey(msg.SenderConnection.RemoteUniqueIdentifier)) { #if !WINDOWS_PHONE Game.Instance.Log(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected! from " + msg.SenderEndpoint); #endif pendingGamers.Add(msg.SenderConnection.RemoteUniqueIdentifier, msg.SenderConnection); SendProfileRequest(msg.SenderConnection); } else { #if !WINDOWS_PHONE Game.Instance.Log("Already have a connection for that user, this is probably due to both NAT intro requests working"); #endif } } break; case NetIncomingMessageType.Data: NetworkMessageType mt = (NetworkMessageType)msg.ReadByte(); switch (mt) { case NetworkMessageType.Data: byte[] data = new byte[msg.LengthBytes - 1]; msg.ReadBytes(data, 0, data.Length); CommandEvent cme = new CommandEvent(new CommandReceiveData(msg.SenderConnection.RemoteUniqueIdentifier, data)); session.commandQueue.Enqueue(cme); break; case NetworkMessageType.Introduction: var introductionAddress = msg.ReadString(); try { IPEndPoint endPoint = ParseIPEndPoint(introductionAddress); if (myLocalEndPoint.ToString() != endPoint.ToString() && !AlreadyConnected(endPoint)) { #if !WINDOWS_PHONE Game.Instance.Log("Received Introduction for: " + introductionAddress + " and I am: " + myLocalEndPoint + " from: " + msg.SenderEndpoint); #endif peer.Connect(endPoint); } } catch (Exception exc) { #if !WINDOWS_PHONE Game.Instance.Log("Error parsing Introduction: " + introductionAddress + " : " + exc.Message); #endif } break; case NetworkMessageType.GamerProfile: #if !WINDOWS_PHONE Game.Instance.Log("Profile recieved from: " + NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier)); #endif if (pendingGamers.ContainsKey(msg.SenderConnection.RemoteUniqueIdentifier)) { pendingGamers.Remove(msg.SenderConnection.RemoteUniqueIdentifier); msg.ReadInt32(); string gamerTag = msg.ReadString(); msg.ReadInt32(); msg.ReadInt32(); GamerStates state = (GamerStates)msg.ReadInt32(); state &= ~GamerStates.Local; CommandGamerJoined cgj = new CommandGamerJoined(msg.SenderConnection.RemoteUniqueIdentifier); cgj.GamerTag = gamerTag; cgj.State = state; CommandEvent cmde = new CommandEvent(cgj); session.commandQueue.Enqueue(cmde); } else { #if !WINDOWS_PHONE Game.Instance.Log("We received a profile for an existing gamer. Need to update it."); #endif } break; case NetworkMessageType.RequestGamerProfile: #if !WINDOWS_PHONE Game.Instance.Log("Profile Request recieved from: " + msg.SenderEndpoint); #endif SendProfile(msg.SenderConnection); break; case NetworkMessageType.GamerStateChange: GamerStates gamerstate = (GamerStates)msg.ReadInt32(); gamerstate &= ~GamerStates.Local; #if !WINDOWS_PHONE Game.Instance.Log("State Change from: " + msg.SenderEndpoint + " new State: " + gamerstate); #endif foreach (var gamer in session.RemoteGamers) { if (gamer.RemoteUniqueIdentifier == msg.SenderConnection.RemoteUniqueIdentifier) { gamer.State = gamerstate; } } break; case NetworkMessageType.SessionStateChange: NetworkSessionState sessionState = (NetworkSessionState)msg.ReadInt32(); foreach (var gamer in session.RemoteGamers) { if (gamer.RemoteUniqueIdentifier == msg.SenderConnection.RemoteUniqueIdentifier) { #if !WINDOWS_PHONE Game.Instance.Log("Session State change from: " + NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " session is now: " + sessionState); #endif if (gamer.IsHost && sessionState == NetworkSessionState.Playing) { session.StartGame(); } } } break; } break; } } // sleep to allow other processes to run smoothly // This may need to be changed depending on network throughput Thread.Sleep(1); if (worker.CancellationPending) { #if !WINDOWS_PHONE Game.Instance.Log("worker CancellationPending"); #endif e.Cancel = true; done = true; } } while (!done); }
static void Main(string[] args) { NetConfiguration config = new NetConfiguration("durable"); config.MaxConnections = 128; config.Port = 14242; NetServer server = new MyDurableServer(config); server.SetMessageTypeEnabled(NetMessageType.ConnectionApproval, true); server.SetMessageTypeEnabled(NetMessageType.DebugMessage, true); //server.SetMessageTypeEnabled(NetMessageType.VerboseDebugMessage, true); server.SetMessageTypeEnabled(NetMessageType.StatusChanged, true); server.SimulatedMinimumLatency = 0.05f; server.SimulatedLatencyVariance = 0.025f; server.SimulatedLoss = 0.03f; server.Start(); FileStream fs = new FileStream("./serverlog.txt", FileMode.Create, FileAccess.Write, FileShare.Read); StreamWriter wrt = new StreamWriter(fs); Output(wrt, "Log started at " + DateTime.Now); wrt.Flush(); NetBuffer buffer = server.CreateBuffer(); int expected = 1; Console.WriteLine("Press any key to quit"); while (!Console.KeyAvailable) { NetMessageType type; NetConnection sender; if (server.ReadMessage(buffer, out type, out sender)) { switch (type) { case NetMessageType.StatusChanged: string statusMessage = buffer.ReadString(); NetConnectionStatus newStatus = (NetConnectionStatus)buffer.ReadByte(); if (sender.RemoteHailData != null) { Output(wrt, "New status: " + newStatus + " (" + statusMessage + ") Remote hail is: " + Encoding.ASCII.GetString(sender.RemoteHailData)); } else { Output(wrt, "New status: " + newStatus + " (" + statusMessage + ") Remote hail hasn't arrived."); } break; case NetMessageType.BadMessageReceived: case NetMessageType.ConnectionRejected: case NetMessageType.DebugMessage: // // All these types of messages all contain a single string in the buffer; display it // Output(wrt, buffer.ReadString()); break; case NetMessageType.VerboseDebugMessage: wrt.WriteLine(buffer.ReadString()); // don't output to console break; case NetMessageType.ConnectionApproval: if (sender.RemoteHailData != null && Encoding.ASCII.GetString(sender.RemoteHailData) == "Hail from client") { Output(wrt, "Hail ok!"); sender.Approve(Encoding.ASCII.GetBytes("Hail from server")); } else { sender.Disapprove("Wrong hail!"); } break; case NetMessageType.Data: // verify ProcessReceived has done its work int len = (int)buffer.Tag; if (len != buffer.LengthBytes) { Output(wrt, "OUCH! ProcessReceived hasn't done its job!"); } string str = buffer.ReadString(); // parse it int nr = Int32.Parse(str.Substring(9)); if (nr != expected) { Output(wrt, "Warning! Expected " + expected + "; received " + nr + " str is ---" + str + "---"); } else { expected++; Console.Title = "Server; received " + nr + " messages"; } break; default: Output(wrt, "Unhandled: " + type + " " + buffer.ToString()); break; } } // we're not doing anything but reading; to suspend this thread until there's something to read server.DataReceivedEvent.WaitOne(1000); } // clean shutdown wrt.Close(); server.Shutdown("Application exiting"); System.Threading.Thread.Sleep(500); // give network thread time to exit }
private void HandleMessages() { while (true) { NetIncomingMessage msg; while ((msg = server.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: server.SendDiscoveryResponse(null, msg.SenderEndPoint); break; case NetIncomingMessageType.ConnectionApproval: if (msg.ReadByte() == (Byte)PacketTypes.ConnectionRequest) { //Game1.multiplayerLobbyTest.text += "\nclient connecting"; msg.SenderConnection.Approve(); } break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: Game1.multiplayerLobbyTest.text += msg.ReadString(); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); if (status == NetConnectionStatus.Connected) { //Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected!"); } break; case NetIncomingMessageType.Data: switch (msg.ReadByte()) { case (Byte)PacketTypes.PlayerLogin: UpdatePlayerLogin(msg); break; case (Byte)PacketTypes.DiceConfiguration: UpdateDiceConfiguration(msg); break; case (Byte)PacketTypes.GameStartSync: NetOutgoingMessage outTrans = server.CreateMessage(); outTrans.Write((Byte)PacketTypes.GameStartSync); server.SendToAll(outTrans, NetDeliveryMethod.ReliableOrdered); break; case (Byte)PacketTypes.Disconnecting: NetOutgoingMessage discmsg = server.CreateMessage(); discmsg.Write((Byte)PacketTypes.Disconnecting); server.SendToAll(discmsg, NetDeliveryMethod.ReliableOrdered); break; case (Byte)PacketTypes.MovesList: Game1.multiplayerLobbyTest.text += "\ntransferring opponent moves list."; NetOutgoingMessage outmsg = server.CreateMessage(); outmsg.Write((Byte)PacketTypes.MovesList); int count = msg.ReadInt32(); outmsg.Write(count); for (int i = 0; i < count; i++) { int selectedDiceID = msg.ReadInt32(); String selectedSpellName = msg.ReadString(); outmsg.Write(selectedDiceID); outmsg.Write(selectedSpellName); if (msg.ReadBoolean()) { int targetedDiceID = msg.ReadInt32(); outmsg.Write(true); outmsg.Write(targetedDiceID); } else { outmsg.Write(false); } outmsg.Write(msg.ReadVector2()); } foreach (NetConnection con in server.Connections) { //Game1.multiplayerLobbyTest.text += con.Tag.ToString(); if (con != msg.SenderConnection) { server.SendMessage(outmsg, con, NetDeliveryMethod.ReliableOrdered); //Game1.multiplayerLobbyTest.text += "\nsent msg"; } } break; } break; default: break; } } Thread.Sleep(1); } }
private void OnHandleMessagesThread() { while (threadUpdate != null) { client.MessageReceivedEvent.WaitOne(); #if DEBUG int nowTime = (int)(NetTime.Now * 1000); if (nowTime - statsReset > 1000) { statsReset = nowTime; Down = downLast; Up = upLast; downLast = 0; upLast = 0; } #endif NetIncomingMessage msg; while (client.ReadMessage(out msg)) { switch (msg.MessageType) { case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); #if NETWORK_DEBUG Console.ForegroundColor = ConsoleColor.DarkCyan; Console.Write(" S "); Console.ForegroundColor = ConsoleColor.Gray; Console.WriteLine("[" + msg.SenderEndPoint + "] " + status); #endif if (status == NetConnectionStatus.Disconnected) { OnDisconnected?.Invoke(); } break; case NetIncomingMessageType.Data: { #if DEBUG downLast += msg.LengthBytes; #endif byte type = msg.ReadByte(); if (type == PacketTypes.UpdateAll) { OnUpdateAllPlayers?.Invoke(msg); } else { Action <NetIncomingMessage> callback; if (callbacks.TryGetValue(type, out callback)) { callback(msg); } else { Console.WriteLine(" - Unknown packet type (" + type + ")!"); } } break; } #if NETWORK_DEBUG case NetIncomingMessageType.VerboseDebugMessage: Console.ForegroundColor = ConsoleColor.DarkGray; Console.Write(" D "); Console.ForegroundColor = ConsoleColor.Gray; Console.WriteLine(msg.ReadString()); break; case NetIncomingMessageType.DebugMessage: Console.ForegroundColor = ConsoleColor.Green; Console.Write(" D "); Console.ForegroundColor = ConsoleColor.Gray; Console.WriteLine(msg.ReadString()); break; case NetIncomingMessageType.WarningMessage: Console.ForegroundColor = ConsoleColor.Yellow; Console.Write(" W "); Console.ForegroundColor = ConsoleColor.Gray; Console.WriteLine(msg.ReadString()); break; case NetIncomingMessageType.ErrorMessage: Console.ForegroundColor = ConsoleColor.Red; Console.Write(" E "); Console.ForegroundColor = ConsoleColor.Gray; Console.WriteLine(msg.ReadString()); break; #endif } client.Recycle(msg); } } client = null; Debug.WriteLine("NetworkHandler: OnHandleMessagesThread exited!"); }
/// <summary> /// Client message loop /// </summary> private void ClientLoop() { NetIncomingMessage msg; while (this.IsRunning) { _server.MessageReceivedEvent.WaitOne(1000); msg = _server.ReadMessage(); // If this second no messages accepted, releave CPU if (msg == null) { continue; } try { switch (msg.MessageType) { // MESSAGETYPE: DATA // The main message type in networking is the data type. When the connection is not linked, the // data is the verification data of the handshake and will be processed accordingly. If not, // the message is passed onto the Connection and processed by their respective protocol. case NetIncomingMessageType.Data: var connection = msg.SenderConnection.Tag as Connection; if (connection != null) { // Client was authenticated so just process the message connection.IncomingMessage(msg); } else { // Client is not yet authenticate so handle that. In my case we directly expect // authentication, but you can write your own handling code. The following code // handles just that. var handshake = NetLobby.IncomingMessage(msg); switch (handshake) { case Handshake.Contents.Succes: Connection new_connection = new Connection(_server, msg.SenderConnection, (msg.SenderConnection.Tag as Handshake).CreateEncryption()); OnConnected.Invoke(new_connection.NodeId, new_connection.Username); break; case Handshake.Contents.Error: case Handshake.Contents.Denied: msg.SenderConnection.Disconnect("Error occured during handshake."); break; case Handshake.Contents.Expired: msg.SenderConnection.Disconnect("Handshake expired."); break; } } break; // MESSAGETYPE: CONNECTION APPROVAL // The ConnectionApproval message type is seen when a node yields the peer#connect function. When // the RemoteEndpoint specified is reached, a loose connection is made. It's up to the other end, // the one that is connected too, to deny or approve the connection. case NetIncomingMessageType.ConnectionApproval: // Here you can add approval code to the public section of the server msg.SenderConnection.Approve(); break; // MESSAGETYPE: STATUS CHANGED // Internal type that is triggered when a connection is initiated, responded too, connecting, // disconnecting, connected or disconnected. Upon a connection, we might have received some // RemoteHailData. This is part of the SRPP protocol and is proccesed accordingly. When // disconnecting, the Connection is disposed, internal connection is disconnected and all is // logged. case NetIncomingMessageType.StatusChanged: NetConnectionStatus statusByte = (NetConnectionStatus)msg.ReadByte(); switch (statusByte) { case NetConnectionStatus.Disconnecting: break; case NetConnectionStatus.Disconnected: // If already connection established, destroy resources var disconnected_connection = msg.SenderConnection.Tag as Connection; if (disconnected_connection != null) { OnDisconnected.Invoke(disconnected_connection.NodeId, disconnected_connection.Username); if (!disconnected_connection.IsDisposed) { disconnected_connection.Dispose(); } } String finalReason = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32())); // Do something with the message if you want like logging: Received a reason for disconnecting... break; case NetConnectionStatus.Connected: break; default: String statusChange = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32())); // You can log/debug status messages here break; } break; #if DEBUG case NetIncomingMessageType.DebugMessage: String debugMessage = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32())); // log break; #endif case NetIncomingMessageType.WarningMessage: String warningMessage = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32())); // log; break; case NetIncomingMessageType.ErrorMessage: String errorMessage = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32())); // log break; default: throw new NetException("MessageType: " + msg.MessageType + " is not supported."); } // Recycle please _server.Recycle(msg); } catch (Exception e) { try { // Disconnect client on error msg.SenderConnection.Disconnect("No tolerance: exception " + e.Message); } catch (Exception) { } } } // Early shutdown _server.Shutdown("Server shutting down"); Console.WriteLine("Client Service is Stopping at " + NetTime.ToReadable(NetTime.Now)); _server.Shutdown("Final shutdown"); }
public void Update() { if (client == null) { return; } NetIncomingMessage msg = null; while (true) { // MH: someone may call Disconnect inside delegate, actually it should just poll events and then process them sequentially but Im lazu if (client == null) { break; } msg = client.ReadMessage(); if (msg == null) { break; } switch (msg.MessageType) { case NetIncomingMessageType.StatusChanged: { NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); if (clientDelegate != null) { if (status == NetConnectionStatus.Connected) { clientDelegate.OnClientConnected(this); } if (status == NetConnectionStatus.Disconnected) { clientDelegate.OnClientDisconnected(this); } } } break; case NetIncomingMessageType.Data: { int msgid = msg.ReadInt32(); Message message = CreateMessageObject(msgid); if (message == null) { Debug.LogError("Lidgren client: unknown message type received, did you forget to RegisterMessageType<T>() ?"); break; } if (clientDelegate != null) { message.id = msgid; message.Read(msg); clientDelegate.OnClientMessageReceived(this, message); } } break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: default: break; } if (client != null) { client.Recycle(msg); } } }
public abstract void ProcessStatusMessage(NetConnectionStatus status, string message);
/// <summary> /// Initializes a new instance of the <see cref="ClientSocketManagerStatusChangedEventArgs"/> class. /// </summary> /// <param name="newStatus">The new <see cref="NetConnectionStatus"/>.</param> /// <param name="reason">The reason for the status change.</param> public ClientSocketManagerStatusChangedEventArgs(NetConnectionStatus newStatus, string reason) { _newStatus = newStatus; _reason = reason; }
void Handler() { NetIncomingMessage inmsg; byte b; Masterserver ms = null; while (true) { while ((inmsg = server.ReadMessage()) != null) { switch (inmsg.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.VerboseDebugMessage: //Console.WriteLine(inmsg.ReadString()); break; //************************************************************************* case NetIncomingMessageType.ConnectionApproval: inmsg.SenderConnection.Approve(); lock (masterServers) { masterServers.Add(new Masterserver(inmsg.SenderConnection)); } break; //************************************************************************* case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)inmsg.ReadByte(); if (status == NetConnectionStatus.Disconnected) { lock (masterServers) masterServers.RemoveAll(p => p.netConnection == inmsg.SenderConnection); } break; //************************************************************************* case NetIncomingMessageType.Data: ms = masterServers.Find(p => p.netConnection == inmsg.SenderConnection); if (ms == null || inmsg.LengthBytes < 1) { break; } b = inmsg.ReadByte(); //masterserver informs, if its enabled for hosting if (b == 1) { Packet1(inmsg, ms); } //ms requests version if (b == 2) { Packet2(inmsg); } //masterserver sends connection count to balanceserver if (b == 21) { Packet21(inmsg, ms); } //timeout message if (b == 84) { Packet84(inmsg, ms); } break; //************************************************************************* default: Console.WriteLine("Unhandled type: " + inmsg.MessageType + " " + inmsg.LengthBytes + " bytes " + inmsg.DeliveryMethod + "|" + inmsg.SequenceChannel); break; } server.Recycle(inmsg); } Thread.Sleep(1); } }
public void ProcessSockets() { Peer peer = null; NetIncomingMessage im; while ((im = PollMessage()) != null) { long id = long.MinValue; if (im != null && im.SenderConnection != null) { id = im.SenderConnection.RemoteUniqueIdentifier; } peer = null; switch (im.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.VerboseDebugMessage: AddLogLine(im.ReadString()); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)im.ReadByte(); string reason = im.ReadString(); AddLogLine(NetUtility.ToHexString(im.SenderConnection.RemoteUniqueIdentifier) + " " + status + ": " + reason); if (status == NetConnectionStatus.Connected) { lock (Locker) Connected = true; AddLogLine("Remote hail: " + im.SenderConnection.RemoteHailMessage.ReadString()); if (DefaultPeerHandler == null) { im.SenderConnection.Disconnect("Denied"); } else { peer = DefaultPeerHandler.AddPeer(im); lock (ConnectedPeers) ConnectedPeers.Add(im.SenderConnection.RemoteUniqueIdentifier, peer); } } else if (status == NetConnectionStatus.Disconnected) { peer = ConnectedPeers.ContainsKey(id) ? ConnectedPeers[id] : null; if (peer == null) // not one of ours { return; } // tell our handler we poofed if (peer.Handler != null) { peer.Handler.PeerDisconnected(reason, peer); } lock (ConnectedPeers) { Connected = ConnectedPeers.Count > 0; ConnectedPeers.Remove(im.SenderConnection.RemoteUniqueIdentifier); } } break; case NetIncomingMessageType.Data: peer = ConnectedPeers.ContainsKey(id) ? ConnectedPeers[id] : null; if (peer == null || peer.Handler == null) // not one of ours { return; } // tell our handler we got some data peer.Handler.PeerReceiveData(im, peer); break; default: AddLogLine("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes " + im.DeliveryMethod + "|" + im.SequenceChannel); break; } SocketServer.Recycle(im); } }
public void read() { while (client.Status == NetPeerStatus.Running && !ctSource.Token.IsCancellationRequested) { WaitHandle.WaitAny(new WaitHandle[] { client.MessageReceivedEvent, ctSource.Token.WaitHandle }); NetIncomingMessage im; while ((im = client.ReadMessage()) != null && !ctSource.IsCancellationRequested) { switch (im.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.Data: try { if (alg != null) { im.Decrypt(alg); } MemoryStream ms = new MemoryStream(im.Data); ProtoMessage m = null; try { m = Serializer.DeserializeWithLengthPrefix <ProtoMessage>(ms, PrefixStyle.Fixed32); } catch (Exception e) { // Attempt to read string and add to message queue string s = im.ReadString(); if (!string.IsNullOrWhiteSpace(s)) { Console.WriteLine("CLIENT: Got message: " + s); tClient.stringMessageQueue.Enqueue(s); } } if (m != null) { Console.WriteLine("CLIENT: Got ProtoMessage with ActionType: " + m.ActionType + " and response type: " + m.ResponseType); if (m.ResponseType == DisplayMessages.LogInSuccess) { loggedIn = true; tClient.protobufMessageQueue.Enqueue(m); } else { if (m.ActionType == Actions.Update) { // Don't do anything at the moment for updates } else { tClient.protobufMessageQueue.Enqueue(m); if (m.ActionType == Actions.LogIn && m.ResponseType == DisplayMessages.None) { byte[] key = null; if (ValidateCertificateAndCreateKey(m as ProtoLogIn, out key)) { ComputeAndSendHashAndKey(m as ProtoLogIn, key); } } else { // Attempt to read string and add to message queue string s = im.ReadString(); if (!string.IsNullOrWhiteSpace(s)) { tClient.stringMessageQueue.Enqueue(s); } } } } } } catch (Exception e) { Globals_Server.logError("Error in reading data: " + e.GetType() + " :" + e.Message + "; Stack Trace: " + e.StackTrace); } break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)im.ReadByte(); Console.WriteLine("CLIENT: Status changed to " + status.ToString()); //MemoryStream ms2 = new MemoryStream(im.SenderConnection.RemoteHailMessage.Data); if (status == NetConnectionStatus.Connected) { if (im.SenderConnection.RemoteHailMessage != null) { try { MemoryStream ms2 = new MemoryStream(im.SenderConnection.RemoteHailMessage.Data); ProtoMessage m = Serializer.DeserializeWithLengthPrefix <ProtoMessage>(ms2, PrefixStyle.Fixed32); if (m != null) { tClient.protobufMessageQueue.Enqueue(m); if (m.ActionType == Actions.LogIn && m.ResponseType == DisplayMessages.None) { byte[] key = null; if (ValidateCertificateAndCreateKey(m as ProtoLogIn, out key)) { if (autoLogIn) { ComputeAndSendHashAndKey(m as ProtoLogIn, key); } } else { Console.WriteLine("Certificate validation failed: Server may be untrusted"); client.Disconnect("Invalid Certificate"); } } } } catch (Exception e) { } } break; } else if (status == NetConnectionStatus.Disconnected) { string reason = im.ReadString(); if (!string.IsNullOrEmpty(reason)) { tClient.stringMessageQueue.Enqueue(reason); } } if (im.SenderConnection.RemoteHailMessage != null && (NetConnectionStatus)im.ReadByte() == NetConnectionStatus.Connected) { } break; case NetIncomingMessageType.ConnectionLatencyUpdated: break; default: break; } client.Recycle(im); } } #if DEBUG Globals_Server.logEvent("Client listening thread ends"); #endif }
public ClientStatusChangedEventArgs(NetConnection connection, NetConnectionStatus status) { SenderConnection = connection; Status = status; }
/// <summary> /// /// </summary> public void Loop() { try { // This is checked each cycle while (this.IsRunning) { _client.MessageReceivedEvent.WaitOne(1000); NetIncomingMessage msg = _client.ReadMessage(); // No message received, please relieve CPU if (msg == null) { continue; } switch (msg.MessageType) { case NetIncomingMessageType.Data: if (msg.SenderConnection.Tag is Connection) { ((Connection)msg.SenderConnection.Tag).IncomingMessage(msg); } else { NetLobby.IncomingMessage(msg); } break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus statusByte = (NetConnectionStatus)msg.ReadByte(); switch (statusByte) { case NetConnectionStatus.Disconnecting: break; // When disconnect is called and processed case NetConnectionStatus.Disconnected: // If already connection established, destroy resources if (msg.SenderConnection.Tag is Connection && !((Connection)msg.SenderConnection.Tag).IsDisposed) { ((Connection)msg.SenderConnection.Tag).Dispose(); } // Received a reason for disconnecting? (e.a. Handshake Fail) String finalReason = Encoding.UTF8.GetString(msg.ReadBytes((Int32)msg.ReadVariableUInt32())); // Some exceptions that should be catched but even so if (finalReason.StartsWith("Handshake data validation failed")) { SetStep(AuthenticationStatus.NoServerConnection); OnAuthenticationFailed.Invoke("Could not connect"); } else if (finalReason.StartsWith("Failed to establish")) { SetStep(AuthenticationStatus.NoServerConnection); OnAuthenticationTimeout.Invoke("Could not connect"); } Disconnect(""); break; case NetConnectionStatus.Connected: SetStep(AuthenticationStatus.ServerConnection); var username = _username; var password = _password; // Connected so lets start authenticating Authenticate(_client.ServerConnection, _username, _password); break; } break; } } Disconnect(""); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public StatusMessageArgs(NetConnectionStatus status, String reason) { Status = status; Reason = reason; }
public override void ProcessStatusMessage(NetConnectionStatus status, string message) { }
public void Update() { if (NetworkClient != null && NetworkClient.Status == NetPeerStatus.Running) { NetIncomingMessage msg; while ((msg = NetworkClient.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.StatusChanged: { NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); if (status == NetConnectionStatus.Connected) { NetOutgoingMessage outMsg = NetworkClient.CreateMessage(); outMsg.Write((byte)CommandType.GetChannelInfo); outMsg.Write(channelInfos[currentChannel].channelId); NetworkClient.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0); } else if (status == NetConnectionStatus.Disconnected) { ChannelException?.Invoke(this, new Exception("Channel refused connection!")); Abort(); } }; break; case NetIncomingMessageType.Data: { if ((CommandType)msg.ReadByte() == CommandType.GetChannelInfo) { ChannelInfo received = new ChannelInfo(msg); if (received.channelId == -1) { ChannelException?.Invoke(this, new Exception($"Channel with ID {channelInfos[currentChannel].channelId} not found!")); Abort(); return; } received.ip = channelInfos[currentChannel].ip; received.port = channelInfos[currentChannel].port; ReceivedResponse?.Invoke(this, received); if (channelInfos.Count - 1 > currentChannel) { currentChannel++; NetOutgoingMessage outMsg = NetworkClient.CreateMessage(); outMsg.Write((byte)CommandType.GetChannelInfo); outMsg.Write(channelInfos[currentChannel].channelId); NetworkClient.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0); } else { Abort(); } } }; break; case NetIncomingMessageType.WarningMessage: Plugin.log.Warn(msg.ReadString()); break; case NetIncomingMessageType.ErrorMessage: Plugin.log.Error(msg.ReadString()); break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: Plugin.log.Info(msg.ReadString()); break; default: Console.WriteLine("Unhandled type: " + msg.MessageType); break; } } } }
private static void HubLoop(object sender, HighResolutionTimerElapsedEventArgs e) { if (_ticksLength.Count > 30) { _ticksLength.RemoveAt(0); } _ticksLength.Add(DateTime.UtcNow.Subtract(_lastTick).Ticks / (float)TimeSpan.TicksPerMillisecond); _lastTick = DateTime.UtcNow; List <RoomInfo> roomsList = RoomsController.GetRoomInfosList(); string titleBuffer = $"ServerHub v{Assembly.GetEntryAssembly().GetName().Version}: {roomsList.Count} rooms, {hubClients.Count} clients in lobby, {roomsList.Select(x => x.players).Sum() + hubClients.Count} clients total {(Settings.Instance.Server.ShowTickrateInTitle ? $", {Tickrate.ToString("0.0")} tickrate" : "")}"; if (_currentTitle != titleBuffer) { _currentTitle = titleBuffer; Console.Title = _currentTitle; } List <Client> allClients = hubClients.Concat(RoomsController.GetRoomsList().SelectMany(x => x.roomClients)).Concat(RadioController.radioChannels.SelectMany(x => x.radioClients)).ToList(); NetIncomingMessage msg; while (ListenerServer.ReadMessage(out msg)) { try { Program.networkBytesInNow += msg.LengthBytes; switch (msg.MessageType) { case NetIncomingMessageType.ConnectionApproval: { byte[] versionBytes = msg.PeekBytes(4); byte[] version = msg.ReadBytes(4); if (version[0] == 0 && version[1] == 0) { uint versionUint = BitConverter.ToUInt32(version, 0); uint serverVersionUint = ((uint)Assembly.GetEntryAssembly().GetName().Version.Major).ConcatUInts((uint)Assembly.GetEntryAssembly().GetName().Version.Minor).ConcatUInts((uint)Assembly.GetEntryAssembly().GetName().Version.Build).ConcatUInts((uint)Assembly.GetEntryAssembly().GetName().Version.Revision); msg.SenderConnection.Deny($"Version mismatch!\nServer:{serverVersionUint}\nClient:{versionUint}"); Logger.Instance.Log($"Client version v{versionUint} tried to connect"); break; } byte[] serverVersion = new byte[4] { (byte)Assembly.GetEntryAssembly().GetName().Version.Major, (byte)Assembly.GetEntryAssembly().GetName().Version.Minor, (byte)Assembly.GetEntryAssembly().GetName().Version.Build, (byte)Assembly.GetEntryAssembly().GetName().Version.Revision }; if (version[0] != serverVersion[0] || version[1] != serverVersion[1] || version[2] != serverVersion[2]) { msg.SenderConnection.Deny($"Version mismatch|{string.Join('.', serverVersion)}|{string.Join('.', version)}"); Logger.Instance.Log($"Client version v{string.Join('.', version)} tried to connect"); break; } PlayerInfo playerInfo = new PlayerInfo(msg); if (Settings.Instance.Access.WhitelistEnabled) { if (!IsWhitelisted(msg.SenderConnection.RemoteEndPoint, playerInfo)) { msg.SenderConnection.Deny("You are not whitelisted on this ServerHub!"); Logger.Instance.Warning($"Client {playerInfo.playerName}({playerInfo.playerId})@{msg.SenderConnection.RemoteEndPoint.Address} is not whitelisted!"); break; } } if (IsBlacklisted(msg.SenderConnection.RemoteEndPoint, playerInfo)) { msg.SenderConnection.Deny("You are banned on this ServerHub!"); Logger.Instance.Warning($"Client {playerInfo.playerName}({playerInfo.playerId})@{msg.SenderConnection.RemoteEndPoint.Address} is banned!"); break; } msg.SenderConnection.Approve(); Client client = new Client(msg.SenderConnection, playerInfo); client.playerInfo.updateInfo.playerState = PlayerState.Lobby; client.ClientDisconnected += ClientDisconnected; hubClients.Add(client); allClients.Add(client); Logger.Instance.Log($"{playerInfo.playerName} connected!"); }; break; case NetIncomingMessageType.Data: { Client client = allClients.FirstOrDefault(x => x.playerConnection.RemoteEndPoint.Equals(msg.SenderEndPoint)); switch ((CommandType)msg.ReadByte()) { case CommandType.Disconnect: { if (client != null) { allClients.Remove(client); ClientDisconnected(client); } } break; case CommandType.UpdatePlayerInfo: { if (client != null) { if (msg.PeekByte() == 1 || !client.lastUpdateIsFull) { client.UpdatePlayerInfo(msg); } if (Settings.Instance.Misc.PlayerColors.ContainsKey(client.playerInfo.playerId)) { client.playerInfo.updateInfo.playerNameColor = Settings.Instance.Misc.PlayerColors[client.playerInfo.playerId]; } } } break; case CommandType.UpdateVoIPData: { if (!Settings.Instance.Server.AllowVoiceChat) { return; } if (client != null) { UnityVOIP.VoipFragment data = new UnityVOIP.VoipFragment(msg); if (data.playerId == client.playerInfo.playerId) { client.playerVoIPQueue.Enqueue(data); } } } break; case CommandType.JoinRoom: { if (client != null) { uint roomId = msg.ReadUInt32(); BaseRoom room = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == roomId); if (room != null) { if (room.roomSettings.UsePassword) { if (RoomsController.ClientJoined(client, roomId, msg.ReadString())) { if (hubClients.Contains(client)) { hubClients.Remove(client); } client.joinedRoomID = roomId; } } else { if (RoomsController.ClientJoined(client, roomId, "")) { if (hubClients.Contains(client)) { hubClients.Remove(client); } client.joinedRoomID = roomId; } } } else { RoomsController.ClientJoined(client, roomId, ""); } } } break; case CommandType.LeaveRoom: { if (client != null) { RoomsController.ClientLeftRoom(client); client.joinedRoomID = 0; client.playerInfo.updateInfo.playerState = PlayerState.Lobby; if (!hubClients.Contains(client)) { hubClients.Add(client); } } } break; case CommandType.GetRooms: { NetOutgoingMessage outMsg = ListenerServer.CreateMessage(); outMsg.Write((byte)CommandType.GetRooms); RoomsController.AddRoomListToMessage(outMsg); msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0); Program.networkBytesOutNow += outMsg.LengthBytes; } break; case CommandType.CreateRoom: { if (client != null) { uint roomId = RoomsController.CreateRoom(new RoomSettings(msg), client.playerInfo); NetOutgoingMessage outMsg = ListenerServer.CreateMessage(5); outMsg.Write((byte)CommandType.CreateRoom); outMsg.Write(roomId); msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0); Program.networkBytesOutNow += outMsg.LengthBytes; } } break; case CommandType.GetRoomInfo: { if (client != null) { #if DEBUG Logger.Instance.Log("GetRoomInfo: Client room=" + client.joinedRoomID); #endif if (client.joinedRoomID != 0) { BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID); if (joinedRoom != null) { NetOutgoingMessage outMsg = ListenerServer.CreateMessage(); outMsg.Write((byte)CommandType.GetRoomInfo); joinedRoom.GetRoomInfo().AddToMessage(outMsg); msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0); Program.networkBytesOutNow += outMsg.LengthBytes; } } } } break; case CommandType.SetSelectedSong: { if (client != null && client.joinedRoomID != 0) { BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID); if (joinedRoom != null) { if (msg.LengthBytes < 16) { joinedRoom.SetSelectedSong(client.playerInfo, null); } else { joinedRoom.SetSelectedSong(client.playerInfo, new SongInfo(msg)); } } } } break; case CommandType.SetLevelOptions: { if (client != null && client.joinedRoomID != 0) { BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID); if (joinedRoom != null) { joinedRoom.SetLevelOptions(client.playerInfo, new LevelOptionsInfo(msg)); } } } break; case CommandType.StartLevel: { #if DEBUG Logger.Instance.Log("Received command StartLevel"); #endif if (client != null && client.joinedRoomID != 0) { BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID); if (joinedRoom != null) { LevelOptionsInfo options = new LevelOptionsInfo(msg); SongInfo song = new SongInfo(msg); song.songDuration += 2.5f; joinedRoom.StartLevel(client.playerInfo, options, song); } } } break; case CommandType.DestroyRoom: { if (client != null && client.joinedRoomID != 0) { BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID); if (joinedRoom != null) { joinedRoom.DestroyRoom(client.playerInfo); } } } break; case CommandType.TransferHost: { if (client != null && client.joinedRoomID != 0) { BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID); if (joinedRoom != null) { joinedRoom.TransferHost(client.playerInfo, new PlayerInfo(msg)); } } } break; case CommandType.PlayerReady: { if (client != null && client.joinedRoomID != 0) { BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID); if (joinedRoom != null) { joinedRoom.ReadyStateChanged(client.playerInfo, msg.ReadBoolean()); } } } break; case CommandType.SendEventMessage: { if (client != null && client.joinedRoomID != 0 && Settings.Instance.Server.AllowEventMessages) { BaseRoom joinedRoom = RoomsController.GetRoomsList().FirstOrDefault(x => x.roomId == client.joinedRoomID); if (joinedRoom != null) { string header = msg.ReadString(); string data = msg.ReadString(); joinedRoom.BroadcastEventMessage(header, data, new List <Client>() { client }); joinedRoom.BroadcastWebSocket(CommandType.SendEventMessage, new EventMessage(header, data)); EventMessageReceived?.Invoke(client, header, data); #if DEBUG Logger.Instance.Log($"Received event message! Header=\"{header}\", Data=\"{data}\""); #endif } } } break; case CommandType.GetChannelInfo: { if (Settings.Instance.Radio.EnableRadio && RadioController.radioStarted) { int channelId = msg.ReadInt32(); NetOutgoingMessage outMsg = ListenerServer.CreateMessage(); outMsg.Write((byte)CommandType.GetChannelInfo); if (RadioController.radioChannels.Count > channelId) { RadioController.radioChannels[channelId].channelInfo.AddToMessage(outMsg); } else { new ChannelInfo() { channelId = -1, currentSong = new SongInfo() { levelId = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" } }.AddToMessage(outMsg); } msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0); Program.networkBytesOutNow += outMsg.LengthBytes; } } break; case CommandType.JoinChannel: { int channelId = msg.ReadInt32(); NetOutgoingMessage outMsg = ListenerServer.CreateMessage(); outMsg.Write((byte)CommandType.JoinChannel); if (RadioController.ClientJoinedChannel(client, channelId)) { outMsg.Write((byte)0); hubClients.Remove(client); } else { outMsg.Write((byte)1); } msg.SenderConnection.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0); Program.networkBytesOutNow += outMsg.LengthBytes; } break; case CommandType.GetSongDuration: { foreach (RadioChannel channel in RadioController.radioChannels) { if (channel.radioClients.Contains(client) && channel.requestingSongDuration) { SongInfo info = new SongInfo(msg); if (info.levelId == channel.channelInfo.currentSong.levelId) { channel.songDurationResponses.TryAdd(client, info.songDuration); } } } } break; case CommandType.LeaveChannel: { if (RadioController.radioStarted && client != null) { RadioController.ClientLeftChannel(client); } }; break; } }; break; case NetIncomingMessageType.WarningMessage: Logger.Instance.Warning(msg.ReadString()); break; case NetIncomingMessageType.ErrorMessage: Logger.Instance.Error(msg.ReadString()); break; case NetIncomingMessageType.StatusChanged: { NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); Client client = allClients.FirstOrDefault(x => x.playerConnection.RemoteEndPoint.Equals(msg.SenderEndPoint)); if (client != null) { if (status == NetConnectionStatus.Disconnected) { allClients.Remove(client); ClientDisconnected(client); } } } break; #if DEBUG case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: Logger.Instance.Log(msg.ReadString()); break; default: Logger.Instance.Log("Unhandled message type: " + msg.MessageType); break; #endif } }catch (Exception ex) { Logger.Instance.Log($"Exception on message received: {ex}"); } ListenerServer.Recycle(msg); } }
internal void NotifyStatusChange(NetConnection conn, NetConnectionStatus previousStatus, string reason) { if (StatusChanged != null) { NetStatusEventArgs e = new NetStatusEventArgs(); e.PreviousStatus = previousStatus; e.Connection = conn; e.Reason = reason; StatusChanged(this, e); } }
public static void GotMessage(object peer) { var server = (CServer)peer; var msg = server.ReadMessage(); switch (msg.MessageType) { case NetIncomingMessageType.Error: string errorText; bool worked = msg.ReadString(out errorText); Main.Log("[SERVER ERROR] " + (worked ? errorText : "(???)")); break; case NetIncomingMessageType.StatusChanged: byte b = msg.ReadByte(); string statusText = msg.ReadString(); NetConnectionStatus status = (NetConnectionStatus)b; Main.Log("[STATUS UPDATE] " + status + " - " + statusText); if (status == NetConnectionStatus.Disconnected) { string n = server.GetUsername(msg.SenderConnection); if (n != null) { Main.Log("User '" + n + "' has disconnected from the server. Cya!"); server.SetName(msg.SenderConnection, null); Main.RemoveUser(n); var removeNameMsg = server.CreateMessage(); removeNameMsg.Write((byte)DataType.NAME); removeNameMsg.Write(1); removeNameMsg.Write(false); removeNameMsg.Write(n); server.SendToAll(removeNameMsg, NetDeliveryMethod.ReliableUnordered); } } if (status == NetConnectionStatus.Connected) { // Send the names of all connected people. var outMsg = server.CreateMessage(); outMsg.Write((byte)DataType.NAME); outMsg.Write(server.names.Count + 1); foreach (var item in server.names) { outMsg.Write(true); outMsg.Write(item.Value); } outMsg.Write(true); outMsg.Write(Main.ActiveUsername); server.SendMessage(outMsg, msg.SenderConnection, NetDeliveryMethod.ReliableUnordered); // Tell everyone else that this person joined... var outMsg2 = server.CreateMessage(); outMsg2.Write((byte)DataType.NAME); outMsg2.Write(1); outMsg2.Write(true); outMsg2.Write(server.GetUsername(msg.SenderConnection)); server.SendToAll(outMsg2, msg.SenderConnection, NetDeliveryMethod.ReliableUnordered, 0); } break; case NetIncomingMessageType.Data: // Find the type. var type = (DataType)msg.ReadByte(); ProcessData(type, msg, server); break; case NetIncomingMessageType.DiscoveryRequest: NetOutgoingMessage response = server.CreateMessage(server.Name); server.SendDiscoveryResponse(response, msg.SenderEndPoint); break; case NetIncomingMessageType.WarningMessage: Main.Log("[SERVER WARNING] " + msg.ReadString()); break; case NetIncomingMessageType.ConnectionApproval: string name = msg.ReadString().Trim(); if (server.names.ContainsValue(name) || Main.ActiveUsername == name) { msg.SenderConnection.Deny("Somebody else on the server already has your username."); Main.Log("Rejected connection from " + msg.SenderConnection + " because they have a duplicate username: "******"Approved connection from " + msg.SenderConnection.RemoteEndPoint + ", called '" + name + "', and sent the current names. (" + (server.names.Count + 1) + ")"); } break; default: Main.Log("[SERVER UNHANDLED] Type: " + msg.MessageType); break; } server.Recycle(msg); }
private void IOHandler() { while (m_Status == RoomSrvStatus.STATUS_RUNNING) { try { m_NetServer.MessageReceivedEvent.WaitOne(1000); long startTime = TimeUtility.GetElapsedTimeUs(); NetIncomingMessage im; for (int ct = 0; ct < 1024; ++ct) { try { if ((im = m_NetServer.ReadMessage()) != null) { switch (im.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.VerboseDebugMessage: LogSys.Log(LOG_TYPE.DEBUG, "Debug Message: {0}", im.ReadString()); break; case NetIncomingMessageType.ErrorMessage: LogSys.Log(LOG_TYPE.DEBUG, "Error Message: {0}", im.ReadString()); break; case NetIncomingMessageType.WarningMessage: LogSys.Log(LOG_TYPE.DEBUG, "Warning Message: {0}", im.ReadString()); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)im.ReadByte(); string reason = im.ReadString(); if (null != im.SenderConnection) { RoomPeer peer = RoomPeerMgr.Instance.GetPeerByConnection(im.SenderConnection); if (null != peer) { LogSys.Log(LOG_TYPE.DEBUG, "Network Status Changed: {0} reason:{1} EndPoint:{2} Key:{3} User:{4}\nStatistic:{5}", status, reason, im.SenderEndPoint.ToString(), peer.GetKey(), peer.Guid, im.SenderConnection.Statistics.ToString()); } else { LogSys.Log(LOG_TYPE.DEBUG, "Network Status Changed: {0} reason:{1} EndPoint:{2}\nStatistic:{3}", status, reason, im.SenderEndPoint.ToString(), im.SenderConnection.Statistics.ToString()); } } else { LogSys.Log(LOG_TYPE.DEBUG, "Network Status Changed:{0} reason:{1}", status, reason); } break; case NetIncomingMessageType.Data: int id = 0; object msg = null; byte[] data = null; try { data = im.ReadBytes(im.LengthBytes); msg = Serialize.Decode(data, out id); } catch { if (null != im.SenderConnection) { RoomPeer peer = RoomPeerMgr.Instance.GetPeerByConnection(im.SenderConnection); if (null != peer) { LogSys.Log(LOG_TYPE.WARN, "room server decode message error !!! from User:{0}({1})", peer.Guid, peer.GetKey()); } } } if (msg != null) { m_Dispatch.Dispatch(id, msg, im.SenderConnection); } else { if (null != im.SenderConnection) { RoomPeer peer = RoomPeerMgr.Instance.GetPeerByConnection(im.SenderConnection); if (null != peer) { LogSys.Log(LOG_TYPE.DEBUG, "got unknow message !!! from User:{0}({1})", peer.Guid, peer.GetKey()); } else { LogSys.Log(LOG_TYPE.DEBUG, "got unknow message !!!"); } } else { LogSys.Log(LOG_TYPE.DEBUG, "got unknow message !!!"); } } break; default: break; } m_NetServer.Recycle(im); } else { break; } } catch (Exception ex) { LogSys.Log(LOG_TYPE.ERROR, "Exception {0}\n{1}", ex.Message, ex.StackTrace); } } RoomPeerMgr.Instance.Tick(); long endTime = TimeUtility.GetElapsedTimeUs(); if (endTime - startTime >= 10000) { LogSys.Log(LOG_TYPE.DEBUG, "Warning, IOHandler() cost {0} us !\nNetPeer Statistic:{1}", endTime - startTime, m_NetServer.Statistics.ToString()); } } catch (Exception ex) { LogSys.Log(LOG_TYPE.ERROR, "Exception {0}\n{1}", ex.Message, ex.StackTrace); } Thread.Sleep(10); } }
private void ProcessNetworkMessages() { NetIncomingMessage inc; while ((inc = client.ReadMessage()) != null) { switch (inc.MessageType) { //Report changes in connection status case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)inc.ReadByte(); switch (status) { case NetConnectionStatus.Connected: /*var message = new UpdatePlayerStateMessage(inc.SenderConnection.RemoteHailMessage); * this.playerManager.AddPlayer(message.Id, message.Position, message.Velocity, message.Rotation, true); * Console.WriteLine("Connected to {0}", inc.SenderEndPoint);*/ ConnectionSuccess("Connected to " + inc.SenderEndpoint); break; case NetConnectionStatus.Disconnected: if (Entry.UserInterace != null && Entry.UserInterace.Chat != null) { Entry.UserInterace.Chat.Log("Lost connection to the server !"); } string reason = "Unknown error !"; try { inc.ReadByte(); reason = inc.ReadString(); } catch { } ConnectionFailed(reason); break; case NetConnectionStatus.Disconnecting: case NetConnectionStatus.InitiatedConnect: case NetConnectionStatus.RespondedConnect: Console.WriteLine(status.ToString()); break; } break; case NetIncomingMessageType.ConnectionApproval: break; case NetIncomingMessageType.Data: handler.Handle(inc); break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: Console.WriteLine(inc.ReadString()); break; } client.Recycle(inc); } }
/// <summary> /// Recebe os dados dos clientes. /// </summary> public static void ReceivedData() { NetIncomingMessage msg; while ((msg = Socket.ReadMessage()) != null) { var pData = Authentication.FindByConnection(msg.SenderConnection); switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: #region Find Banned IP if (Accounts_DB.BannedIP(msg.SenderEndPoint.Address.ToString()) == true) { LogConfig.WriteLog("Warning: Attempted IP Banned " + msg.SenderEndPoint.Address); LogConfig.WriteLog("Warning: Attempted IP Banned " + msg.SenderEndPoint.Address, Color.Coral); return; } #endregion LoginServerNetwork.Socket.SendDiscoveryResponse(null, msg.SenderEndPoint); LogConfig.WriteLog($"Discovery Response IPEndPoint: {msg.SenderEndPoint.Address}", Color.Coral); break; case NetIncomingMessageType.ErrorMessage: LogConfig.WriteLog($"Error: {msg.ReadString()}", Color.Coral); break; case NetIncomingMessageType.StatusChanged: #region Status Changed Connected NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); if (status == NetConnectionStatus.Connected) { LogConfig.WriteLog($"Status changed to connected: {msg.SenderEndPoint.Address}", Color.Coral); Authentication.Player.Add(new PlayerData(msg.SenderConnection, NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier), msg.SenderEndPoint.Address.ToString())); } #endregion #region Status Changed Disconnected if (status == NetConnectionStatus.Disconnected) { pData = Authentication.FindByHexID(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier)); //1 - enabled, 0 - disabled if (Settings.LogSystem == 1) { LogConfig.WriteLog($"Status changed to disconnected: {pData?.ID} {pData?.Account} {msg.SenderEndPoint.Address} {pData.HexID}"); } if (!Settings.LogSystemScreen) { LogConfig.WriteLog($"Status changed to disconnected: {pData?.ID} {pData?.Account} {msg.SenderEndPoint.Address} {pData.HexID}", Color.Coral); } Accounts_DB.UpdateLastIP(pData.Account, pData.IP); Accounts_DB.UpdateLoggedIn(pData.Account, 0); //0 disconnect Accounts_DB.UpdateCurrentIP(pData.Account, ""); Authentication.Player.Remove(pData); } #endregion break; case NetIncomingMessageType.Data: LoginServerData.HandleData(pData.HexID, msg); break; default: //Registra qualquer mensagem invalida LogConfig.WriteLog($"Unhandled type: {msg.MessageType}", Color.DarkRed); break; } LoginServerNetwork.Socket.Recycle(msg); } }
private Task RunListenerAsync() { return(Task.Factory.StartNew(() => { while (!_cancelTokenSource.IsCancellationRequested) { NetIncomingMessage im; while ((im = _server.ReadMessage()) != null) { // handle incoming message switch (im.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.VerboseDebugMessage: string text = im.ReadString(); Output(text); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)im.ReadByte(); string reason = im.ReadString(); Output(NetUtility.ToHexString(im.SenderConnection.RemoteUniqueIdentifier) + " " + status + ": " + reason); UpdateConnectionsList(im.SenderConnection, status); break; case NetIncomingMessageType.Data: string data = im.ReadString(); KeyValue <string> x = new KeyValue <string>(data); Output("data from client - key:" + x.key + " value:" + x.value); //= _jSerializer.Deserialize<Tuple<string, string>>(data); // incoming chat message from a client //string chat = im.ReadString(); //Output("Broadcasting '" + chat + "'"); //// broadcast this to all connections, except sender //List<NetConnection> all = _server.Connections; // get copy //all.Remove(im.SenderConnection); //if (all.Count > 0) //{ // NetOutgoingMessage om = _server.CreateMessage(); // om.Write(NetUtility.ToHexString(im.SenderConnection.RemoteUniqueIdentifier) + " said: " + chat); // _server.SendMessage(om, all, NetDeliveryMethod.ReliableOrdered, 0); //} break; default: Output("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes " + im.DeliveryMethod + "|" + im.SequenceChannel); break; } _server.Recycle(im); } Thread.Sleep(1); } } )); }
static void Update() { if (!isMessageQueueRunning) return; List<NetIncomingMessage> messages = new List<NetIncomingMessage>(); int counter = peer.ReadMessages(messages); foreach (var msg in messages) { //faster than switch, as most will be Data messages. if (msg.MessageType == NetIncomingMessageType.Data) { Consume(msg); peer.Recycle(msg); } else if (msg.MessageType == NetIncomingMessageType.DiscoveryResponse) { if (OnDiscoveryResponse != null) OnDiscoveryResponse(msg); peer.Recycle(msg); } else if (msg.MessageType == NetIncomingMessageType.WarningMessage) { Debug.LogWarning(msg.ReadString()); peer.Recycle(msg); } else if (msg.MessageType == NetIncomingMessageType.ConnectionLatencyUpdated) { Latency = msg.ReadFloat(); peer.Recycle(msg); } else if (msg.MessageType == NetIncomingMessageType.ErrorMessage) { Debug.LogError(msg.ReadString()); peer.Recycle(msg); } else if (msg.MessageType == NetIncomingMessageType.StatusChanged) { var lastStatus = m_status; m_status = (NetConnectionStatus)msg.ReadByte(); statusReason = msg.ReadString(); peer.Recycle(msg); try { if (m_status == NetConnectionStatus.Disconnected) { if (lastStatus != NetConnectionStatus.Disconnected) { if (OnDisconnectedFromServer != null) OnDisconnectedFromServer(); if (Configuration.DeleteNetworkInstantiatesOnDisconnect) { NetworkView.DestroyAllViews(); } } else { if (OnFailedToConnect != null) OnFailedToConnect(statusReason); } } else if (m_status == NetConnectionStatus.Connected) { if (OnConnectedToServer != null) OnConnectedToServer(); } } catch (Exception e) { Debug.LogError(e); } } else if (msg.MessageType == NetIncomingMessageType.Error) { Debug.LogError(msg.ReadString()); //this should really never happen... peer.Recycle(msg); } else peer.Recycle(msg); } }
/// <summary> /// Initializes a new instance of the <see cref="ClientSocketManagerStatusChangedEventArgs"/> class. /// </summary> /// <param name="newStatus">The new <see cref="NetConnectionStatus"/>.</param> /// <param name="reason">The reason for the status change.</param> public ClientSocketManagerStatusChangedEventArgs(NetConnectionStatus newStatus, string reason) { _newStatus = newStatus; _reason = reason; }
public override void StatusChanged(NetConnectionStatus status, string message, NetConnection connection) { }
public StatusMessageArgs(NetConnectionStatus status, String reason) { Status = status; Reason = reason; }
public void SetStatus(NetConnectionStatus status, string reason) { if (m_status == status) { m_parent.Log.Warning("Redundant status change: " + status); return; } NetConnectionStatus wasStatus = m_status; m_status = status; m_parent.NotifyStatusChange(this, wasStatus, reason); if (m_status == NetConnectionStatus.Connected) m_savedConnectCustomData = null; // no need to hang on to this now if (m_status == NetConnectionStatus.Disconnected) { NetServer server = m_parent as NetServer; if (server != null) server.RemoveConnection(this); } }
/// <summary> /// When overridden in the derived class, allows for handling when the status of an <see cref="IIPSocket"/> changes. /// </summary> /// <param name="sender">The <see cref="IIPSocket"/> who's status has changed.</param> /// <param name="status">The new status.</param> /// <param name="reason">The reason for the status change.</param> protected virtual void OnReceiveStatusChanged(IIPSocket sender, NetConnectionStatus status, string reason) { }
public abstract void OnStatusChange(NetConnection connection, NetConnectionStatus status);
public static void GotMessage(object peer) { NetIncomingMessage im; while ((im = Program.s_client.ReadMessage()) != null) { // handle incoming message switch (im.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.VerboseDebugMessage: string text = im.ReadString(); //Output(text); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)im.ReadByte(); if (status == NetConnectionStatus.Connected) { L_form.EnableInput(); Output("Successfully connected to Chat"); } else { //s_form.DisableInput(); //s_form.ReConnect(); //string reason = im.ReadString(); //Output(status.ToString() + ": " + reason); } break; case NetIncomingMessageType.Data: string chat = im.ReadString(); if (chat.StartsWith("PlayersIn")) { string[] chat2 = chat.Split(':'); string[] PlayersInLobby = chat2[0].Split(';'); string[] PlayersInGame = chat2[1].Split(';'); L_form.FillList(PlayersInLobby, PlayersInGame); //L_form.PlayersInLobbyList.View = View.Details; } else if (chat == "kick:" + Program.game.LocalPlayerGuid.ToString()) { System.Windows.Forms.MessageBox.Show("You were kicked by the Admin!"); L_form.LobbyForm_FormClosing(null, null); } else if (chat == "ban:" + Program.game.LocalPlayerGuid.ToString()) { System.Windows.Forms.MessageBox.Show("You were banned by the Admin!"); L_form.LobbyForm_FormClosing(null, null); } else { Output(chat); } break; default: Output("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes"); break; } } }
public LidgrenStatusMessage(NetConnectionStatus status) { Status = status.ToGladNet(); }
private void OnRecvMessage() { try { m_NetClient.MessageReceivedEvent.WaitOne(1000); NetIncomingMessage im; while ((im = m_NetClient.ReadMessage()) != null) { switch (im.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.VerboseDebugMessage: LogSystem.Info("Debug Message: {0}", im.ReadString()); break; case NetIncomingMessageType.ErrorMessage: LogSystem.Info("Error Message: {0}", im.ReadString()); break; case NetIncomingMessageType.WarningMessage: LogSystem.Info("Warning Message: {0}", im.ReadString()); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)im.ReadByte(); string reason = im.ReadString(); if (null != im.SenderConnection) { LogSystem.Info("Network Status Changed:{0} Reason:{1}\nStatistic:{2}", status, reason, im.SenderConnection.Statistics.ToString()); LogMessageCount(); if (NetConnectionStatus.Disconnected == status) { m_IsConnected = false; m_CanSendMessage = false; if (reason.CompareTo("disconnect") == 0) { if (!m_IsWaitStart) { m_IsWaitStart = true; m_NetClient.Disconnect("bye for disconnect"); PluginFramework.Instance.QueueAction(this.OnRoomServerWaitStart); } } } else if (NetConnectionStatus.Connected == status) { OnConnected(im.SenderConnection); } } else { LogSystem.Info("Network Status Changed:{0} reason:{1}", status, reason); } break; case NetIncomingMessageType.Data: case NetIncomingMessageType.UnconnectedData: if (!m_IsConnected && NetIncomingMessageType.Data == im.MessageType) { break; } try { byte[] data = im.ReadBytes(im.LengthBytes); int id; object msg = Serialize.Decode(data, out id); if (msg != null) { PushMsg(id, msg, data.Length, im.SenderConnection); } } catch (Exception ex) { LogSystem.Error("Decode Message exception:{0}\n{1}", ex.Message, ex.StackTrace); } break; default: break; } m_NetClient.Recycle(im); } } catch (Exception e) { LogSystem.Error("Exception:{0}\n{1}", e.Message, e.StackTrace); } }
public void Update() { if (_receivedMessages.Count > 0) { networkClient.Recycle(_receivedMessages); _receivedMessages.Clear(); } if (networkClient.ReadMessages(_receivedMessages) > 0) { for (int i = _receivedMessages.Count - 1; i >= 0; i--) { if (_receivedMessages[i].MessageType == NetIncomingMessageType.Data && _receivedMessages[i].PeekByte() == (byte)CommandType.UpdatePlayerInfo) { if (_packets > 150) { _averagePacketTime = 0f; _packets = 0; } if (Time.realtimeSinceStartup - _lastPacketTime < 0.2f) { _averagePacketTime += Time.realtimeSinceStartup - _lastPacketTime; _packets++; if (_averagePacketTime != 0f && _packets != 0) { tickrate = 1f / (_averagePacketTime / _packets); } } else { _averagePacketTime = 0f; _packets = 0; } _lastPacketTime = Time.realtimeSinceStartup; MessageReceived?.Invoke(_receivedMessages[i]); _receivedMessages[i].Position = 0; break; } } if (Config.Instance.SpectatorMode) { for (int i = 0; i < _receivedMessages.Count; i++) { _receivedMessages[i].Position = 0; if (_receivedMessages[i].MessageType == NetIncomingMessageType.Data && _receivedMessages[i].PeekByte() == (byte)CommandType.GetPlayerUpdates) { PlayerInfoUpdateReceived?.Invoke(_receivedMessages[i]); _receivedMessages[i].Position = 0; } } } foreach (NetIncomingMessage msg in _receivedMessages) { switch (msg.MessageType) { case NetIncomingMessageType.StatusChanged: { NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); if (status == NetConnectionStatus.Connected && !connected) { connected = true; ConnectedToServerHub?.Invoke(); } else if (status == NetConnectionStatus.Disconnected && connected) { Plugin.log.Debug("Disconnecting..."); Disconnect(); MessageReceived?.Invoke(null); } else if (status == NetConnectionStatus.Disconnected && !connected) { Plugin.log.Error("ServerHub refused connection! Reason: " + msg.ReadString()); } } break; case NetIncomingMessageType.Data: { CommandType commandType = (CommandType)msg.PeekByte(); switch (commandType) { case CommandType.Disconnect: { Plugin.log.Debug("Disconnecting..."); Disconnect(); MessageReceived?.Invoke(msg); } break; case CommandType.SendEventMessage: { string header = msg.ReadString(); string data = msg.ReadString(); Plugin.log.Debug($"Received event message! Header=\"{header}\", Data=\"{data}\""); foreach (Action <string, string> nextDel in EventMessageReceived.GetInvocationList()) { try { nextDel?.Invoke(header, data); } catch (Exception e) { if (nextDel != null) { Plugin.log.Error($"Exception in {nextDel.Target.GetType()}.{nextDel.Method.Name} on event message received event: {e}"); } else { Plugin.log.Error($"Exception in {nextDel.Target.GetType()}.{nextDel.Method.Name} on event message received event: {e}"); } } } } break; case CommandType.JoinRoom: { msg.Position = 8; if (msg.PeekByte() == 0 && ClientJoinedRoom != null) { foreach (Action nextDel in ClientJoinedRoom.GetInvocationList()) { try { nextDel?.Invoke(); } catch (Exception e) { if (nextDel != null) { Plugin.log.Error($"Exception in {nextDel.Target.GetType()}.{nextDel.Method.Name} on client joined room event: {e}"); } else { Plugin.log.Error($"Exception on client joined room event: {e}"); } } } } MessageReceived?.Invoke(msg); } break; case CommandType.StartLevel: { #if DEBUG startNewDump = true; packetsBuffer.Clear(); msg.Position = 8; LevelOptionsInfo levelInfo = new LevelOptionsInfo(msg); SongInfo songInfo = new SongInfo(msg); List <byte> buffer = new List <byte>(); buffer.AddRange(levelInfo.ToBytes()); buffer.AddRange(HexConverter.ConvertHexToBytesX(songInfo.hash)); Plugin.log.Info("LevelID: " + songInfo.levelId + ", Bytes: " + BitConverter.ToString(buffer.ToArray())); packetsBuffer.Enqueue(buffer.ToArray()); msg.Position = 0; #endif if (playerInfo != null && playerInfo.updateInfo.playerState == PlayerState.Room && ClientLevelStarted != null) { foreach (Action nextDel in ClientLevelStarted.GetInvocationList()) { try { nextDel?.Invoke(); } catch (Exception e) { if (nextDel != null) { Plugin.log.Error($"Exception in {nextDel.Target.GetType()}.{nextDel.Method.Name} on client level started event: {e}"); } else { Plugin.log.Error($"Exception on client level started event: {e}"); } } } } MessageReceived?.Invoke(msg); } break; case CommandType.UpdatePlayerInfo: break; default: { MessageReceived?.Invoke(msg); } break; } }; break; case NetIncomingMessageType.WarningMessage: Plugin.log.Warn(msg.ReadString()); break; case NetIncomingMessageType.ErrorMessage: Plugin.log.Error(msg.ReadString()); break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: Plugin.log.Debug(msg.ReadString()); break; default: Plugin.log.Debug("Unhandled message type: " + msg.MessageType); break; } } networkClient.Recycle(_receivedMessages); _receivedMessages.Clear(); } if (connected && networkClient.ConnectionsCount == 0) { Plugin.log.Debug("Connection lost! Disconnecting..."); Disconnect(); MessageReceived?.Invoke(null); } /* * if((Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl)) && Input.GetKeyDown(KeyCode.F1)) * { * GarbageCollector.GCMode = GarbageCollector.GCMode == GarbageCollector.Mode.Enabled ? GarbageCollector.Mode.Disabled : GarbageCollector.Mode.Enabled; * Plugin.log.Notice($"Garbage collector {GarbageCollector.GCMode.ToString()}!"); * } */ }
public void ServerHandleMessage(object sender, System.Timers.ElapsedEventArgs e) { try { #region HandleMessage ServerMain.TimerPackage.Stop(); NetIncomingMessage im; string message = string.Empty; Byte[] Bymessage; //ServerHandler handler; if ((im = server.ReadMessage()) == null) { return; } //Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "ServerHandleMessage"); client = im.SenderConnection; // handle incoming message switch (im.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.VerboseDebugMessage: message = im.ReadString(); Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + message); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)im.ReadByte(); Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + status.ToString()); if (status == NetConnectionStatus.Connected) { Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + NetUtility.ToHexString(im.SenderConnection.RemoteUniqueIdentifier)); //Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "Remote hail: " + im.SenderConnection.RemoteHailMessage.ReadString() + " from " + im.SenderEndPoint.ToString()); client = im.SenderConnection; Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + im.SenderConnection.ToString()); Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "Ping = " + client.AverageRoundtripTime.ToString() + " S"); } if (status == NetConnectionStatus.Disconnected) { uint id = 0; foreach (uint uid in ServerMain.allUser.Keys) { if (ServerMain.allUser[uid].connection == client) { id = uid; } } if (id != 0) { clsChangeUser changeUser = new clsChangeUser(id, ServerMain.allUser[id].name); Package packageUser = new Package((uint)Protocol.KILLUSER, changeUser.ToBytes()); ServerMain.toAllClient.Enqueue(packageUser); ServerMain.allConnections.Remove(ServerMain.allUser[id].connection); ServerMain.allUser.Remove(id); } } Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "Peer:" + im.SenderConnection.Peer.ToString()); break; case NetIncomingMessageType.Data: Bymessage = im.ReadBytes(4); Package package = new Package(BitConverter.ToUInt32(Bymessage, 0)); //Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "[C-->S] " + (Protocol)package.protocol + "\n"); int _length = BitConverter.ToInt32(im.ReadBytes(4), 0); List <byte> _data = new List <byte>(); for (int i = 0; i < _length; i++) { _data.AddRange(im.ReadBytes(1)); } package.data = _data.ToArray(); package.user = client; switch (package.protocol) { case (uint)Protocol.LOGIN: inLogin(package); break; case (uint)Protocol.SEND: inSend(package); break; case (uint)Protocol.SECRET: isSecret(package); break; } break; default: Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes " + im.DeliveryMethod + "|" + im.SequenceChannel); break; } server.Recycle(im); #endregion } catch (Exception er) { Console.WriteLine("[" + DateTime.Now.ToString("HH:mm:ss") + "]" + er.ToString()); } finally { ServerMain.TimerPackage.Start(); } }
private void UpdateConnectionsDictionary(NetConnectionStatus status) { if (status == NetConnectionStatus.Connected) { var senderId = messageIn.SenderConnection.RemoteUniqueIdentifier; if (connections.ContainsKey(senderId)) { connections.Remove(senderId); } connections.Add(senderId, messageIn.SenderConnection); // Store the event as a message var message = new Message { ClientId = messageIn.SenderConnection.RemoteUniqueIdentifier, Type = MessageType.Connect, RemoteTimeOffset = messageIn.SenderConnection.RemoteTimeOffset }; Messages.Add(message); Logger.Log<LidgrenServer>(LogLevel.Info, string.Format("Client {0} connected from IP {1}", senderId, messageIn.SenderEndpoint.Address)); } else if (status == NetConnectionStatus.Disconnected) { var senderId = messageIn.SenderConnection.RemoteUniqueIdentifier; if (connections.ContainsKey(senderId)) { connections.Remove(senderId); } // Store the event as a message var message = new Message { ClientId = messageIn.SenderConnection.RemoteUniqueIdentifier, Type = MessageType.Disconnect }; Messages.Add(message); Logger.Log<LidgrenServer>(LogLevel.Info, string.Format("Client {0} disconnected with IP {1}", senderId, messageIn.SenderEndpoint.Address)); } }
protected virtual void OnStatusChange(NetIncomingMessage message, NetConnectionStatus status) { Log.Debug(status + ": " + message.ReadString()); }
/// <summary> /// When overridden in the derived class, allows for handling when the status of an <see cref="IIPSocket"/> changes. /// </summary> /// <param name="sender">The <see cref="IIPSocket"/> who's status has changed.</param> /// <param name="status">The new status.</param> /// <param name="reason">The reason for the status change.</param> protected override void OnReceiveStatusChanged(IIPSocket sender, NetConnectionStatus status, string reason) { base.OnReceiveStatusChanged(sender, status, reason); switch (status) { case NetConnectionStatus.Disconnected: // If there was an account on the socket, destroy it var acc = World.GetUserAccount(sender, false); if (acc != null) acc.Dispose(); break; case NetConnectionStatus.Connected: // Send the server time to the client using (var pw = ServerPacket.SetGameTime(DateTime.Now)) { sender.Send(pw, ServerMessageType.GUI); } break; } }
/// <summary> /// Recebe os dados. /// </summary> public static void ReceivedData() { NetIncomingMessage msg; while ((msg = Socket.ReadMessage()) != null) { var pData = Authentication.FindByConnection(msg.SenderConnection); switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: Socket.SendDiscoveryResponse(null, msg.SenderEndPoint); LogConfig.WriteLog($"Discovery Response IPEndPoint: {msg.SenderEndPoint.Address}", Color.Coral); break; case NetIncomingMessageType.ErrorMessage: #region ErrorMessage var error = msg.ReadString(); LogConfig.WriteLog($"Error: {error}", Color.Coral); #endregion break; case NetIncomingMessageType.StatusChanged: #region StatusChanged : Connected NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); if (status == NetConnectionStatus.Connected) { LogConfig.WriteLog($"Status changed to connected: {msg.SenderEndPoint.Address}", Color.Coral); Authentication.Player.Add(new PlayerData(msg.SenderConnection, string.Empty, msg.SenderEndPoint.Address.ToString())); WorldServerPacket.NeedHexID(msg.SenderConnection); } #endregion #region StatusChanged : Disconnected if (status == NetConnectionStatus.Disconnected) { pData = Authentication.FindByConnection(msg.SenderConnection); LogConfig.WriteLog($"Status changed to disconnected: {pData.AccountID} {pData?.Account} {msg.SenderEndPoint.Address} {pData.HexID}", Color.Coral); pData.Clear(); Authentication.Player.Remove(pData); } #endregion break; case NetIncomingMessageType.Data: WorldServerData.HandleData(pData.Connection, msg); break; default: if (Settings.LogSystem) { LogConfig.WriteLog($"Unhandled type: {msg.MessageType}"); } Program.WorldForm.WriteLog($"Unhandled type: {msg.MessageType}", Color.DarkRed); break; } Socket.Recycle(msg); } }
internal void SetStatus(NetConnectionStatus status, string reason) { // user or library thread if (status == m_status) return; m_status = status; if (reason == null) reason = string.Empty; if (m_status == NetConnectionStatus.Connected) { m_timeoutDeadline = (float)NetTime.Now + m_peerConfiguration.m_connectionTimeout; m_peer.LogVerbose("Timeout deadline initialized to " + m_timeoutDeadline); } if (m_peerConfiguration.IsMessageTypeEnabled(NetIncomingMessageType.StatusChanged)) { NetIncomingMessage info = m_peer.CreateIncomingMessage(NetIncomingMessageType.StatusChanged, 4 + reason.Length + (reason.Length > 126 ? 2 : 1)); info.m_senderConnection = this; info.m_senderEndPoint = m_remoteEndPoint; info.Write((byte)m_status); info.Write(reason); m_peer.ReleaseMessage(info); } else { // app dont want those messages, update visible status immediately m_visibleStatus = m_status; } }
public static void UpdateNetwork() { NetIncomingMessage msg; if (server == null) { return; } while ((msg = server.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.WarningMessage: Console.WriteLine("{0}: {1}", msg.MessageType, msg.ReadString()); break; case NetIncomingMessageType.StatusChanged: { if (msg.SenderConnection == null) { break; } NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); string reason = msg.ReadString(); Console.WriteLine("StatusChanged: {0} '{1}'", status, reason); switch (status) { case NetConnectionStatus.Connected: { if (State == States.InGame && !AllowLateJoins) { // F**k off, no visitors msg.SenderConnection.Disconnect("Already in game, f**k off."); break; } if (Clients.Count == Constants.MaxPlayerCount) { msg.SenderConnection.Disconnect("Too crowded, f**k off."); break; } ServerClient client = new ServerClient(msg.SenderConnection, GenerateId()); msg.SenderConnection.Tag = client; Clients.Add(client); if (State == States.Lobby) { ServerList.Update(); } break; } case NetConnectionStatus.Disconnected: { if (msg.SenderConnection.Tag == null) { break; } ServerClient serverClient = (ServerClient)msg.SenderConnection.Tag; if (serverClient.Verified) { SendMessageToAllExcept(new PlayerDelete(serverClient.Id), serverClient.Id); ServerClient client = (ServerClient)msg.SenderConnection.Tag; client.Disconnect(); Clients.Remove(client); // Card Czar left like the asshole he is if (serverClient.Id == currentCardCzar) { DeclareWinner(Clients[Random.Next(Clients.Count)].Id); } if (State == States.Lobby) { ServerList.Update(); } } else { Clients.Remove((ServerClient)msg.SenderConnection.Tag); } break; } } break; } case NetIncomingMessageType.Data: { if (msg.SenderConnection == null || msg.SenderConnection.Tag == null) { break; } ServerClient client = (ServerClient)msg.SenderConnection.Tag; Packet packet = Packet.ReadFromMessage(msg); client.HandleMessage(packet); break; } default: Console.WriteLine("Unhandled type: " + msg.MessageType); break; } server.Recycle(msg); } HandleGame(); }