/// <summary> /// Connects to a local server instance /// </summary> /// <param name="server">The server tag to connect to</param> /// <param name="serverPassword">The SHA256 encrypted password to connect to the server</param> /// <param name="port">The port that the server is running on</param> public void ConnectTo(GameServer server, string serverPassword = "", int port = NetSettings.DEFAULT_SERVER_PORT) { if (myConnectedServer == null) { // Hash the password before sending if (!string.IsNullOrWhiteSpace(serverPassword)) { serverPassword = SecurityUtils.Hash(serverPassword); } // Write the hail message and send it NetOutgoingMessage hailMessage = myPeer.CreateMessage(); myTag.WriteToPacket(hailMessage); hailMessage.Write(serverPassword); // Update our connected tag myConnectedServer = server.Tag; // Attempt the connection myPeer.Connect(new IPEndPoint(server.IP, port), hailMessage); } else { throw new InvalidOperationException("Cannot connect when this client is already connected"); } }
public void HandleWebConnections() { NetIncomingMessage message; while ((message = peer.ReadMessage()) != null) { switch (message.MessageType) { case NetIncomingMessageType.Data: HandleData(message); break; case NetIncomingMessageType.StatusChanged: switch (message.SenderConnection.Status) { case NetConnectionStatus.Connected: Debug.WriteLine("Connected!"); break; case NetConnectionStatus.Disconnected: Debug.WriteLine("Disconnected..."); break; } break; case NetIncomingMessageType.ConnectionApproval: message.SenderConnection.Approve(); break; case NetIncomingMessageType.DiscoveryResponse: peer.Connect(message.SenderEndPoint); connecting = false; break; case NetIncomingMessageType.DiscoveryRequest: var msg = peer.CreateMessage(); msg.Write("hi"); peer.SendDiscoveryResponse(msg, message.SenderEndPoint); peer.Connect(message.SenderEndPoint); isServer = true; break; case NetIncomingMessageType.DebugMessage: Debug.WriteLine(message.ReadString()); break; case NetIncomingMessageType.WarningMessage: Debug.WriteLine(message.ReadString()); break; default: Debug.WriteLine("unhandled message with type: " + message.MessageType); break; } peer.Recycle(message); } }
public void ConnectToPeer(IPEndPoint endPoint) { // Create player data byte[] arrPlayer = ByteSerializer.ObjectToByteArray(localPlayer); NetOutgoingMessage om = peer.CreateMessage(arrPlayer.Length); om.Write(arrPlayer); // Connect to server peer.Connect(endPoint.Address.ToString(), endPoint.Port); }
public void Connect(IPEndPoint ipEndPoint, Packet packet) { NetOutgoingMessage outBuffer = _peer.CreateMessage(); packet.Serialize(outBuffer); _master = new Connection( ConnectionType.Master, _peer.Connect(ipEndPoint, outBuffer), ConnectionStatus.Connecting); }
public Object Listener() // Listens for incoming messages on your peer port. { NetIncomingMessage message = peer.ReadMessage(); // Reads any incoming messages assuming there are any. if (message != null) // Makes sure there actually is a message. { switch (message.MessageType) // Checks for the message type that we grabbed above. { case NetIncomingMessageType.DiscoveryRequest: // Someone is looking for you because they requested this port number. NetOutgoingMessage res = peer.CreateMessage(); // Creates a response / packet to send back. res.Write("Here!"); // Replies with "Here!" in theory you could customize this for different networks to choose what to do peer.SendDiscoveryResponse(res, message.SenderEndPoint); break; case NetIncomingMessageType.DiscoveryResponse: // Your request was received and you got a response back. peer.Connect(message.SenderEndPoint); // Since you got a message back you connect to the end point. break; case NetIncomingMessageType.Data: // You received Data or an update from a peer return(DeserializeData(message.ReadBytes(message.LengthBytes))); } } return(null); }
/// <summary> /// Подключение к другому клиенту. /// <remarks>Возможно вызвать только после подключения к сервису.</remarks> /// </summary> /// <param name="peerId">Id пира к которому подключаемся.</param> /// <param name="remotePoint">Адрес клиента</param> internal void ConnectToPeer(string peerId, IPEndPoint remotePoint) { ThrowIfDisposed(); int oldState = Interlocked.CompareExchange(ref state, (int)PeerState.ConnectedToPeers, (int)PeerState.ConnectedToService); if (oldState == (int)PeerState.NotConnected) { throw new InvalidOperationException("Peer has not right state."); } if (handler == null) { throw new InvalidOperationException("Handler not created."); } var hailMessage = handler.CreateMessage(); using (var client = ClientModel.Get()) hailMessage.Write(client.User.Nick); handler.Connect(remotePoint, hailMessage); DisconnectFromService(); ClientModel.Logger.WriteDebug("AsyncPeer.ConnectToPeer({0}, {1})", peerId, remotePoint); }
/// <summary> /// Connect to an endpoint /// </summary> /// <param name="ipaddress">The IP address to connect to</param> public void Connect(string address) { ServerAddress = address; log.Debug("Connecting to: " + ServerAddress + ":" + Configuration.ApplicationPort); if (Role == NetworkRole.Client) { if (ServerAddress == null) { string errorMessage = "Bad server address."; log.Error(errorMessage); throw new RedGrinException(errorMessage); } try { network.Connect(address, Configuration.ApplicationPort); } catch (Exception ex) { throw new RedGrinException(ex.Message); } // TODO: set specific server connection variable here? } else { string errorMessage = "Cannot connect while running as Server."; log.Error(errorMessage); throw new RedGrinException(errorMessage); } }
/// <inheritdoc /> public void ClientConnect(string host, int port, string userNameRequest) { DebugTools.Assert(!IsServer, "Should never be called on the server."); DebugTools.Assert(!IsConnected); if (IsRunning) { ClientDisconnect("Client left server."); } // Set up NetPeer. var endPoint = NetUtility.Resolve(host, port); Logger.InfoS("net", $"Connecting to {endPoint}..."); var config = _getBaseNetPeerConfig(); if (endPoint.AddressFamily == AddressFamily.InterNetworkV6) { config.LocalAddress = IPAddress.IPv6Any; } else { config.LocalAddress = IPAddress.Any; } var peer = new NetPeer(config); peer.Start(); _netPeers.Add(peer); var hail = peer.CreateMessage(); hail.Write(userNameRequest); peer.Connect(host, port, hail); }
public void AcceptConnection() { if (pendingConnectRequester != null) { peer.Connect(pendingConnectRequester); } }
public ConnectionId Connect(IPEndPoint endpoint) { var connection = _netPeer.Connect(endpoint); var connectionId = _connectionIdPool.Pop(); AddConnection(connectionId, connection); return(connectionId); }
public void Connect(ConnectionId connectionId, ApprovalSecret approvalSecret, IPEndPoint endpoint) { var approvalSecretMessage = _netPeer.CreateMessage(); approvalSecretMessage.Write(approvalSecret.Value); var connection = _netPeer.Connect(endpoint, approvalSecretMessage); AddConnection(connectionId, connection); }
public void connectToPeer(NetIncomingMessage recipient, int charNum) { NetOutgoingMessage name = peer.CreateMessage(this.name); name.Write((int)charNum); peer.Connect(recipient.SenderEndPoint.Address.ToString(), recipient.SenderEndPoint.Port, name); //this.NetWorker.challenger = recipient; }
public Peer(string app, string nick, string host, int port) { Nick = nick; var conf = new NetPeerConfiguration(app); netPeer = new NetClient(conf); netPeer.Start(); connections[SERVER_NICK] = netPeer.Connect(host, port); Send(SERVER_NICK, new ConnectMessage(), DeliveryMethod.Reliable); }
static public void Connect(string ip) { Config = new NetPeerConfiguration(ApplicationName); NetworkHandler = new NetClient(Config); { NetworkHandler.Start(); NetworkHandler.Connect(ip, Port); } Server = false; }
public override void Start() { base.Start(); var approval = NetPeer.CreateMessage(); approval.Write("Approve me please, there might be token"); NetPeer.Connect(_options.ServerHost, _options.ServerPort, approval); Logger.LogInformation($"Send connection approval to {_options.ServerHost}:{_options.ServerPort}"); }
static void Main(string[] args) { var config = new NetPeerConfiguration("MultiPlayer"); config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); config.EnableMessageType(NetIncomingMessageType.ConnectionApproval); config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); config.AcceptIncomingConnections = true; config.Port = 5002; var Me = new NetPeer(config); Me.Start(); Me.DiscoverLocalPeers(5001); while (true) { NetIncomingMessage message; while ((message = Me.ReadMessage()) != null) { switch (message.MessageType) { case NetIncomingMessageType.Data: Console.WriteLine(message.ReadString()); break; case NetIncomingMessageType.DiscoveryRequest: var response = Me.CreateMessage("Uuum hi..?"); Me.SendDiscoveryResponse(response, message.SenderEndPoint); Console.WriteLine($"Someone at {message.SenderEndPoint.Address} is attempting to discover us!"); break; case NetIncomingMessageType.DiscoveryResponse: Me.Connect(message.SenderEndPoint); Console.WriteLine($"Peer discovered at {message.SenderEndPoint.Address}. Attempting to connect."); //TODO connect? break; case NetIncomingMessageType.ConnectionApproval: message.SenderConnection.Approve(); Console.WriteLine($"Uuum. Someone connected. I don't really know what to do now..."); break; case NetIncomingMessageType.StatusChanged: Console.WriteLine(message.ReadString()); break; default: Console.WriteLine(message.ReadString()); break; } } } }
public void Connect(IPEndPoint ipEndPoint, Packet packet) { NetOutgoingMessage outMessage = _peer.CreateMessage(); packet.Serialize(outMessage); _connection = new Connection( ConnectionType.Server, _peer.Connect(ipEndPoint, outMessage), ConnectionStatus.Connecting); }
/// <summary> /// Connects to a server. Throws an exception if you attempt to call Connect as a Server. /// </summary> public void Connect(string ip) { if (mRole == AgentRole.Client) { mPeer.Connect(ip, port); } else { throw new SystemException("Attempted to connect as server. Only clients should connect."); } }
public void Connect(string ip) { if (_role == AgentRole.Client) { Log("Connecting to " + ip + ":" + _port); _peer.Connect(ip, _port); } else { throw new SystemException("Attempted to connect as server. Only clients should connect."); } }
public Client(string ip, int port) { try { ecdhrsaProvider = new ECDHRSAProvider(); NetPeerConfiguration config = new NetPeerConfiguration("GJABD_GAME"); config.EnableUPnP = true; config.LocalAddress = IPAddress.Any; /* FOR PRODUCTION * config.PingInterval = 5f; * config.ConnectionTimeout = 10f; * config.ResendHandshakeInterval = 1f; * config.MaximumHandshakeAttempts = 2; */ netPeer = new NetPeer(config); netPeer.Start(); // needed for initialization Console.WriteLine("started peer"); NetOutgoingMessage sendMsg = netPeer.CreateMessage(); sendMsg.Write("RELEASE_GAME_WEB"); sendMsg.Write(ClientConstants.version.ToString()); //send authentication public key and verifications. SecureMessageEncoder sem = new SecureMessageEncoder(sendMsg); sem.WriteBytes(ecdhrsaProvider.GetECDHPublicKey()); sem.WriteBytes(ecdhrsaProvider.GetSignedHash()); sem.WriteBytes(ecdhrsaProvider.GetRSAPublicKey()); sendMsg = sem.PackAndGet(); IPEndPoint ipEnd = new IPEndPoint(IPAddress.Parse(ip), port); NetConnection connection = netPeer.Connect(ipEnd, sendMsg); Console.WriteLine("connected to server"); // in your separate thread while (netPeer.MessageReceivedEvent.WaitOne()) { NetIncomingMessage msg = netPeer.ReadMessage(); CMessageParseManager.parseMessage(msg, this); netPeer.Recycle(msg); Console.WriteLine("Unique identifier is " + NetUtility.ToHexString(netPeer.UniqueIdentifier)); } } catch (Exception e) { Console.WriteLine(e); } }
void Start() { MyNetwork = GetComponent <MyNetwork>(); NetPeerConfiguration config = new NetPeerConfiguration(appName); peer = new NetClient(config); peer.Start(); NetOutgoingMessage approval = peer.CreateMessage(); connection = peer.Connect("localhost", 3000, approval); }
private static void HandleMessage(NetMessageType type, NetConnection source, NetBuffer buffer) { switch (type) { case NetMessageType.StatusChanged: if (source.LocalHailData == null) { source.LocalHailData = Encoding.ASCII.GetBytes("Hi; I'm " + s_peer.GetHashCode()); } if (source.RemoteHailData != null) { WriteToConsole("New status: " + source.Status + " - remote hail is: " + Encoding.ASCII.GetString(source.RemoteHailData)); } else { WriteToConsole("New status: " + source.Status + " - remote hail is null"); } break; case NetMessageType.DebugMessage: case NetMessageType.VerboseDebugMessage: case NetMessageType.BadMessageReceived: case NetMessageType.ConnectionRejected: WriteToConsole(buffer.ReadString()); break; case NetMessageType.Data: WriteToConsole(source.RemoteEndpoint + " writes: " + buffer.ReadString()); break; case NetMessageType.ServerDiscovered: // discovered another peer! s_peer.Connect(buffer.ReadIPEndPoint(), Encoding.ASCII.GetBytes("Hi; I'm " + s_peer.GetHashCode())); break; default: // unhandled break; } }
public static void HandlePeerMessages(object peer) { if (peer is NetPeer) { NetPeer p = ((NetPeer)peer); NetIncomingMessage msg = ((NetPeer)peer).ReadMessage(); string machineName; switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: if (!peers.ContainsKey(msg.SenderEndpoint)) { Console.WriteLine("DiscoveryRequest from " + msg.SenderEndpoint.Address + " port: " + msg.SenderEndpoint.Port); NetOutgoingMessage requestResponse = p.CreateMessage(); requestResponse.Write(Environment.MachineName); p.SendDiscoveryResponse(requestResponse, msg.SenderEndpoint); } break; case NetIncomingMessageType.DiscoveryResponse: machineName = msg.ReadString(); Boolean connectedToPeer = false; foreach (NetConnection conn in p.Connections) { if (conn.RemoteEndpoint == msg.SenderEndpoint) { connectedToPeer = true; } } if (!connectedToPeer) { if (!peers.ContainsKey(msg.SenderEndpoint)) { Console.WriteLine("DiscoveryResponse from " + msg.SenderEndpoint.Address + " port: " + msg.SenderEndpoint.Port + " machine name: " + machineName); peers.Add(msg.SenderEndpoint, machineName); } NetOutgoingMessage hailMessage = p.CreateMessage(); hailMessage.Write(Environment.MachineName); NetConnection senderConn = p.Connect(msg.SenderEndpoint, hailMessage); } break; } p.Recycle(msg); } }
/// <inheritdoc /> public void ClientConnect(string host, int port) { Debug.Assert(_netPeer != null); Debug.Assert(!IsServer, "Should never be called on the server."); if (_netPeer.ConnectionsCount > 0) { ClientDisconnect("Client left server."); } Logger.Info($"[NET] Connecting to {host}:{port}..."); _netPeer.Connect(host, port); }
public bool Connect() { if (mNetwork.Configuration.IsServer) { throw new InvalidOperationException("Server interfaces cannot use Connect()."); } Log.Info($"Connecting to {mNetwork.Configuration.Host}:{mNetwork.Configuration.Port}..."); var handshakeSecret = new byte[32]; mRng.GetNonZeroBytes(handshakeSecret); var connectionRsa = new RSACryptoServiceProvider(2048); var hailParameters = connectionRsa.ExportParameters(false); var hail = new HailPacket(mRsa, handshakeSecret, SharedConstants.VersionData, hailParameters); hail.Encrypt(); var hailMessage = mPeer.CreateMessage(hail.Data.Length); if (hailMessage == null) { throw new InvalidOperationException(); } hailMessage.Data = hail.Data; hailMessage.LengthBytes = hail.Data.Length; if (mPeer.Status == NetPeerStatus.NotRunning) { mPeer.Start(); } var connection = mPeer.Connect(mNetwork.Configuration.Host, mNetwork.Configuration.Port, hailMessage); var server = new LidgrenConnection( mNetwork, Guid.Empty, connection, handshakeSecret, connectionRsa.ExportParameters(true) ); if (mNetwork.AddConnection(server)) { return(true); } Log.Error("Failed to add connection to list."); connection?.Disconnect("client_error"); return(false); }
void HandleWebConnections() { NetIncomingMessage message; while ((message = peer.ReadMessage()) != null) { switch (message.MessageType) { case NetIncomingMessageType.Data: // data code break; case NetIncomingMessageType.StatusChanged: switch (message.SenderConnection.Status) { case NetConnectionStatus.Connected: Debug.WriteLine("Connected!"); break; case NetConnectionStatus.Disconnected: ship2 = null; Debug.WriteLine("Disconnected..."); break; } break; case NetIncomingMessageType.DiscoveryResponse: peer.Connect("176.135.163.41", 8000, peer.CreateMessage("yes")); break; case NetIncomingMessageType.DiscoveryRequest: var msg = peer.CreateMessage(); msg.Write("hi"); peer.SendDiscoveryResponse(msg, message.SenderEndPoint); break; case NetIncomingMessageType.DebugMessage: Console.WriteLine(message.ReadString()); break; default: Console.WriteLine("unhandled message with type: " + message.MessageType); break; } peer.Recycle(message); } }
public void AttemptToReconnect(object state) { UDPClient aTimer = (UDPClient)state; if (myServerConnection == null || myServerConnection.Peer.ConnectionsCount != 1) { IsUpdateServerActive?.Invoke(false); aTimer.isConnected = false; myServerConnection = myPeer.Connect(myEndpoint2); } else { IsUpdateServerActive?.Invoke(true); aTimer.isConnected = true; aTimer.OnConnect?.Invoke(); } }
public void Start() { session.Connect("localhost", 50000); //session.UPnP.ForwardPort(55500, ""); /*string whatIsMyIp = "http://roadaddicts.site11.com/"; * Regex ipRegex = new Regex(@"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b"); * WebClient wc = new WebClient(); * UTF8Encoding utf8 = new UTF8Encoding(); * string requestHtml = ""; * try * { * requestHtml = utf8.GetString(wc.DownloadData(whatIsMyIp)); * } * catch (WebException we) * { * // do something with exception * Console.Write(we.ToString()); * } * Console.WriteLine(requestHtml); * string ip = "216.239.66.84"; * Console.Write("Enter port "); * int port = Int32.Parse(Console.ReadLine()); * Stopwatch watch = Stopwatch.StartNew(); * while(watch.ElapsedMilliseconds < 15000) * { * packetWriter = session.CreateMessage(); * packetWriter.Write("hello"); * session.SendUnconnectedMessage(packetWriter, ip, port); * System.Threading.Thread.Sleep(1000); * session.DiscoverKnownPeer(ip, port); * System.Threading.Thread.Sleep(1000); * receiveMessage(); * }*/ while (true) { receiveMessage(); if (pingSent == false) { pingSent = true; System.Threading.Thread.Sleep(100); watch = Stopwatch.StartNew(); sendPing(); } } }
/// <inheritdoc /> public void ClientConnect(string host, int port, string userNameRequest) { DebugTools.Assert(_netPeer != null); DebugTools.Assert(!IsServer, "Should never be called on the server."); DebugTools.Assert(!IsConnected); if (_netPeer.ConnectionsCount > 0) { ClientDisconnect("Client left server."); } Logger.InfoS("net", $"Connecting to {host}:{port}..."); var hail = _netPeer.CreateMessage(); hail.Write(userNameRequest); _netPeer.Connect(host, port, hail); }
internal void ConnectToService(IPEndPoint remotePoint) { ThrowIfDisposed(); if (Interlocked.CompareExchange(ref _state, (int)PeerState.ConnectedToService, (int)PeerState.NotConnected) != (int)PeerState.NotConnected) { throw new InvalidOperationException("Peer has not right state."); } if (_handler != null && _handler.Status == NetPeerStatus.Running) { throw new ArgumentException("Already runned."); } var config = new NetPeerConfiguration(NetConfigString); config.Port = 0; config.AcceptIncomingConnections = true; config.EnableMessageType(NetIncomingMessageType.ConnectionApproval); if (remotePoint.AddressFamily == AddressFamily.InterNetworkV6) { config.LocalAddress = IPAddress.IPv6Any; } _handler = new NetPeer(config); _syncContext.Send(RegisterReceived, _handler); _handler.Start(); var hail = _handler.CreateMessage(); using (var client = ClientModel.Get()) { var localPoint = new IPEndPoint(Connection.GetIpAddress(remotePoint.AddressFamily), _handler.Port); hail.Write(client.Chat.User.Nick); hail.Write(localPoint); } _serviceConnection = _handler.Connect(remotePoint, hail); ClientModel.Logger.WriteDebug("AsyncPeer.ConnectToService({0})", remotePoint); }