static void Main(string[] args)
{
NetPeerConfiguration config = new NetPeerConfiguration("unittests");
config.EnableUPnP = true;
NetPeer peer = new NetPeer(config);
peer.Start(); // needed for initialization
Console.WriteLine("Unique identifier is " + NetUtility.ToHexString(peer.UniqueIdentifier));
ReadWriteTests.Run(peer);
NetQueueTests.Run();
MiscTests.Run(peer);
BitVectorTests.Run();
EncryptionTests.Run(peer);
var om = peer.CreateMessage();
peer.SendUnconnectedMessage(om, new IPEndPoint(IPAddress.Loopback, 14242));
try
{
peer.SendUnconnectedMessage(om, new IPEndPoint(IPAddress.Loopback, 14242));
}
catch (NetException nex)
{
if (nex.Message != "This message has already been sent! Use NetPeer.SendMessage() to send to multiple recipients efficiently")
{
throw nex;
}
}
peer.Shutdown("bye");
// read all message
NetIncomingMessage inc;
while ((inc = peer.ReadMessage()) != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine("Peer message: " + inc.ReadString());
break;
case NetIncomingMessageType.Error:
throw new Exception("Received error message!");
}
}
Console.WriteLine("Done");
Console.ReadKey();
}
void HandleRequestHost(NetIncomingMessage inc)
{
Console.WriteLine("Sending list of " + registeredHosts.Count + " hosts to client " + inc.SenderEndpoint);
List <Int64> toRemove = new List <Int64>();
var game = inc.ReadInt32();
foreach (var kvp in registeredHosts)
{
if ((double)kvp.Value[5] + 130.0 < NetTime.Now)
{
toRemove.Add(kvp.Key);
continue;
}
//Console.WriteLine(game + " " + kvp.Value[6]);
if ((int)kvp.Value[6] == game)
{
NetOutgoingMessage om = peer.CreateMessage();
om.Write(kvp.Key);
om.Write((string)kvp.Value[2]);
om.Write((UInt16)kvp.Value[3]);
om.Write((UInt16)kvp.Value[4]);
om.Write((IPEndPoint)kvp.Value[1]);
peer.SendUnconnectedMessage(om, inc.SenderEndpoint);
}
}
foreach (var kvp in toRemove)
{
manager.Release(kvp);
registeredHosts.Remove(kvp);
}
}
/// <summary>
/// Return the list of servers that match the version specified
/// </summary>
private static void SendServerLists(NetIncomingMessage netMsg, NetPeer peer)
{
foreach (var server in ServerDictionary.Values.ToArray())
{
var msgData = MasterServerMessageFactory.CreateNewMessageData <MsReplyServersMsgData>();
msgData.Id = server.Info.Id;
msgData.ServerVersion = server.Info.ServerVersion;
msgData.Password = server.Info.Password;
msgData.Cheats = server.Info.Cheats;
msgData.Description = server.Info.Description;
msgData.DropControlOnExit = server.Info.DropControlOnExit;
msgData.DropControlOnExitFlight = server.Info.DropControlOnExitFlight;
msgData.DropControlOnVesselSwitching = server.Info.DropControlOnVesselSwitching;
msgData.ExternalEndpoint = $"{server.ExternalEndpoint.Address}:{server.ExternalEndpoint.Port}";
msgData.GameMode = server.Info.GameMode;
msgData.InternalEndpoint = $"{server.InternalEndpoint.Address}:{server.InternalEndpoint.Port}";
msgData.MaxPlayers = server.Info.MaxPlayers;
msgData.ModControl = server.Info.ModControl;
msgData.PlayerCount = server.Info.PlayerCount;
msgData.ServerName = server.Info.ServerName;
msgData.VesselUpdatesSendMsInterval = server.Info.VesselUpdatesSendMsInterval;
msgData.WarpMode = server.Info.WarpMode;
msgData.TerrainQuality = server.Info.TerrainQuality;
var msg = MasterServerMessageFactory.CreateNew <MainMstSrvMsg>(msgData);
var outMsg = peer.CreateMessage(msg.GetMessageSize());
msg.Serialize(outMsg);
peer.SendUnconnectedMessage(outMsg, netMsg.SenderEndPoint);
peer.FlushSendQueue();
msg.Recycle();
}
}
/// <summary>
/// Return the list of servers that match the version specified
/// </summary>
private static void SendServerLists(NetIncomingMessage netMsg, NetPeer peer)
{
var values = ServerDictionary.Values.OrderBy(v => v.Info.Id).ToArray();
var msgData = MasterServerMessageFactory.CreateNewMessageData <MsReplyServersMsgData>();
msgData.ServersCount = values.Length;
msgData.Id = values.Select(s => s.Info.Id).ToArray();
msgData.ServerVersion = values.Select(s => s.Info.ServerVersion).ToArray();
msgData.Cheats = values.Select(s => s.Info.Cheats).ToArray();
msgData.Description = values.Select(s => s.Info.Description).ToArray();
msgData.DropControlOnExit = values.Select(s => s.Info.DropControlOnExit).ToArray();
msgData.DropControlOnExitFlight = values.Select(s => s.Info.DropControlOnExit).ToArray();
msgData.DropControlOnVesselSwitching = values.Select(s => s.Info.DropControlOnExit).ToArray();
msgData.ExternalEndpoint = values.Select(s => $"{s.ExternalEndpoint.Address}:{s.ExternalEndpoint.Port}").ToArray();
msgData.GameMode = values.Select(s => s.Info.GameMode).ToArray();
msgData.InternalEndpoint = values.Select(s => $"{s.InternalEndpoint.Address}:{s.InternalEndpoint.Port}").ToArray();
msgData.MaxPlayers = values.Select(s => s.Info.MaxPlayers).ToArray();
msgData.ModControl = values.Select(s => s.Info.ModControl).ToArray();
msgData.PlayerCount = values.Select(s => s.Info.PlayerCount).ToArray();
msgData.ServerName = values.Select(s => s.Info.ServerName).ToArray();
msgData.VesselUpdatesSendMsInterval = values.Select(s => s.Info.VesselUpdatesSendMsInterval).ToArray();
msgData.WarpMode = values.Select(s => s.Info.WarpMode).ToArray();
msgData.TerrainQuality = values.Select(s => s.Info.TerrainQuality).ToArray();
var msg = MasterServerMessageFactory.CreateNew <MainMstSrvMsg>(msgData);
var outMsg = peer.CreateMessage(msg.GetMessageSize());
msg.Serialize(outMsg);
peer.SendUnconnectedMessage(outMsg, netMsg.SenderEndPoint);
peer.FlushSendQueue();
msg.Recycle();
}
public static void RequestNATIntroduction(IPEndPoint host, NetPeer peer)
{
if (host == null)
{
return;
}
if (m_masterServer == null)
{
throw new Exception("Must connect to master server first!");
}
NetOutgoingMessage om = peer.CreateMessage();
om.Write((byte)2); // NAT intro request
// write internal ipendpoint
IPAddress addr = IPAddress.Parse(GetMyLocalIpAddress());
om.Write(new IPEndPoint(addr, peer.Port));
// write external address of host to request introduction to
IPEndPoint hostEp = new IPEndPoint(host.Address, port);
om.Write(hostEp);
om.Write(peer.Configuration.AppIdentifier); // send the app id
peer.SendUnconnectedMessage(om, m_masterServer);
}
/// <summary>
/// Return the list of servers that match the version specified
/// </summary>
private static void SendServerLists(NetIncomingMessage netMsg, NetPeer peer, string version)
{
var values = ServerDictionary.Values.Where(s => s.Info.Version == version).OrderBy(v => v.Info.Id);
var msgData = new MsReplyServersMsgData
{
Id = values.Select(s => s.Info.Id).ToArray(),
Cheats = values.Select(s => s.Info.Cheats).ToArray(),
Description = values.Select(s => s.Info.Description).ToArray(),
DropControlOnExit = values.Select(s => s.Info.DropControlOnExit).ToArray(),
DropControlOnExitFlight = values.Select(s => s.Info.DropControlOnExit).ToArray(),
DropControlOnVesselSwitching = values.Select(s => s.Info.DropControlOnExit).ToArray(),
ExternalEndpoint = values.Select(s => s.ExternalEndpoint.Address + ":" + s.ExternalEndpoint.Port).ToArray(),
GameMode = values.Select(s => s.Info.GameMode).ToArray(),
InternalEndpoint = values.Select(s => s.InternalEndpoint.Address + ":" + s.InternalEndpoint.Port).ToArray(),
MaxPlayers = values.Select(s => s.Info.MaxPlayers).ToArray(),
ModControl = values.Select(s => s.Info.ModControl).ToArray(),
PlayerCount = values.Select(s => s.Info.PlayerCount).ToArray(),
ServerName = values.Select(s => s.Info.ServerName).ToArray(),
VesselUpdatesSendMsInterval = values.Select(s => s.Info.VesselUpdatesSendMsInterval).ToArray(),
WarpMode = values.Select(s => s.Info.WarpMode).ToArray()
};
var msg = MasterServerMessageFactory.CreateNew <MainMstSrvMsg>(msgData);
var data = MasterServerMessageFactory.Serialize(msg);
var outMsg = peer.CreateMessage(data.Length);
outMsg.Write(data);
peer.SendUnconnectedMessage(outMsg, netMsg.SenderEndPoint);
peer.FlushSendQueue();
}
internal static void Send(string host, int port, string text)
{
NetOutgoingMessage om = Peer.CreateMessage();
om.Write(text);
Peer.SendUnconnectedMessage(om, host, port);
}
internal static void SendErrorResponse(NetPeer peer, IPEndPoint recipientEndPoint, MasterServerMessageType requestType, MasterServerMessageResult error)
{
var response = peer.CreateMessage();
response.Write((byte)requestType);
response.Write((byte)error);
peer.SendUnconnectedMessage(response, recipientEndPoint);
}
private IEnumerator GetExternalEP(IPEndPoint sendEP = null)
{
while (masterServer == null)
{
yield return(new WaitForSeconds(0.1f));
}
NetOutgoingMessage msg = client.CreateMessage();
msg.Write((byte)MasterServerMessageType.RequestExternalEP);
msg.Write(sendEP != null); // return end point
if (sendEP != null)
{
msg.Write(sendEP);
}
client.SendUnconnectedMessage(msg, masterServer);
}
public static void SendUnconnectedMessage(NetOutgoingMessage message,
string ip,
int port)
{
if (connection != null)
{
peer.SendUnconnectedMessage(message, ip, port);
}
}
internal static void RequestGeneralInfo(NetPeer peer)
{
var request = peer.CreateMessage();
request.Write(NetworkSettings.GameAppId);
request.Write(NetworkSettings.MasterServerPayload); // Note that payload does not need to match to get general info
request.Write((byte)MasterServerMessageType.RequestGeneralInfo);
peer.SendUnconnectedMessage(request, ResolveEndPoint());
}
internal static void RequestHosts(NetPeer peer)
{
var request = peer.CreateMessage();
request.Write(NetworkSettings.GameAppId);
request.Write(NetworkSettings.MasterServerPayload);
request.Write((byte)MasterServerMessageType.RequestHosts);
peer.SendUnconnectedMessage(request, ResolveEndPoint());
}
public void OpenHostedGame(NetPeer serverPeer)
{
Console.WriteLine("Open Game");
var msg = serverPeer.CreateMessage();
var data = JsonConvert.SerializeObject(HostedGame);
msg.Write(data);
serverPeer.SendUnconnectedMessage(msg, GlobalLobbyHost, GlobalLobbyUdpPort);
}
internal static void SendRequestGeneralInfoResponse(NetPeer peer, IPEndPoint recipientEndPoint, string generalInfo)
{
var response = peer.CreateMessage();
response.Write((byte)MasterServerMessageType.RequestGeneralInfo);
response.Write((byte)MasterServerMessageResult.Ok);
response.Write(generalInfo);
peer.SendUnconnectedMessage(response, recipientEndPoint);
}
private static void GetServerList(NetPeer netPeer)
{
MonoGamerPeer.m_masterServer = new IPEndPoint(NetUtility.Resolve(MonoGamerPeer.masterServer), MonoGamerPeer.masterserverport);
NetOutgoingMessage message = netPeer.CreateMessage();
message.Write((byte)1);
message.Write(netPeer.get_Configuration().get_AppIdentifier());
netPeer.SendUnconnectedMessage(message, MonoGamerPeer.m_masterServer);
}
/// <summary>Send a generic punch message, with no expectation of response</summary>
public void GenericPunch(IPEndPoint endpoint)
{
if (netPeer != null && netPeer.Status == NetPeerStatus.Running)
{
var message = netPeer.CreateMessage();
// Deliberately zero-length message
netPeer.SendUnconnectedMessage(message, endpoint);
}
}
/// <summary>
/// Contacts the Master Server on the net and gets a list of available host games
/// </summary>
/// <param name="netPeer"></param>
private static void GetServerList(NetPeer netPeer)
{
m_masterServer = new IPEndPoint(NetUtility.Resolve(masterServer), masterserverport);
NetOutgoingMessage listRequest = netPeer.CreateMessage();
listRequest.Write((byte)1);
listRequest.Write(netPeer.Configuration.AppIdentifier);
netPeer.SendUnconnectedMessage(listRequest, m_masterServer);
}
internal static void RequestIntroduction(NetPeer peer, Guid guid, IPEndPoint internalIp)
{
var request = peer.CreateMessage();
request.Write(NetworkSettings.GameAppId);
request.Write(NetworkSettings.MasterServerPayload);
request.Write((byte)MasterServerMessageType.RequestIntroduction);
request.Write(guid.ToString());
request.Write(internalIp);
peer.SendUnconnectedMessage(request, ResolveEndPoint());
}
public void SendUnconnected(IPEndPoint endPoint, NetBuffer buffer)
{
var message = _netPeer.CreateMessage();
if (buffer.LengthBytes > 0)
{
message.Write(buffer);
}
Console.WriteLine("Sending data " + buffer.ToHexString() + " to " + endPoint);
_netPeer.SendUnconnectedMessage(message, endPoint);
}
internal static void UnregisterHost(NetPeer peer, Guid guid)
{
var request = peer.CreateMessage();
request.Write(NetworkSettings.GameAppId);
request.Write(NetworkSettings.MasterServerPayload);
request.Write((byte)MasterServerMessageType.UnregisterHost);
request.Write(guid.ToString());
peer.SendUnconnectedMessage(request, ResolveEndPoint());
Debug.WriteLine("Unregistering with master server (Guid: " + guid + ")");
}
protected virtual void HandleOnUnconnectedMessage(NetPeer peer, NetIncomingMessage message)
{
var packetType = message.ReadString();
switch (packetType)
{
case "status":
var response = peer.CreateMessage();
response.WriteVariableInt32(peer.ConnectionsCount);
peer.SendUnconnectedMessage(response, message.SenderEndPoint);
break;
}
}
internal static void RegisterHost(NetPeer peer, Guid guid, IPEndPoint internalIp, NetworkSessionPublicInfo publicInfo)
{
var request = peer.CreateMessage();
request.Write(NetworkSettings.GameAppId);
request.Write(NetworkSettings.MasterServerPayload);
request.Write((byte)MasterServerMessageType.RegisterHost);
request.Write(guid.ToString());
request.Write(internalIp);
publicInfo.Pack(request);
peer.SendUnconnectedMessage(request, ResolveEndPoint());
Debug.WriteLine("Registering with master server (Guid: " + guid + ", InternalIp: " + internalIp + ", PublicInfo: ...)");
}
public void SendUnconnectedMessage(Message message, string host, int port)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (host == null)
{
throw new ArgumentNullException("host");
}
var outgoingMsg = netPeer.CreateMessage();
message.WritePayload(outgoingMsg);
netPeer.SendUnconnectedMessage(outgoingMsg, host, port);
//Trace.WriteLine("Sent " + ((CustomMessageType)message.MessageType).ToString() + " unconnected to " + host + ":" + port.ToString() + ".");
if (OnUnconnectedMessageSent != null)
{
OnUnconnectedMessageSent(this, new UnconnectedSendMessageEventArgs(message, new DnsEndPoint(host, port)));
}
}
internal static void SendRequestHostsResponse(NetPeer peer, IPEndPoint recipientEndPoint, bool localDiscovery, Guid guid, NetworkSessionPublicInfo publicInfo)
{
var response = peer.CreateMessage();
response.Write((byte)MasterServerMessageType.RequestHosts);
response.Write((byte)MasterServerMessageResult.Ok);
response.Write(guid.ToString());
publicInfo.Pack(response);
if (localDiscovery)
{
peer.SendDiscoveryResponse(response, recipientEndPoint);
}
else
{
peer.SendUnconnectedMessage(response, recipientEndPoint);
}
}
public static void sendMessage(NetPeer peer, string adr, short port, string msg)
{
var om = peer.CreateMessage();
om.Write(msg);
try
{
peer.SendUnconnectedMessage(om, new IPEndPoint(NetUtility.Resolve(adr), port));
}
catch (NetException nex)
{
if (nex.Message != "This message has already been sent! Use NetPeer.SendMessage() to send to multiple recipients efficiently")
{
throw;
}
}
}
protected virtual void HandleOnUnconnectedMessage(NetPeer peer, NetIncomingMessage message)
{
try
{
var packetType = message.ReadString();
switch (packetType)
{
case "status":
var response = peer.CreateMessage();
response.WriteVariableInt32(Player.OnlineCount);
peer.SendUnconnectedMessage(response, message.SenderEndPoint);
break;
}
}
catch (Exception exception)
{
Log.Error(exception);
}
}
private void HandleSideChannelVerify(NetIncomingMessage message)
{
ulong sideChannelId;
int token;
try
{
sideChannelId = message.ReadUInt64();
token = message.ReadInt32();
}
catch
{
owner.UnconnectedProtocolError("Bad verify request");
return;
}
if (token == 0)
{
return;
}
int expectedToken;
if (authTokens != null && authTokens.TryGetValue(sideChannelId, out expectedToken) && expectedToken == token)
{
owner.Log("Sending verify to " + message.SenderEndPoint);
// TODO: This is open to being spoofed (do we care? -- put verification we connected to the right game in the side-channel?)
var response = NetPeer.CreateMessage();
response.Write((byte)(UnconnectedMessage.SideChannelVerifyResponse));
response.Write(sideChannelId);
response.Write(token);
NetPeer.SendUnconnectedMessage(response, message.SenderEndPoint);
}
else
{
#if DEBUG
owner.UnconnectedProtocolError("Bad verify request (not authorised)");
#endif
}
}
public static void RequestNATIntroduction(IPEndPoint host, NetPeer peer)
{
if (host == null)
{
return;
}
if (MonoGamerPeer.m_masterServer == null)
{
throw new Exception("Must connect to master server first!");
}
NetOutgoingMessage message = peer.CreateMessage();
message.Write((byte)2);
IPAddress address = IPAddress.Parse(MonoGamerPeer.GetMyLocalIpAddress());
message.Write(new IPEndPoint(address, peer.get_Port()));
IPEndPoint ipEndPoint = new IPEndPoint(host.Address, MonoGamerPeer.port);
message.Write(ipEndPoint);
message.Write(peer.get_Configuration().get_AppIdentifier());
peer.SendUnconnectedMessage(message, MonoGamerPeer.m_masterServer);
}
internal void WaitConnection(IPEndPoint waitingPoint)
{
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.");
}
// Creating and sending message that be pierce NAT
// and creates possibility accept incoming message
var holePunchMessage = _handler.CreateMessage();
holePunchMessage.Write((byte)0);
_handler.SendUnconnectedMessage(holePunchMessage, waitingPoint);
DisconnectFromService();
_logger.WriteDebug("AsyncPeer.WaitConnection({0})", waitingPoint);
}
internal void WaitConnection(IPEndPoint waitingPoint)
{
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.");
}
// Создания и отправка сообщения для пробивания NAT,
// и возможности принять входящее соединение
var holePunchMessage = _handler.CreateMessage();
holePunchMessage.Write((byte)0);
_handler.SendUnconnectedMessage(holePunchMessage, waitingPoint);
DisconnectFromService();
ClientModel.Logger.WriteDebug("AsyncPeer.WaitConnection({0})", waitingPoint);
}
