public Boolean startHTTPListener()
{
try
{
if (listener.IsListening)
{
return(true);
}
string prefix = "http://+:" + listenerHttpPort + "/";
AddPortToFirewall(listenerHttpPort);
listener.Prefixes.Clear();
listener.Prefixes.Add(prefix);
listener.Start();
if (listenerThread == null)
{
listenerThread = new Thread(HandleRequests);
listenerThread.Start();
}
}
catch (Exception)
{
return(false);
}
peer.Start();
peer.DiscoverLocalPeers(peer.Port);
peerTimer.Enabled = true;
return(true);
}
/// <summary>
/// Sends discovery packets to all servers on the local network
/// </summary>
public void DiscoverServers()
{
// Discover local peers :D
myPeer.DiscoverLocalPeers(NetSettings.DEFAULT_SERVER_PORT);
myPeer.DiscoverLocalPeers(NetSettings.DEFAULT_SERVER_PORT + 1);
myPeer.DiscoverLocalPeers(NetSettings.DEFAULT_SERVER_PORT + 2);
myPeer.DiscoverLocalPeers(NetSettings.DEFAULT_SERVER_PORT + 3);
try
{
// Get the IP range to ping
IPSegment segment = new IPSegment(NetUtils.GetGateway(myAddress).ToString(), NetUtils.GetSubnetMask(myAddress).ToString());
// Get an enumerable result
IEnumerable <uint> hosts = segment.Hosts();
// Iterate and ping each one
foreach (uint host in hosts)
{
myPeer.DiscoverKnownPeer(host.ToIpString(), NetSettings.DEFAULT_SERVER_PORT);
}
}
catch (Exception e)
{
Logger.Write("Failed to ping local servers");
MessageBox.Show("Failed to discover local servers, please make sure you don't have any weird networking", "Whoops", MessageBoxButtons.OK);
}
}
public static void SendMCL()
{
Console.WriteLine("Enter Port: ");
int port = int.Parse(Console.ReadLine());
NetPeerConfiguration config = new NetPeerConfiguration("InduZtry");
config.Port = port;
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
config.EnableMessageType(NetIncomingMessageType.Data);
config.AcceptIncomingConnections = true;
//config.EnableUPnP = true;
peer = new NetPeer(config);
peer.Start();
//Console.WriteLine("UPnP IP: " + peer.UPnP.GetExternalIP());
Thread t = new Thread(RecvMCL);
t.IsBackground = true;
t.Start();
//Console.WriteLine("Enter Server IP: ");
//string sip = Console.ReadLine();
Console.WriteLine("Enter Server Port: ");
port = int.Parse(Console.ReadLine());
//peer.DiscoverKnownPeer(sip, port);
peer.DiscoverLocalPeers(port);
//while(true) {
//Thread.Sleep(10);
//Console.WriteLine("Port: ");
//int rport = int.Parse(Console.ReadLine());
//peer.DiscoverLocalPeers(rport);
//}
}
/// <summary>
/// Sends the discovery message on defined port.
/// </summary>
/// <param name="port">The port.</param>
public void SendDiscoveryMessage(int port)
{
switch (_config.SysType)
{
case SysType.Peer:
_netPeer.DiscoverLocalPeers(port);
break;
case SysType.Client:
_netClient.DiscoverLocalPeers(port);
break;
case SysType.Server:
_netServer.DiscoverLocalPeers(port);
break;
}
Status.Connecting = true;
if (_config.DiscoveryTimeout > 0)
{
_discoveryTimeout = new Timer(_config.DiscoveryTimeout);
_discoveryTimeout.Elapsed += OnDiscoveryTimeout;
_discoveryTimeout.Enabled = true;
}
}
double nextPollTime = 0; // poll network on first update
internal void Update()
{
double now = NetTime.Now;
if (nextPollTime < now)
{
nextPollTime = now + timeBetweenPolls;
// Clear out any expired games in the list:
for (int i = discoveryList.Count - 1; i >= 0; i--)
{
if (discoveryList[i].expireTime < now)
{
discoveryList.RemoveAt(i);
discoveryListDirty = true;
}
}
// Broadcast a discovery packet
foreach (int port in discoveryPorts)
{
NetPeer.DiscoverLocalPeers(port);
}
}
if (discoveryListDirty)
{
discoveryListDirty = false;
if (OnItemsChanged != null)
{
OnItemsChanged(this);
}
}
}
internal static void Input(string str)
{
if (str.StartsWith("discover "))
{
s_peer.DiscoverLocalPeers(Int32.Parse(str.Substring(9)));
return;
}
if (str.StartsWith("connect "))
{
int idx = str.IndexOf(' ', 8);
if (idx == -1)
{
// port only
s_peer.Connect("127.0.0.1", Int32.Parse(str.Substring(8)), Encoding.ASCII.GetBytes("Hi; I'm " + s_peer.GetHashCode()));
return;
}
else
{
// host and port
string host = str.Substring(8, idx - 8);
string portStr = str.Substring(idx + 1);
s_peer.Connect(host, Int32.Parse(portStr), Encoding.ASCII.GetBytes("Hi; I'm " + s_peer.GetHashCode()));
return;
}
}
NetBuffer buffer = s_peer.CreateBuffer();
buffer.Write(str);
// send to all other peers
s_peer.SendToAll(buffer, NetChannel.ReliableUnordered);
}
public static void Start()
{
Peers = new ConcurrentDictionary <long, KulamiPeer>();
NetPeerConfiguration netPeerConfiguration = new NetPeerConfiguration("HelloWorld Kulami")
{
AcceptIncomingConnections = true,
AutoFlushSendQueue = true,
PingInterval = 1f,
//ResendHandshakeInterval = 1f,
ConnectionTimeout = 7,
Port = Port,
UseMessageRecycling = false,
MaximumHandshakeAttempts = 100
};
netPeerConfiguration.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
netPeerConfiguration.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
netPeerConfiguration.EnableMessageType(NetIncomingMessageType.UnconnectedData);
netPeerConfiguration.EnableMessageType(NetIncomingMessageType.StatusChanged);
Client = new NetPeer(netPeerConfiguration);
Client.RegisterReceivedCallback(on_received_mesage);
Client.Start();
TraceHelper.WriteLine("Personal ID: {0}", Client.UniqueIdentifier);
TraceHelper.WriteLine("Broadcast: {0}", netPeerConfiguration.BroadcastAddress);
// Broadcast thread
new Thread(() =>
{
while (true)
{
Client.DiscoverLocalPeers(Port);
Thread.Sleep(2000);
}
})
{
IsBackground = true
}.Start();
// Message queue
new Thread(() =>
{
while (true)
{
Thread.Sleep(100);
// Loop through the clients, and tell them to send what's in their queue
foreach (KulamiPeer peer in Peers.Values)
{
peer.FlushQueue();
}
}
})
{
IsBackground = true
}.Start();
}
public void FindPeer(string port)
{
if (port != null && port.Length > 0)
{
peer.DiscoverLocalPeers(int.Parse(port)); // Sends out a broadcast on your local subnet looking for that port number with a message type
}
// of DiscoveryRequest, and if someone receives it they will send back a DiscoveryResponse which then we will connect to them.
}
//Obtains a list of found servers
public void discoverPeers(int port, ref List <NetIncomingMessage> peersList)
{
NetWorker.foundPeers.Clear();
peer.DiscoverLocalPeers(port);
//Thread.Sleep(1000);
//List must have something
peersList = NetWorker.foundPeers;
}
/// <summary>Inits networkssystems configures settings for lidgrens networks framework.</summary>
public override void Init()
{
_timestart = DateTime.Now;
_config = new NetPeerConfiguration("Sap6_Networking")
{
Port = _localport,
AcceptIncomingConnections = true,
UseMessageRecycling = true
};
_config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
_config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
_config.EnableMessageType(NetIncomingMessageType.UnconnectedData);
//_config.SimulatedLoss = 0.05f;
_peer = new NetPeer(_config);
_peer.Start();
_peer.DiscoverLocalPeers(_searchport);
Game1.Inst.Scene.OnEvent("send_to_peer", data => this.SendObject((string)data, "metadata"));
Game1.Inst.Scene.OnEvent("search_for_peers", data => _peer.DiscoverLocalPeers(_searchport));
Game1.Inst.Scene.OnEvent("send_start_game",
data =>
{
this.SendObject(data, "StartEvent");
_isMaster = true;
_scanForPeers = false;
});
Game1.Inst.Scene.OnEvent("send_menuitem", data =>
{
var datasend = (MenuItem)data;
this.SendObject(datasend.CText, datasend.Id);
});
DebugOverlay.Inst.DbgStr((a, b) => $"Cons: {_peer.Connections.Count} IsMaster: {_isMaster}");
DebugOverlay.Inst.DbgStr((a, b) => $"Re: {kbps} kb/s");
players.Add(new NetworkPlayer {
IP = _peer.Configuration.BroadcastAddress.ToString(), Time = _timestart, You = true
});
}
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;
}
}
}
}
void DiscoverHosts()
{
DiscoveredHosts = new Dictionary <IPEndPoint, FoundGame>();
// Send discovery signal on known ports
Console.Write("Discovering hosts");
for (int i = 0; i < 6; i++)
{
peer.DiscoverLocalPeers(Port + i);
}
// Wait for responses
for (int i = 0; i < 3; i++)
{
Thread.Sleep(500);
Console.Write(".");
}
Console.WriteLine($"\nFound {DiscoveredHosts.Count} hosts.");
}
public PentagoNetwork(string playerName)
{
lastPingTime = DateTime.Now;
nextPingTime = lastPingTime.AddSeconds(1);
availablePeers = new List <peerType>();
config = new NetPeerConfiguration("Pentago");
// Enable DiscoveryResponse messages
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
config.EnableMessageType(NetIncomingMessageType.UnconnectedData);
config.EnableMessageType(NetIncomingMessageType.Data);
config.ConnectionTimeout = 5;
config.AcceptIncomingConnections = true;
config.MaximumConnections = 32;
config.Port = PORT_NUMBER;
peer = new NetPeer(config);
try
{
peer.Start();
peerOn = true;
Console.WriteLine("Peer Started");
Thread t = new Thread(waitForMessages);
t.SetApartmentState(ApartmentState.STA);
peerName = playerName;
t.Start();
Console.WriteLine(peerName);
peer.DiscoverLocalPeers(PORT_NUMBER);
}
catch (Exception ex)
{
Console.WriteLine("Caught exception: " + ex.Data);
}
}
public void discoverPeers()
{
peer.DiscoverLocalPeers(PORT_NUMBER);
}
internal static void Find(NetworkSessionType sessionType)
{
NetPeerConfiguration config = new NetPeerConfiguration(applicationIdentifier);
if (sessionType == NetworkSessionType.PlayerMatch)
{
config.EnableMessageType(NetIncomingMessageType.UnconnectedData);
config.EnableMessageType(NetIncomingMessageType.NatIntroductionSuccess);
}
else
{
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
}
if (MonoGameNetworkConfiguration.Broadcast != IPAddress.None)
{
config.BroadcastAddress = MonoGameNetworkConfiguration.Broadcast;
}
netPeer = new NetPeer(config);
netPeer.Start();
if (sessionType == NetworkSessionType.PlayerMatch)
{
GetServerList(netPeer);
}
else
{
netPeer.DiscoverLocalPeers(port);
}
DateTime now = DateTime.UtcNow;
discoveryMsgs = new List <NetIncomingMessage> ();
do
{
NetIncomingMessage msg;
while ((msg = netPeer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryResponse:
discoveryMsgs.Add(msg);
break;
case NetIncomingMessageType.UnconnectedData:
if (msg.SenderEndPoint.Equals(m_masterServer))
{
discoveryMsgs.Add(msg);
/*
* // it's from the master server - must be a host
* IPEndPoint hostInternal = msg.ReadIPEndPoint();
* IPEndPoint hostExternal = msg.ReadIPEndPoint();
*
* m_hostList.Add(new IPEndPoint[] { hostInternal, hostExternal });
*/
}
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//
// Just print diagnostic messages to console
//
#if DEBUG
Console.WriteLine("Find: " + msg.ReadString());
#endif
break;
}
}
} while ((DateTime.UtcNow - now).Seconds <= 2);
netPeer.Shutdown("Find shutting down");
}
private static AvailableNetworkSessionCollection InternalFind(NetworkSessionType sessionType, IEnumerable <SignedInGamer> localGamers, NetworkSessionProperties searchProperties)
{
var config = new NetPeerConfiguration(NetworkSettings.GameAppId)
{
Port = 0, // Use any port
AcceptIncomingConnections = false,
};
config.EnableMessageType(NetIncomingMessageType.VerboseDebugMessage);
config.EnableMessageType(NetIncomingMessageType.UnconnectedData);
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
var discoverPeer = new NetPeer(config);
try
{
discoverPeer.Start();
}
catch (Exception e)
{
throw new InvalidOperationException("Could not start discover peer", e);
}
Debug.WriteLine("Discover peer started.");
// Discover hosts
if (sessionType == NetworkSessionType.SystemLink)
{
Debug.WriteLine("Sending local discovery request...");
discoverPeer.DiscoverLocalPeers(NetworkSettings.Port);
}
else if (sessionType == NetworkSessionType.PlayerMatch || sessionType == NetworkSessionType.Ranked)
{
Debug.WriteLine("Sending discovery request to master server...");
NetworkMasterServer.RequestHosts(discoverPeer);
}
else
{
throw new InvalidOperationException();
}
// Get list of answers
var availableSessions = new List <AvailableNetworkSession>();
var startTime = DateTime.Now;
while (DateTime.Now - startTime <= DiscoveryTimeOut)
{
var msg = discoverPeer.ReadMessage();
if (msg == null)
{
Thread.Sleep((int)NoMessageSleep.TotalMilliseconds);
continue;
}
if (msg.MessageType == NetIncomingMessageType.DiscoveryResponse)
{
Guid guid;
NetworkSessionPublicInfo publicInfo;
if (NetworkMasterServer.ParseExpectedResponseHeader(msg, MasterServerMessageType.RequestHosts) &&
NetworkMasterServer.ParseRequestHostsResponse(msg, out guid, out publicInfo))
{
AddAvailableNetworkSession(guid, publicInfo, localGamers, sessionType, searchProperties, availableSessions, tag: msg.SenderEndPoint);
}
else
{
Debug.WriteLine("Failed to parse local discovery response from " + msg.SenderEndPoint + ", ignoring...");
}
}
else if (msg.MessageType == NetIncomingMessageType.UnconnectedData)
{
if (!msg.SenderEndPoint.Equals(NetworkMasterServer.ResolveEndPoint()))
{
Debug.WriteLine("Unconnected data not from master server recieved from " + msg.SenderEndPoint + ", ignoring...");
}
else
{
Guid guid;
NetworkSessionPublicInfo publicInfo;
if (NetworkMasterServer.ParseExpectedResponseHeader(msg, MasterServerMessageType.RequestHosts) &&
NetworkMasterServer.ParseRequestHostsResponse(msg, out guid, out publicInfo))
{
AddAvailableNetworkSession(guid, publicInfo, localGamers, sessionType, searchProperties, availableSessions);
}
else
{
Debug.WriteLine("Failed to parse master server discovery response from " + msg.SenderEndPoint + ", ignoring...");
}
}
}
else
{
HandleLidgrenMessage(msg);
}
discoverPeer.Recycle(msg);
}
discoverPeer.Shutdown(string.Empty);
Debug.WriteLine("Discovery peer shut down.");
return(new AvailableNetworkSessionCollection(availableSessions));
}
/// <summary>Periodically scan for new peers</summary>
private void ScanForNewPeers()
{
_peer.DiscoverLocalPeers(_searchport);
SendPeerPlayerInfo();
}
