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