private NetReceiverChannelBase CreateReceiverChannel(NetMessageType tp) { m_peer.VerifyNetworkThread(); // create receiver channel NetReceiverChannelBase chan; NetDeliveryMethod method = NetUtility.GetDeliveryMethod(tp); switch (method) { case NetDeliveryMethod.Unreliable: chan = new NetUnreliableUnorderedReceiver(this); break; case NetDeliveryMethod.ReliableOrdered: chan = new NetReliableOrderedReceiver(this, NetConstants.ReliableOrderedWindowSize); break; case NetDeliveryMethod.UnreliableSequenced: chan = new NetUnreliableSequencedReceiver(this); break; case NetDeliveryMethod.ReliableUnordered: chan = new NetReliableUnorderedReceiver(this, NetConstants.ReliableOrderedWindowSize); break; case NetDeliveryMethod.ReliableSequenced: chan = new NetReliableSequencedReceiver(this, NetConstants.ReliableSequencedWindowSize); break; default: throw new NetException("Unhandled NetDeliveryMethod!"); } int channelSlot = (int)tp - 1; NetException.Assert(m_receiveChannels[channelSlot] == null); m_receiveChannels[channelSlot] = chan; return(chan); }
private static async void UpdateIPsAndStartServices() { if (_pairingService == null) { return; } var hostnames = NetUtility.GetLocalHostNames().Select(h => h.CanonicalName.ToString()); _pairingService.IPAddresses.Clear(); _pairingService.IPAddresses.AddRange(hostnames); await _httpServer.Start(); int port = int.Parse(_httpServer.ServiceName); _pairingService.Port = port; _pairingService.Publish(); _log.Info("Pairing parameters:\nHostname: {0}\nPort: {1}\nPIN: {2}\nPairing Code: {3}", Hostname, port, PIN, _pairingService.TXTRecordData["Pair"]); }
private void LoginButton_OnClicked(Button btn) { if (string.IsNullOrEmpty(emailTf.GetText()) || string.IsNullOrEmpty(passwordTf.GetText())) { windowService.Open(new OkWindow(windowService, "Error", "Fields can't be empty")); return; } windowService.Open(new TextWindow("Information", "Login in...")); var msg = zoneClientNetPeer.CreateMessage(); var messageData = new PlayerLoginMessageData(); messageData.Email = emailTf.GetText(); messageData.Password = passwordTf.GetText(); messageData.Encode(msg); var receiver = new IPEndPoint(NetUtility.Resolve(Constants.Host), Constants.ZoneServerPort); zoneClientNetPeer.SendUnconnectedMessage(msg, receiver); }
public void init() { netServer = new NetServer(ServerConfigurator.netPeerConfig); serverController = new ServerController(netServer); serverController.StartServer(); netServer.UPnP.ForwardPort(ServerConfigurator.port, "GServer"); Console.WriteLine("[SA] Server Started and serving."); Console.WriteLine("Unique identifier is " + NetUtility.ToHexString(netServer.UniqueIdentifier)); // in your separate thread while (netServer.MessageReceivedEvent.WaitOne()) // this will block until a message arrives { NetIncomingMessage msg = netServer.ReadMessage(); sMessageParseManager.parseMessage(msg, this); netServer.Recycle(msg); } }
public void Listen() { NetDebug.Log("[TCPServer] Listen."); IPEndPoint remote = NetUtility.GetIPEndPoint(setting.host, setting.port); if (null == remote) { NetDebug.Log("[TCPServer] ip port can not be null."); return; } socket = new Socket(remote.AddressFamily, SocketType.Stream, ProtocolType.Tcp); socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true); socket.Blocking = setting.blocking; socket.Bind(remote); socket.Listen(setting.backlog); AcceptAsync(); }
private void CheckOnlineStatus() { try { NetUtility.ResolveAsync(serverAddress, delegate(IPAddress adr) { if (adr == null) { SetOnlineStatus(OnlineStatus.OFFLINE); } else { SetOnlineStatus(OnlineStatus.ONLINE); } }); } catch (Exception) { SetOnlineStatus(OnlineStatus.OFFLINE); } }
private void tbServerAddress_TextChanged(object sender, TextChangedEventArgs e) { var newAddress = tbServerAddress.Text; lblAddressState.Content = "❓"; try { if (!ipv4ValidationRegex.IsMatch(newAddress)) { lblAddressState.Content = "❗"; SetOnlineStatus(OnlineStatus.OFFLINE); return; } SetOnlineStatus(OnlineStatus.CHECKING); NetUtility.ResolveAsync(newAddress, (address) => { if (address == null) { Dispatcher.BeginInvoke(new Action(() => { lblAddressState.Content = "❗"; SetOnlineStatus(OnlineStatus.OFFLINE); })); return; } serverAddress = newAddress; GameProperties.Props.SetAndSave(PropertyKey.SERVER_ADDRESS, serverAddress); lblAddressState.Content = "✔"; SetOnlineStatus(OnlineStatus.ONLINE); }); } catch { // invalid address lblAddressState.Content = "❗"; SetOnlineStatus(OnlineStatus.OFFLINE); } }
// remoteWindowStart is remote expected sequence number; everything below this has arrived properly // seqNr is the actual nr received internal override void ReceiveAcknowledge(double now, int seqNr) { if (m_doFlowControl == false) { // we have no use for acks on this channel since we don't respect the window anyway m_connection.m_peer.LogVerbose("SuppressUnreliableUnorderedAcks sender/receiver mismatch!"); return; } // late (dupe), on time or early ack? int relate = NetUtility.RelativeSequenceNumber(seqNr, m_windowStart); if (relate < 0) { //m_connection.m_peer.LogDebug("Received late/dupe ack for #" + seqNr); return; // late/duplicate ack } if (relate == 0) { //m_connection.m_peer.LogDebug("Received right-on-time ack for #" + seqNr); // ack arrived right on time NetException.Assert(seqNr == m_windowStart); m_receivedAcks[m_windowStart] = false; m_windowStart = (m_windowStart + 1) % NetConstants.NumSequenceNumbers; return; } // Advance window to this position m_receivedAcks[seqNr] = true; while (m_windowStart != seqNr) { m_receivedAcks[m_windowStart] = false; m_windowStart = (m_windowStart + 1) % NetConstants.NumSequenceNumbers; } }
public void init() { NetPeerConfiguration config = new NetPeerConfiguration("GJABD_GAME"); config.Port = 14242; config.LocalAddress = IPAddress.Any; config.EnableUPnP = true; config.EnableMessageType(NetIncomingMessageType.ConnectionApproval); //ON PRODUCTION: //config.DisableMessageType(NetIncomingMessageType.WarningMessage); netServer = new NetServer(config); serverController = new ServerController(netServer); try { serverController.StartServer(); } catch (Exception e) { Console.WriteLine(e); throw; } netServer.UPnP.ForwardPort(14242, "GServer"); Console.WriteLine("[SA] Server Started and serving."); Console.WriteLine("Unique identifier is " + NetUtility.ToHexString(netServer.UniqueIdentifier)); // in your separate thread while (netServer.MessageReceivedEvent.WaitOne()) // this will block until a message arrives { NetIncomingMessage msg = netServer.ReadMessage(); sMessageParseManager.parseMessage(msg, this); netServer.Recycle(msg); } }
// may be on user thread private NetSenderChannelBase CreateSenderChannel(NetMessageType tp) { NetSenderChannelBase chan; lock (m_sendChannels) { NetDeliveryMethod method = NetUtility.GetDeliveryMethod(tp); int sequenceChannel = (int)tp - (int)method; int channelSlot = (int)method - 1 + sequenceChannel; if (m_sendChannels[channelSlot] != null) { // we were pre-empted by another call to this method chan = m_sendChannels[channelSlot]; } else { switch (method) { case NetDeliveryMethod.Unreliable: case NetDeliveryMethod.UnreliableSequenced: chan = new NetUnreliableSenderChannel(this, NetUtility.GetWindowSize(method), method); break; case NetDeliveryMethod.ReliableOrdered: chan = new NetReliableSenderChannel(this, NetUtility.GetWindowSize(method)); break; case NetDeliveryMethod.ReliableSequenced: case NetDeliveryMethod.ReliableUnordered: default: chan = new NetReliableSenderChannel(this, NetUtility.GetWindowSize(method)); break; } m_sendChannels[channelSlot] = chan; } } return(chan); }
private IEnumerator InitMasterEndPoint() { float tStart; float tPass; float timeOut = 1.0f; while (masterServer == null) { Ping ping; foreach (var ip in masterIPs) { tStart = Time.time; tPass = 0; ping = new Ping(ip); while (!ping.isDone && tPass < timeOut) { yield return(new WaitForSeconds(0.15f)); tPass = Time.time - tStart; } if (tPass >= timeOut || ping.time == -1) { Debug.Log("Ping timed out (" + tPass + "s)" + " for master : " + ip); // timedout } else { masterServer = NetUtility.Resolve(ip, masterPort); Debug.Log("Resolved Master : " + ip + " , Ping : " + ping.time + "ms"); initMasterConn = true; yield break; } yield return(null); } } }
static void Main(string[] args) { TcpListener server = new TcpListener(NetUtility.GetLocalIPAddress(), 1234); server.Start(); Clients = new List <ClientHandler>(); Console.WriteLine($"Waiting for clients on {server.Server.LocalEndPoint}"); while (true) { TcpClient client = server.AcceptTcpClient(); // Assign the client to a handler Clients.Add(new ClientHandler(client)); Console.WriteLine($"Accepted and assigned handler to {client.Client.RemoteEndPoint}."); } Console.WriteLine("Sever Execution Ended. Press any key to continue..."); Console.ReadKey(); }
public void Listen(UDPSetting setting) { if (null == setting) { NetDebug.Error("[UDPConnection] the setting can not be null."); return; } this.setting = setting; Initialize(this.setting.ioNum); localEndPoint = NetUtility.GetIPEndPoint(setting.host, setting.port); socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.ReuseAddress, true); socket.Bind(localEndPoint); kcpHandle = new KCPServerHandle(setting); kcpHandle.onSendHandle = OnSend; kcpHandle.onReceiveHandle = OnReceive; Start(); }
static void Main(string[] args) { NetPeerConfiguration config = new NetPeerConfiguration("garbagethrower"); var client = new NetClient(config); client.Start(); var target = new IPEndPoint(NetUtility.Resolve("localhost"), 14242); var buffer = new byte[1024]; var rnd = new Random(); // use RawSend to throw poop at server while (true) { rnd.NextBytes(buffer); int length = rnd.Next(1, 1023); switch (rnd.Next(2)) { case 0: // complete randomness break; case 1: // semi-sensical buffer[1] = 0; // not a fragment, sequence number 0 buffer[2] = 0; // not a fragment, sequence number 0 buffer[3] = (byte)length; // correct payload length buffer[4] = (byte)(length >> 8); // correct payload length break; } // fling teh poop client.RawSend(buffer, 0, length, target); Thread.Sleep(1); } }
private static void HandleLoginRequest(NetIncomingMessage msg) { var logger = Logger.Instance(); logger.Write(String.Format("Received LoginRequest from {0}", NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier)), LogLevels.Informational); // Retrieve our username and password from the message. var user = msg.ReadString(); var pass = msg.ReadString(); // Attempt to authenticate the user. var result = Data.AuthenticateUser(user, pass); if (result[0] == 0) { // Login OK. // Generate a brand new GUID and add our user to the internal storage for later use. var id = result[1]; var guid = Guid.NewGuid(); var storage = GUIDStore.Instance(); storage.AddGUID(id, guid); logger.Write(String.Format("Authenticated user at Peer: {0}", NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier)), LogLevels.Debug); logger.Write(String.Format("Added GUID: {0} to storage.", guid), LogLevels.Debug); // Send our user the OK and our realmlist. Send.AuthSuccess(msg.SenderConnection, guid); } else { // Login Failed. logger.Write(String.Format("Authentication failed for user at Peer: {0}", NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier)), LogLevels.Debug); // Tell our user they entered incorrect information. Send.AuthFailed(msg.SenderConnection); } }
static void Main(string[] args) { Console.Write("Enter the Server IP address: "); string serverHostName = Console.ReadLine(); Client.Connect(NetUtility.GetHostAddressIPv4(serverHostName), 1234); NetworkStream stream = Client.GetStream(); Console.Write("Pick a Nickname: "); byte[] nickname = Encoding.UTF8.GetBytes(Console.ReadLine()); byte[] composedMessage = ComposeMessage(TransmissionType.Nickname, nickname); stream.Write(composedMessage, 0, composedMessage.Length); Thread receiverThread = new Thread(Receive); receiverThread.Start(); while (true) { Console.Write("Message: "); ChatMessage msg = new ChatMessage(Console.ReadLine()); Console.Write("To: "); msg.Destination = Console.ReadLine(); // serialize the ChatMessage object and compose the server request byte[] serialized = msg.ToByteArray(); byte[] concatenated = ComposeMessage(TransmissionType.Message, serialized); stream.Write(concatenated, 0, concatenated.Length); stream.Flush(); } stream.Close(); Client.Close(); Console.WriteLine("Ping message sent. Press any key to continue..."); Console.ReadKey(); }
private static void HandleConfirmGuid(NetIncomingMessage msg) { var logger = Logger.Instance(); logger.Write(String.Format("Received ConfirmGuid from {0}", NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier)), LogLevels.Informational); var store = GUIDStore.Instance(); // See if our storage contains this Guid. var guid = Guid.Parse(msg.ReadString()); if (store.Contains(guid)) { // Yes it does, we can accept this client. logger.Write(String.Format("GUID: {0} Exists, allowing user on.", guid), LogLevels.Debug); Send.GuidOK(msg.SenderConnection, guid); } else { // No it doesn't, where did they come from? logger.Write(String.Format("GUID: {0} Does NotExists, notify user.", guid), LogLevels.Debug); Send.GuidError(msg.SenderConnection, guid); } }
public static void AuthSuccess(NetConnection conn, Guid guid) { var data = new NetBuffer(); var list = RealmList.Instance().GetRealms(); var logger = Logger.Instance(); data.Write((Int32)Packets.Server.AuthSuccess); data.Write(guid.ToString()); data.Write(list.Count); foreach (var item in list) { data.Write(item.Value.Name); data.Write(item.Value.Hostname); data.Write(item.Value.Port); data.Write( (from c in NetServer.Instance().Connections() select NetUtility.ToHexString(c.RemoteUniqueIdentifier)) .Contains(item.Value.RemoteIdentifier) ? true : false ); } logger.Write(String.Format("Sending AuthSuccess to {0}", NetUtility.ToHexString(conn.RemoteUniqueIdentifier)), LogLevels.Debug); SendDataTo(conn, data); }
private static void HandleAuthenticateClient(NetIncomingMessage msg) { var logger = Logger.Instance(); var netid = NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier); logger.Write(String.Format("Received AuthenticateClient from {0}", netid), LogLevels.Informational); // Get our user. var user = NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier); // Get our GUID. var guid = Guid.Parse(msg.ReadString()); // Create a new user and add their (currently known) data. var store = PlayerStore.Instance(); store.AddPlayer(netid); store.SetAuthorizationId(netid, guid); logger.Write(String.Format("Adding new Player with GUID: {0} AuthorizationID: {1}", guid, netid), LogLevels.Debug); // Try and confirm this guid with our authentication server. Send.ConfirmGuid(guid); }
public static void MainClient() { Application.EnableVisualStyles(); lobby = new Lobby(); hostList = new Dictionary <long, IPEndPoint[]>(); SSEngine.MasterServerEndpoint = new IPEndPoint(NetUtility.Resolve("localhost"), SSEngine.MasterServerPort); count = 0; lastRefreshed = 0.0f; SSEngine.IsHost = null; NetPeerConfiguration config = new NetPeerConfiguration("strange suits"); config.EnableMessageType(NetIncomingMessageType.UnconnectedData); config.EnableMessageType(NetIncomingMessageType.NatIntroductionSuccess); config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); SSEngine.Peer = new NetClient(config); SSEngine.Peer.Start(); SSEngine.Peer.DiscoverKnownPeer(SSEngine.MasterServerEndpoint); lobby.StartUpdate(); lobby.ShowDialog(); }
public void StartConnect(string address) { if (_isConnecting) { return; } // See if the IP includes a port. var split = address.Split(':'); string ip = address; ushort port = DEFAULT_PORT; if (split.Length > 2) { // Multiple colons? throw new InvalidOperationException("Not a valid Address."); } // IP:port format. if (split.Length == 2) { ip = split[0]; if (!ushort.TryParse(split[1], out port)) { throw new InvalidOperationException("Not a valid port."); } } if (NetUtility.Resolve(ip, port) == null) { throw new InvalidOperationException("Not a valid Address."); } _connectTime = DateTime.Now; _isConnecting = true; NetworkManager.ClientConnect(ip, port); }
public void Connect(string address, int port) { Initialize(); IsServer = false; State = UDPConnectionState.OPENING; remoterPoint = NetUtility.GetIPEndPoint(address, port); if (null == remoterPoint) { NetDebug.Log("[TCPClient] remote can not be null."); return; } socket = new Socket(remoterPoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp); socket.Connect(remoterPoint); ReceiveFromAsync(remoterPoint); //socket.Blocking = setting.blocking; //socket.NoDelay = setting.noDelay; Send(remoterPoint, UDPPacketType.SYN); }
/// <summary> /// Start local network peer. /// </summary> public Network() { m_netPeerConfiguration.MaximumConnections = 32; m_netPeerConfiguration.Port = APIMain.ServerPort; m_netPeerConfiguration.ReceiveBufferSize = 1000000000; m_netPeerConfiguration.EnableMessageType(NetIncomingMessageType.UnconnectedData); //m_netPeerConfiguration.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); Commented since client will get list of the servers from master server. m_netPeerConfiguration.EnableMessageType(NetIncomingMessageType.ConnectionApproval); this.m_masterServer = new IPEndPoint(NetUtility.Resolve(APIMain.MasterServerIP), APIMain.MasterServerPort); Log.HandleLog(LOGMessageTypes.Info, true, true, true, "Server configured."); Log.HandleEmptyMessage(); Log.HandleLog(LOGMessageTypes.Info, "Initializing server..."); m_netServer = new NetServer(m_netPeerConfiguration); m_netServer.Start(); Log.HandleLog(LOGMessageTypes.Info, true, true, true, "Server initialized."); Log.HandleEmptyMessage(); m_updateThread = new Thread(Update); m_updateThread.Start(); }
public bool AttemptConnection() { // Attempt Connection IPEndPoint ep; if (IPaddress != "") { ep = NetUtility.Resolve(IPaddress, 14240); } else { ep = NetUtility.Resolve("localhost", 14240); } if (client.GetConnection(ep) == null) { client.DiscoverKnownPeer(ep); connectedServerInfo.IPAddress = ep.ToString(); connectedServerInfo.port = ep.Port; myInfo.IPAddress = client.Configuration.BroadcastAddress.ToString(); myInfo.port = client.Port; //if (client.ConnectionStatus != NetConnectionStatus.Disconnected) //{ //pConnected = true; // } } else { Debug.WriteLine("You're already connected idiot"); } return(pConnected); }
// private static bool no_more_tiles =false; //if we dont need to read updates on tiles anymore, to save work. static void Main(string[] args) { NetPeerConfiguration config = new NetPeerConfiguration("Flags"); config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); config.Port = 14242; //our port config.EnableUPnP = true; //enabling port forwarding using upnp. // create and start server NetServer server = new NetServer(config); server.Start(); //gamerooms that will contain 2 players each. GameRoom currentGameRoom = new GameRoom(); List <GameRoom> gamerooms = new List <GameRoom>(); //list of all gamerooms. List <int> tile_list = new List <int>(); //list of tiles id's server.UPnP.ForwardPort(14242, "Flags game for school project"); // schedule initial sending of position updates double nextSendUpdates = NetTime.Now; // run until escape is pressed while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape) { NetIncomingMessage msg; while ((msg = server.ReadMessage()) != null) //reading messages from clients. { switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: // Server received a discovery request from a client; send a discovery response // with data about if its the first or second player. NetOutgoingMessage msg_num_of_players = server.CreateMessage(); if (server.ConnectionsCount % 2 != 0) { msg_num_of_players.Write(1); } else { msg_num_of_players.Write(0); } server.SendDiscoveryResponse(msg_num_of_players, msg.SenderEndPoint); //sending response. break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: // // Just print diagnostic messages to console // Console.WriteLine(msg.ReadString()); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); if (status == NetConnectionStatus.Connected) { // // A new player just connected! // //writing to console. Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected!"); //in each connection we use it's TAG to keep game data of that client. msg.SenderConnection.Tag = new int[602]; //resetting to -10 (meaning no game data to send to other clients) int[] pos = msg.SenderConnection.Tag as int[]; for (int i = 0; i < pos.Length; i++) { pos[i] = -10; } //creating new game room if you are the first player. if (server.ConnectionsCount % 2 == 1) { GameRoom tmp = new GameRoom(); currentGameRoom = tmp; currentGameRoom.SetFirstPlayer(msg.SenderConnection); gamerooms.Add(currentGameRoom); } else //joining an existing room if you are the second player. { currentGameRoom.SetSecondPlayer(msg.SenderConnection); } } break; case NetIncomingMessageType.Data: //reading game related data. string data_string = msg.ReadString(); //reading message header switch (data_string) { case "teleport": { int tile_id = msg.ReadInt32(); //reading message int[] pos = msg.SenderConnection.Tag as int[]; //using connection TAG to save data about that client if (pos[600] == -10) { pos[600] = tile_id; } else { pos[601] = tile_id; } break; } case "tile_added": { int tile_id = msg.ReadInt32(); //reading message int[] pos = msg.SenderConnection.Tag as int[]; //using connection TAG to save data about that client int i = 0; while (pos[4 + i] != -10) { i++; } pos[4 + i] = tile_id; break; } case "move": { int id = msg.ReadInt32(); int indexinput = msg.ReadInt32(); //reading message int[] pos = msg.SenderConnection.Tag as int[]; //using connection TAG to save data about that client pos[0] = id; pos[1] = indexinput; break; } case "attacked": { int id = msg.ReadInt32(); int indexinput = msg.ReadInt32(); //reading message int[] pos = msg.SenderConnection.Tag as int[]; //using connection TAG to save data about that client pos[2] = id; pos[3] = indexinput; break; } } break; } // // send position updates 30 times per second // } double now = NetTime.Now; if (now > nextSendUpdates) { // Yes, it's time to send position updates // for each gameroom... foreach (GameRoom gameroom in gamerooms) { // for each player... foreach (NetConnection player in gameroom.players) { // ... send information to the other player foreach (NetConnection otherPlayer in gameroom.players) { if (player != otherPlayer) { NetOutgoingMessage om = server.CreateMessage(); if (otherPlayer.Tag == null) { otherPlayer.Tag = new int[602]; } int[] pos = otherPlayer.Tag as int[]; if (pos[0] != -10 && pos[1] != -10) //if there is new data to write. { om.Write("move"); om.Write(pos[0]); om.Write(pos[1]); // send message server.SendMessage(om, player, NetDeliveryMethod.ReliableOrdered, 0); pos[0] = -10; pos[1] = -10; } int i = 0; while (pos[4 + i] == -10 && 4 + i < 599) { i++; } if (pos[4 + i] != -10) //if there is new data to write. { om = server.CreateMessage(); om.Write("tile_added"); om.Write(pos[4 + i]); server.SendMessage(om, player, NetDeliveryMethod.ReliableOrdered, 0); pos[4 + i] = -10; } if (pos[2] != -10 && pos[3] != -10) //if there is new data to write. { om = server.CreateMessage(); om.Write("attacked"); om.Write(pos[2]); om.Write(pos[3]); // send message server.SendMessage(om, player, NetDeliveryMethod.ReliableOrdered, 0); pos[2] = -10; pos[3] = -10; } if (pos[600] != -10 || pos[601] != -10) //if there is new data to write. { om = server.CreateMessage(); om.Write("teleport"); if (pos[600] != -10) { om.Write(pos[600]); // send message server.SendMessage(om, player, NetDeliveryMethod.ReliableOrdered, 0); pos[600] = -10; } else if (pos[601] != -10) { om.Write(pos[601]); // send message server.SendMessage(om, player, NetDeliveryMethod.ReliableOrdered, 0); pos[601] = -10; } } // server.SendMessage(om, player, NetDeliveryMethod.ReliableOrdered, 0); } } } } // schedule next update nextSendUpdates += (1.0 / 30.0); } // sleep to allow other processes to run smoothly Thread.Sleep(1); } server.Shutdown("app exiting"); }
static void RunServer(CancellationTokenSource token) { var config = new NetPeerConfiguration("Mafia") { Port = 12345 }; var server = new NetServer(config); server.Start(); while (!token.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); //if (status == NetConnectionStatus.Connected) //{ // string hail = im.SenderConnection.RemoteHailMessage.ReadString(); // Output("Remote hail: " + hail); //} //if (status == NetConnectionStatus.Disconnected) //{ //} UpdateConnectionsList(im.SenderConnection, status); break; case NetIncomingMessageType.Data: string action = im.ReadString(); string data = im.ReadString(); Output(action + ":" + 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); } Console.WriteLine("Server is exiting.."); server.FlushSendQueue(); }
static void Main(string[] args) { int playerNr = 1; Field[,] gamegrid; //Gamegrid erzeugen gamegrid = new Field[gamegridSize, gamegridSize]; for (int i = 0; i < gamegrid.GetLength(0); i++) { for (int j = 0; j < gamegrid.GetLength(1); j++) { gamegrid[i, j] = new Field(); } } // Create PlayerList //playerList = new List<Player>(); //Networking NetPeerConfiguration config = new NetPeerConfiguration("xnaapp"); config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); config.Port = 1337; //create and start Server NetServer server = new NetServer(config); server.Start(); //Speed double nextSendUpdates = NetTime.Now; //Escape Exit while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape) { //READING MESSAGES // NetIncomingMessage msg; while ((msg = server.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: //Recieved discovery request from cient -> send discovery response server.SendDiscoveryResponse(null, msg.SenderEndPoint); break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: //Write all error messages Console.WriteLine(msg.ReadString()); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); if (status == NetConnectionStatus.Connected) { // Player Connected ! Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " is connected !"); //Add new Player to List msg.SenderConnection.Tag = new Player(playerNr, msg.SenderConnection.RemoteUniqueIdentifier, gamegridSize); playerNr++; //addPlayersServer(playerId); } else if (status == NetConnectionStatus.Disconnected) { Console.WriteLine(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + "disconnected!"); //Delete Player from List //foreach(Player player in playerList){ // if (player.playerId == playerId) // { // playerList.Remove(player); // } //} } break; case NetIncomingMessageType.Data: //Recieve Client Message int moveX = msg.ReadInt32(); int moveY = msg.ReadInt32(); //int gridSize = msg.ReadInt32(); Player msgPlayer = msg.SenderConnection.Tag as Player; msgPlayer.directionX = moveX; msgPlayer.directionY = moveY; msg.SenderConnection.Tag = msgPlayer; Console.WriteLine("---------------------------------------------------------"); Console.WriteLine("RECIEVED MSG Nr " + msgPlayer.playerNr + " PosX: " + msgPlayer.pos[0] + " PosY: " + msgPlayer.pos[1]); //foreach (Player player in playerList) //{ // if (player.playerId == playerId) // { // player.directionX = moveX; // player.directionY = moveY; // Console.WriteLine("Id " + playerId + " X: " + moveX + " Y: " + moveY); // msg.SenderConnection.Tag = player; // return; // } //} break; } double now = NetTime.Now; if (now > nextSendUpdates) { //Send Position Updates back foreach (NetConnection player in server.Connections) { NetOutgoingMessage sendMessage = server.CreateMessage(); sendMessage.Write(player.RemoteUniqueIdentifier); if (player.Tag == null) { Console.WriteLine("ACHTUNG KEIN TAG BEIM SENDEN !!! "); player.Tag = new Player(playerNr, msg.SenderConnection.RemoteUniqueIdentifier, gamegridSize); playerNr++; } Player msgPlayer = player.Tag as Player; sendMessage.Write(msgPlayer.playerNr); //Collision Detection and Movement // if (!gamegrid[msgPlayer.pos[0], msgPlayer.pos[1]].isWall) { //Set Wall and Color gamegrid[msgPlayer.pos[0], msgPlayer.pos[1]].isWall = true; // Move Console.WriteLine("Nr " + msgPlayer.playerNr + " PosX: " + msgPlayer.pos[0] + " PosY: " + msgPlayer.pos[1]); Console.WriteLine(gamegrid[msgPlayer.pos[0], msgPlayer.pos[1]].isWall); msgPlayer.move(); Console.WriteLine("Nr " + msgPlayer.playerNr + " PosX: " + msgPlayer.pos[0] + " PosY: " + msgPlayer.pos[1]); Console.WriteLine(gamegrid[msgPlayer.pos[0], msgPlayer.pos[1]].isWall); } else { msgPlayer.isAlive = false; } sendMessage.Write(msgPlayer.isAlive); sendMessage.Write(msgPlayer.pos[0]); sendMessage.Write(msgPlayer.pos[1]); Console.WriteLine("SENDED MSG Nr " + msgPlayer.playerNr + " PosX: " + msgPlayer.pos[0] + " PosY: " + msgPlayer.pos[1]); server.SendMessage(sendMessage, player, NetDeliveryMethod.Unreliable); } } nextSendUpdates += (1.0 / 10.0);//Sendeintervall } //to run smootly Thread.Sleep(1); } server.Shutdown("Server beendet"); }
public override int GetPacketSize() => NetUtility.BitsToHoldGuid(_sourceMechGuid) + _usedWeapon.GetPacketSize() + _targetPosition.GetPacketSize();
private async void HandleHandshake(NetPeerData peer, NetConnection connection) { try { var incPacket = await AwaitData(connection); var msgLogin = new MsgLoginStart(); msgLogin.ReadFromBuffer(incPacket); var ip = connection.RemoteEndPoint.Address; var isLocal = IPAddress.IsLoopback(ip) && _config.GetCVar(CVars.AuthAllowLocal); var canAuth = msgLogin.CanAuth; var needPk = msgLogin.NeedPubKey; var authServer = _config.GetSecureCVar <string>("auth.server"); if (Auth == AuthMode.Required && !isLocal) { if (!canAuth) { connection.Disconnect("Connecting to this server requires authentication"); return; } } NetEncryption?encryption = null; NetUserId userId; string userName; LoginType type; var padSuccessMessage = true; if (canAuth && Auth != AuthMode.Disabled) { var verifyToken = new byte[4]; RandomNumberGenerator.Fill(verifyToken); var msgEncReq = new MsgEncryptionRequest { PublicKey = needPk ? RsaPublicKey : Array.Empty <byte>(), VerifyToken = verifyToken }; var outMsgEncReq = peer.Peer.CreateMessage(); outMsgEncReq.Write(false); outMsgEncReq.WritePadBits(); msgEncReq.WriteToBuffer(outMsgEncReq); peer.Peer.SendMessage(outMsgEncReq, connection, NetDeliveryMethod.ReliableOrdered); incPacket = await AwaitData(connection); var msgEncResponse = new MsgEncryptionResponse(); msgEncResponse.ReadFromBuffer(incPacket); byte[] verifyTokenCheck; byte[] sharedSecret; try { verifyTokenCheck = _authRsaPrivateKey !.Decrypt( msgEncResponse.VerifyToken, RSAEncryptionPadding.OaepSHA256); sharedSecret = _authRsaPrivateKey !.Decrypt( msgEncResponse.SharedSecret, RSAEncryptionPadding.OaepSHA256); } catch (CryptographicException) { // Launcher gives the client the public RSA key of the server BUT // that doesn't persist if the server restarts. // In that case, the decrypt can fail here. connection.Disconnect("Token decryption failed./nPlease reconnect to this server from the launcher."); return; } if (!verifyToken.SequenceEqual(verifyTokenCheck)) { connection.Disconnect("Verify token is invalid"); return; } encryption = new NetAESEncryption(peer.Peer, sharedSecret, 0, sharedSecret.Length); var authHashBytes = MakeAuthHash(sharedSecret, RsaPublicKey !); var authHash = Base64Helpers.ConvertToBase64Url(authHashBytes); var client = new HttpClient(); var url = $"{authServer}api/session/hasJoined?hash={authHash}&userId={msgEncResponse.UserId}"; var joinedResp = await client.GetAsync(url); joinedResp.EnsureSuccessStatusCode(); var joinedRespJson = JsonConvert.DeserializeObject <HasJoinedResponse>( await joinedResp.Content.ReadAsStringAsync()); if (!joinedRespJson.IsValid) { connection.Disconnect("Failed to validate login"); return; } userId = new NetUserId(joinedRespJson.UserData !.UserId); userName = joinedRespJson.UserData.UserName; padSuccessMessage = false; type = LoginType.LoggedIn; } else { var reqUserName = msgLogin.UserName; if (!UsernameHelpers.IsNameValid(reqUserName, out var reason)) { connection.Disconnect($"Username is invalid ({reason.ToText()})."); return; } // If auth is set to "optional" we need to avoid conflicts between real accounts and guests, // so we explicitly prefix guests. var origName = Auth == AuthMode.Disabled ? reqUserName : (isLocal ? $"localhost@{reqUserName}" : $"guest@{reqUserName}"); var name = origName; var iterations = 1; while (_assignedUsernames.ContainsKey(name)) { // This is shit but I don't care. name = $"{origName}_{++iterations}"; } userName = name; (userId, type) = await AssignUserIdAsync(name); } var endPoint = connection.RemoteEndPoint; var connect = await OnConnecting(endPoint, userId, userName, type); if (connect.IsDenied) { connection.Disconnect($"Connection denied: {connect.DenyReason}"); return; } // Well they're in. Kick a connected client with the same GUID if we have to. if (_assignedUserIds.TryGetValue(userId, out var existing)) { existing.Disconnect("Another connection has been made with your account."); // Have to wait until they're properly off the server to avoid any collisions. await AwaitDisconnectAsync(existing); } var msg = peer.Peer.CreateMessage(); var msgResp = new MsgLoginSuccess { UserId = userId.UserId, UserName = userName, Type = type }; if (padSuccessMessage) { msg.Write(true); msg.WritePadBits(); } msgResp.WriteToBuffer(msg); encryption?.Encrypt(msg); peer.Peer.SendMessage(msg, connection, NetDeliveryMethod.ReliableOrdered); Logger.InfoS("net", "Approved {ConnectionEndpoint} with username {Username} user ID {userId} into the server", connection.RemoteEndPoint, userName, userId); // Handshake complete! HandleInitialHandshakeComplete(peer, connection, userId, userName, encryption, type); } catch (ClientDisconnectedException) { Logger.InfoS("net", $"Peer {NetUtility.ToHexString(connection.RemoteUniqueIdentifier)} disconnected while handshake was in-progress."); } catch (Exception e) { connection.Disconnect("Unknown server error occured during handshake."); Logger.ErrorS("net", "Exception during handshake with peer {0}:\n{1}", NetUtility.ToHexString(connection.RemoteUniqueIdentifier), e); } }
private void DiscoverPublicServers() { string deviceId; #if PLATFORM_ANDROID try { deviceId = global::Android.Provider.Settings.Secure.GetString(Android.MainActivity.Current.ContentResolver, global::Android.Provider.Settings.Secure.AndroidId); if (deviceId == null) { deviceId = ""; } } catch { deviceId = ""; } deviceId += "|Android " + global::Android.OS.Build.VERSION.Release + "|"; try { string device = (string.IsNullOrEmpty(global::Android.OS.Build.Model) ? global::Android.OS.Build.Manufacturer : (global::Android.OS.Build.Model.StartsWith(global::Android.OS.Build.Manufacturer) ? global::Android.OS.Build.Model : global::Android.OS.Build.Manufacturer + " " + global::Android.OS.Build.Model)); if (device == null) { device = ""; } else if (device.Length > 1) { device = char.ToUpper(device[0]) + device.Substring(1); } deviceId += device; } catch { } #else try { deviceId = Environment.MachineName; if (deviceId == null) { deviceId = ""; } } catch { deviceId = ""; } deviceId += "|" + Environment.OSVersion.ToString() + "|"; #endif deviceId = Convert.ToBase64String(Encoding.UTF8.GetBytes(deviceId)) .Replace('+', '-').Replace('/', '_').TrimEnd('='); ServerListJson json; try { string currentVersion = App.AssemblyVersion; WebClient http = new WebClient(); http.Encoding = Encoding.UTF8; http.Headers["User-Agent"] = "Jazz2 Resurrection"; string content = http.DownloadString(ServerListUrl + "?fetch&v=" + currentVersion + "&d=" + deviceId); if (content == null) { return; } json = ContentResolver.Current.Json.Parse <ServerListJson>(content); } catch { // Nothing to do... return; } // Remove lost local servers foreach (KeyValuePair <string, Server> pair in foundServers) { if (pair.Value.PublicEndPointList == null) { continue; } if (pair.Value.IsLost) { pair.Value.LatencyMs = -1; serverUpdatedAction(pair.Value, false); } else { pair.Value.IsLost = true; } } // Process server list if (json.s != null) { foreach (ServerListJson.Server s in json.s) { List <IPEndPoint> endPoints; if (!publicEndPoints.TryGetValue(s.u, out endPoints)) { string[] endPointsRaw = s.e.Split('|'); endPoints = new List <IPEndPoint>(endPointsRaw.Length); for (int i = 0; i < endPointsRaw.Length; i++) { int idx = endPointsRaw[i].LastIndexOf(':'); if (idx == -1) { continue; } int port; if (!int.TryParse(endPointsRaw[i].Substring(idx + 1), NumberStyles.Any, CultureInfo.InvariantCulture, out port)) { continue; } try { IPAddress ip = NetUtility.Resolve(endPointsRaw[i].Substring(0, idx)); if (ip.IsIPv4MappedToIPv6) { ip = ip.MapToIPv4(); } endPoints.Add(new IPEndPoint(ip, port)); } catch { // Nothing to do... } } publicEndPoints[s.e] = endPoints; } if (endPoints.Count == 0) { // Endpoints cannot be parsed, skip this server continue; } bool isNew; Server server; if (!foundServers.TryGetValue(s.u, out server)) { server = new Server { UniqueIdentifier = s.u, ActiveEndPointName = endPoints[0].Address.ToString() + ":" + endPoints[0].Port.ToString(CultureInfo.InvariantCulture), LatencyMs = -1, IsLost = true }; foundServers[s.u] = server; isNew = true; } else { isNew = false; } server.PublicEndPointList = endPoints; server.Name = s.n; server.CurrentPlayers = s.c; server.MaxPlayers = s.m; serverUpdatedAction(server, isNew); // Send ping request server.LastPingTime = (long)(NetTime.Now * 1000); NetOutgoingMessage m = client.CreateMessage(); m.Write(SpecialPacketTypes.Ping); client.SendUnconnectedMessage(m, endPoints); } } }