325 lines
13 KiB
C#
325 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Reflection;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using LightReflectiveMirror.Endpoints;
|
|
using Mirror;
|
|
using Newtonsoft.Json;
|
|
|
|
namespace LightReflectiveMirror
|
|
{
|
|
class Program
|
|
{
|
|
public static Transport transport;
|
|
public static Program instance;
|
|
public static Config conf;
|
|
|
|
private RelayHandler _relay;
|
|
private MethodInfo _awakeMethod;
|
|
private MethodInfo _startMethod;
|
|
private MethodInfo _updateMethod;
|
|
private MethodInfo _lateUpdateMethod;
|
|
|
|
private DateTime _startupTime;
|
|
|
|
private List<int> _currentConnections = new List<int>();
|
|
public Dictionary<int, IPEndPoint> NATConnections = new Dictionary<int, IPEndPoint>();
|
|
private BiDictionary<int, string> _pendingNATPunches = new BiDictionary<int, string>();
|
|
private int _currentHeartbeatTimer = 0;
|
|
|
|
private byte[] _NATRequest = new byte[500];
|
|
private int _NATRequestPosition = 0;
|
|
|
|
private UdpClient _punchServer;
|
|
|
|
private const string CONFIG_PATH = "config.json";
|
|
|
|
public static void Main(string[] args) => new Program().MainAsync().GetAwaiter().GetResult();
|
|
|
|
public int GetConnections() => _currentConnections.Count;
|
|
public TimeSpan GetUptime() => DateTime.Now - _startupTime;
|
|
public int GetPublicRoomCount() => _relay.rooms.Where(x => x.isPublic).Count();
|
|
public List<Room> GetRooms() => _relay.rooms;
|
|
|
|
public async Task MainAsync()
|
|
{
|
|
WriteTitle();
|
|
instance = this;
|
|
_startupTime = DateTime.Now;
|
|
|
|
if (!File.Exists(CONFIG_PATH))
|
|
{
|
|
File.WriteAllText(CONFIG_PATH, JsonConvert.SerializeObject(new Config(), Formatting.Indented));
|
|
WriteLogMessage("A config.json file was generated. Please configure it to the proper settings and re-run!", ConsoleColor.Yellow);
|
|
Console.ReadKey();
|
|
Environment.Exit(0);
|
|
}
|
|
else
|
|
{
|
|
conf = JsonConvert.DeserializeObject<Config>(File.ReadAllText(CONFIG_PATH));
|
|
|
|
WriteLogMessage("Loading Assembly... ", ConsoleColor.White, true);
|
|
try
|
|
{
|
|
var asm = Assembly.LoadFile(Directory.GetCurrentDirectory() + @"\" + conf.TransportDLL);
|
|
WriteLogMessage($"OK", ConsoleColor.Green);
|
|
|
|
WriteLogMessage("\nLoading Transport Class... ", ConsoleColor.White, true);
|
|
|
|
transport = asm.CreateInstance(conf.TransportClass) as Transport;
|
|
|
|
if (transport != null)
|
|
{
|
|
var transportClass = asm.GetType(conf.TransportClass);
|
|
WriteLogMessage("OK", ConsoleColor.Green);
|
|
|
|
WriteLogMessage("\nLoading Transport Methods... ", ConsoleColor.White, true);
|
|
CheckMethods(transportClass);
|
|
WriteLogMessage("OK", ConsoleColor.Green);
|
|
|
|
WriteLogMessage("\nInvoking Transport Methods...");
|
|
|
|
if (_awakeMethod != null)
|
|
_awakeMethod.Invoke(transport, null);
|
|
|
|
if (_startMethod != null)
|
|
_startMethod.Invoke(transport, null);
|
|
|
|
WriteLogMessage("\nStarting Transport... ", ConsoleColor.White, true);
|
|
|
|
transport.OnServerError = (clientID, error) =>
|
|
{
|
|
WriteLogMessage($"Transport Error, Client: {clientID}, Error: {error}", ConsoleColor.Red);
|
|
};
|
|
|
|
transport.OnServerConnected = (clientID) =>
|
|
{
|
|
WriteLogMessage($"Transport Connected, Client: {clientID}", ConsoleColor.Cyan);
|
|
_currentConnections.Add(clientID);
|
|
_relay.ClientConnected(clientID);
|
|
|
|
if (conf.EnableNATPunchtroughServer)
|
|
{
|
|
string natID = Guid.NewGuid().ToString();
|
|
_pendingNATPunches.Add(clientID, natID);
|
|
_NATRequestPosition = 0;
|
|
_NATRequest.WriteByte(ref _NATRequestPosition, (byte)OpCodes.RequestNATConnection);
|
|
_NATRequest.WriteString(ref _NATRequestPosition, natID);
|
|
transport.ServerSend(clientID, 0, new ArraySegment<byte>(_NATRequest, 0, _NATRequestPosition));
|
|
}
|
|
};
|
|
|
|
_relay = new RelayHandler(transport.GetMaxPacketSize(0));
|
|
|
|
transport.OnServerDataReceived = _relay.HandleMessage;
|
|
transport.OnServerDisconnected = (clientID) =>
|
|
{
|
|
_currentConnections.Remove(clientID);
|
|
_relay.HandleDisconnect(clientID);
|
|
|
|
if(NATConnections.ContainsKey(clientID))
|
|
NATConnections.Remove(clientID);
|
|
|
|
if(_pendingNATPunches.TryGetByFirst(clientID, out _))
|
|
_pendingNATPunches.Remove(clientID);
|
|
};
|
|
|
|
transport.ServerStart();
|
|
|
|
WriteLogMessage("OK", ConsoleColor.Green);
|
|
|
|
if (conf.UseEndpoint)
|
|
{
|
|
WriteLogMessage("\nStarting Endpoint Service... ", ConsoleColor.White, true);
|
|
var endpoint = new EndpointServer();
|
|
|
|
if (endpoint.Start(conf.EndpointPort))
|
|
{
|
|
WriteLogMessage("OK", ConsoleColor.Green);
|
|
}
|
|
else
|
|
{
|
|
WriteLogMessage("FAILED\nPlease run as administrator or check if port is in use.", ConsoleColor.DarkRed);
|
|
}
|
|
}
|
|
|
|
if (conf.EnableNATPunchtroughServer)
|
|
{
|
|
WriteLogMessage("\nStarting NatPunchthrough Socket... ", ConsoleColor.White, true);
|
|
|
|
try
|
|
{
|
|
_punchServer = new UdpClient(conf.NATPunchtroughPort);
|
|
|
|
WriteLogMessage("OK\n", ConsoleColor.Green, true);
|
|
|
|
WriteLogMessage("\nStarting NatPunchthrough Thread... ", ConsoleColor.White, true);
|
|
var natThread = new Thread(new ThreadStart(RunNATPunchLoop));
|
|
|
|
try
|
|
{
|
|
natThread.Start();
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
WriteLogMessage("FAILED\n" + e, ConsoleColor.DarkRed);
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
WriteLogMessage("FAILED\nCheck if port is in use.", ConsoleColor.DarkRed, true);
|
|
Console.WriteLine(e);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WriteLogMessage("FAILED\nClass not found, make sure to included namespaces!", ConsoleColor.DarkRed);
|
|
Console.ReadKey();
|
|
Environment.Exit(0);
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
WriteLogMessage("FAILED\nException: " + e, ConsoleColor.DarkRed);
|
|
Console.ReadKey();
|
|
Environment.Exit(0);
|
|
}
|
|
|
|
await RegisterSelfToLoadBalancer();
|
|
}
|
|
|
|
while (true)
|
|
{
|
|
if (_updateMethod != null) _updateMethod.Invoke(transport, null);
|
|
if (_lateUpdateMethod != null) _lateUpdateMethod.Invoke(transport, null);
|
|
|
|
_currentHeartbeatTimer++;
|
|
|
|
if(_currentHeartbeatTimer >= conf.UpdateHeartbeatInterval)
|
|
{
|
|
_currentHeartbeatTimer = 0;
|
|
|
|
for(int i = 0; i < _currentConnections.Count; i++)
|
|
transport.ServerSend(_currentConnections[i], 0, new ArraySegment<byte>(new byte[] { 200 }));
|
|
|
|
GC.Collect();
|
|
}
|
|
|
|
await Task.Delay(conf.UpdateLoopTime);
|
|
}
|
|
}
|
|
|
|
|
|
async Task<bool> RegisterSelfToLoadBalancer()
|
|
{
|
|
// replace hard coded value for config value later
|
|
var url = "http://www.localhost:7070/api/auth";
|
|
string externalip = "127.0.0.1";//new WebClient().DownloadString("https://ipv4.icanhazip.com/");
|
|
string port = conf.EndpointPort.ToString();
|
|
HttpWebRequest myRequest = (HttpWebRequest)WebRequest.Create(url);
|
|
|
|
myRequest.Headers.Add("Auth", "AuthKey");
|
|
myRequest.Headers.Add("Address", $"{externalip}:" + port + "/api/stats");
|
|
|
|
try
|
|
{
|
|
WebResponse myResponse = await myRequest.GetResponseAsync();
|
|
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
// error adding or load balancer unavailable
|
|
WriteLogMessage("Error registering", ConsoleColor.Red);
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
void RunNATPunchLoop()
|
|
{
|
|
WriteLogMessage("OK\n", ConsoleColor.Green);
|
|
IPEndPoint remoteEndpoint = new IPEndPoint(IPAddress.Any, conf.NATPunchtroughPort);
|
|
|
|
// Stock Data server sends to everyone:
|
|
var serverResponse = new byte[1] { 1 };
|
|
|
|
byte[] readData;
|
|
bool isConnectionEstablishment;
|
|
int pos;
|
|
string connectionID;
|
|
|
|
while (true)
|
|
{
|
|
readData = _punchServer.Receive(ref remoteEndpoint);
|
|
pos = 0;
|
|
try
|
|
{
|
|
isConnectionEstablishment = readData.ReadBool(ref pos);
|
|
|
|
if (isConnectionEstablishment)
|
|
{
|
|
connectionID = readData.ReadString(ref pos);
|
|
|
|
if (_pendingNATPunches.TryGetBySecond(connectionID, out pos))
|
|
{
|
|
NATConnections.Add(pos, new IPEndPoint(remoteEndpoint.Address, remoteEndpoint.Port));
|
|
_pendingNATPunches.Remove(pos);
|
|
Console.WriteLine("Client Successfully Established Puncher Connection. " + remoteEndpoint.ToString());
|
|
}
|
|
}
|
|
|
|
_punchServer.Send(serverResponse, 1, remoteEndpoint);
|
|
}
|
|
catch
|
|
{
|
|
// ignore, packet got fucked up or something.
|
|
}
|
|
}
|
|
}
|
|
|
|
static void WriteLogMessage(string message, ConsoleColor color = ConsoleColor.White, bool oneLine = false)
|
|
{
|
|
Console.ForegroundColor = color;
|
|
if (oneLine)
|
|
Console.Write(message);
|
|
else
|
|
Console.WriteLine(message);
|
|
}
|
|
|
|
void CheckMethods(Type type)
|
|
{
|
|
_awakeMethod = type.GetMethod("Awake", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
_startMethod = type.GetMethod("Start", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
_updateMethod = type.GetMethod("Update", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
_lateUpdateMethod = type.GetMethod("LateUpdate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
}
|
|
|
|
void WriteTitle()
|
|
{
|
|
string t = @"
|
|
w c(..)o (
|
|
_ _____ __ __ \__(-) __)
|
|
| | | __ \ | \/ | /\ (
|
|
| | | |__) || \ / | /(_)___)
|
|
| | | _ / | |\/| | w /|
|
|
| |____ | | \ \ | | | | | \
|
|
|______||_| \_\|_| |_| m m copyright monkesoft 2021
|
|
|
|
";
|
|
|
|
string load = $"Chimp Event Listener Initializing... OK" +
|
|
"\nHarambe Memorial Initializing... OK" +
|
|
"\nBananas Initializing... OK\n";
|
|
|
|
WriteLogMessage(t, ConsoleColor.Green);
|
|
WriteLogMessage(load, ConsoleColor.Cyan);
|
|
}
|
|
}
|
|
}
|