public Client(LengthedSocket socket, Server server)
{
Socket = socket;
Server = server;
State = ClientState.Connected;
TimeoutTime = DateTime.Now.AddMinutes(Server.Config.AuthConfig.ClientTimeout);
Socket.OnError += OnError;
Socket.OnReceive += OnReceive;
Socket.OnDecrypt += OnDecrypt;
Socket.ReceiveAsync();
var rnd = new Random();
OneTimeKey = rnd.NextUInt();
SessionId1 = rnd.NextUInt();
SessionId2 = rnd.NextUInt();
// This packet must not be encrypted, so call Socket.Send instead of SendPacket
SendPacket(new ProtocolVersionPacket(OneTimeKey));
// This is here, so ProtocolVersionPacket won't get encrypted
Socket.OnEncrypt += OnEncrypt;
Logger.WriteLog(LogType.Network, "*** Client connected from {0}", Socket.RemoteAddress);
}
private void OnAccept(LengthedSocket socket)
{
Socket.AcceptAsync();
lock (Clients)
Clients.Add(new QueueClient(this, socket));
}
public Client(LengthedSocket socket, Server server)
{
Socket = socket;
Server = server;
State = ClientState.Connected;
Timer = new Timer();
Socket.OnError += OnError;
Socket.OnReceive += OnReceive;
Socket.OnDecrypt += OnDecrypt;
Socket.ReceiveAsync();
var rnd = new Random();
OneTimeKey = rnd.NextUInt();
SessionId1 = rnd.NextUInt();
SessionId2 = rnd.NextUInt();
SendPacket(new ProtocolVersionPacket(OneTimeKey));
// This is here (after ProtocolVersionPacket), so it won't get encrypted
Socket.OnEncrypt += OnEncrypt;
Timer.Add("timeout", Server.Config.AuthConfig.ClientTimeout * 1000, false, () =>
{
Logger.WriteLog(LogType.Network, "*** Client timed out! Ip: {0}", Socket.RemoteAddress);
Close(true);
});
Logger.WriteLog(LogType.Network, "*** Client connected from {0}", Socket.RemoteAddress);
}
public Client Create(LengthedSocket socket, ClientCryptData data, Server server)
{
var client = _serviceProvider.GetService <Client>();
client.RegisterAtServer(server, socket, data);
return(client);
}
public bool Start()
{
// If no config file has been found, these values are 0 by default
if (Config.GameConfig.Port == 0 || Config.GameConfig.Backlog == 0)
{
Logger.WriteLog(LogType.Error, "Invalid config values!");
return(false);
}
Loop.Start();
SetupCommunicator();
try
{
ListenerSocket = new LengthedSocket(SizeType.Dword, false);
ListenerSocket.OnError += OnError;
ListenerSocket.OnAccept += OnAccept;
ListenerSocket.Bind(new IPEndPoint(IPAddress.Any, Config.GameConfig.Port));
ListenerSocket.Listen(Config.GameConfig.Backlog);
}
catch (Exception e)
{
Logger.WriteLog(LogType.Error, "Unable to create or start listening on the client socket! Exception:");
Logger.WriteLog(LogType.Error, e);
return(false);
}
LoginManager.OnLogin += OnLogin;
QueueManager = new QueueManager(this);
ListenerSocket.AcceptAsync();
Logger.WriteLog(LogType.Network, "*** Listening for clients on port {0}", Config.GameConfig.Port);
Timer.Add("SessionExpire", 10000, true, () =>
{
var toRemove = new List <uint>();
lock (IncomingClients)
{
toRemove.AddRange(IncomingClients.Where(ic => ic.Value.ExpireTime < DateTime.Now).Select(ic => ic.Key));
foreach (var rem in toRemove)
{
IncomingClients.Remove(rem);
}
}
});
Timer.Add("QueueManagerUpdate", Config.QueueConfig.UpdateInterval, true, () =>
{
QueueManager.Update(Config.ServerInfoConfig.MaxPlayers - CurrentPlayers);
});
return(true);
}
public virtual void Start(IPAddress bindAddress, Int32 port)
{
Socket = new LengthedSocket(LengthedSocket.SizeType.Word);
Socket.Bind(new IPEndPoint(bindAddress, port));
Socket.Listen(100);
Socket.BeginAccept(EndAccept);
}
private void OnCommunicatorAccept(LengthedSocket socket)
{
AuthCommunicator.AcceptAsync();
lock (GameServers)
GameServerQueue.Add(new CommunicatorClient(socket, this));
Logger.WriteLog(LogType.Network, $"A Game server has connected! Remote: {socket.RemoteAddress}");
}
public CommunicatorClient(LengthedSocket socket, Server server)
{
Server = server;
Socket = socket;
Socket.OnReceive += OnReceive;
Socket.OnError += OnError;
Socket.ReceiveAsync();
}
private void OnAccept(LengthedSocket newSocket)
{
ListenerSocket.AcceptAsync();
if (newSocket == null)
{
return;
}
LoginManager.LoginSocket(newSocket);
}
private void OnAccept(LengthedSocket newSocket)
{
ListenerSocket.AcceptAsync();
if (newSocket == null)
{
return;
}
lock (Clients)
Clients.Add(new Client(newSocket, this, _authUnitOfWorkFactory));
}
public QueueManager(Server server)
{
Server = server;
Socket = new LengthedSocket(SizeType.Dword, false);
Socket.OnError += OnError;
Socket.OnAccept += OnAccept;
Socket.Bind(new IPEndPoint(IPAddress.Any, Config.Port));
Socket.Listen(Config.Backlog);
Socket.AcceptAsync();
}
public void Connect(IPEndPoint server)
{
if (ConnectionState != ConnectionState.Disconnected)
{
return;
}
ServerAddress = server;
ConnectionState = ConnectionState.Connecting;
Socket = new LengthedSocket(LengthedSocket.SizeType.Word);
Socket.BeginConnect(ServerAddress, EndConnect, null);
}
public bool Start()
{
// If no config file has been found, these values are 0 by default
if (Config.AuthConfig.Port == 0 || Config.AuthConfig.Backlog == 0)
{
Logger.WriteLog(LogType.Error, "Invalid config values!");
return(false);
}
try
{
ListenerSocket = new LengthedSocket(SizeType.Word);
ListenerSocket.OnError += OnError;
ListenerSocket.OnAccept += OnAccept;
ListenerSocket.Bind(new IPEndPoint(IPAddress.Any, Config.AuthConfig.Port));
ListenerSocket.Listen(Config.AuthConfig.Backlog);
}
catch (Exception e)
{
Logger.WriteLog(LogType.Error, "Unable to create or start listening on the client socket! Exception:");
Logger.WriteLog(LogType.Error, e);
return(false);
}
Loop.Start();
if (!SetupCommunicator())
{
return(false);
}
Logger.WriteLog(LogType.Network, "*** Listening for clients on port {0}", Config.AuthConfig.Port);
ListenerSocket.AcceptAsync();
// TODO: Set up timed events (query stuff, internal communication, etc...)
Timer.Add("DisconnectTimedoutClients", 10000, true, () =>
{
lock (Clients)
foreach (var c in Clients.Where(c => c.TimeoutTime < DateTime.Now))
{
c.Close();
}
});
return(true);
}
public Client(LengthedSocket socket, AuthServer server)
{
Socket = socket;
Server = server;
RegisterHandler(ClientOpcode.AboutToPlay, MsgAboutToPlay);
RegisterHandler(ClientOpcode.Login, MsgLogin);
RegisterHandler(ClientOpcode.Logout, MsgLogout);
RegisterHandler(ClientOpcode.SCCheck, MsgSCCheck);
RegisterHandler(ClientOpcode.ServerListExt, MsgServerListExt);
Server.GenerateData(out OneTimeKey, out SessionId1, out SessionId2);
SendProtocolVersion();
Socket.SetNeedDecrypt(true);
Socket.BeginReceive(_internalBuffer, 0, 2048, EndReceive);
}
public QueueClient(QueueManager manager, LengthedSocket socket)
{
Manager = manager;
Socket = socket;
Socket.OnReceive += OnReceive;
Socket.OnError += OnError;
Socket.ReceiveAsync();
Socket.Send(new ServerKeyPacket
{
PublicKey = Manager.Config.PublicKey,
Prime = Manager.Config.Prime,
Generator = Manager.Config.Generator
});
State = QueueState.Authenticating;
}
public Server()
{
Configuration.OnLoad += ConfigLoaded;
Configuration.OnReLoad += ConfigReLoaded;
Configuration.Load();
Loop = new MainLoop(this, MainLoopTime);
PublicAddress = IPAddress.Parse(Config.GameConfig.PublicAddress);
LengthedSocket.InitializeEventArgsPool(Config.SocketAsyncConfig.MaxClients * Config.SocketAsyncConfig.ConcurrentOperationsByClient);
BufferManager.Initialize(Config.SocketAsyncConfig.BufferSize, Config.SocketAsyncConfig.MaxClients, Config.SocketAsyncConfig.ConcurrentOperationsByClient);
GameDatabaseAccess.Initialize(Config.WorldDatabaseConnectionString, Config.CharDatabaseConnectionString);
CommandProcessor.RegisterCommand("exit", ProcessExitCommand);
CommandProcessor.RegisterCommand("reload", ProcessReloadCommand);
}
public Server(IHostApplicationLifetime hostApplicationLifetime, IClientFactory clientFactory)
{
_hostApplicationLifetime = hostApplicationLifetime;
_clientFactory = clientFactory;
Configuration.OnLoad += ConfigLoaded;
Configuration.OnReLoad += ConfigReLoaded;
Configuration.Load();
Loop = new MainLoop(this, MainLoopTime);
PublicAddress = IPAddress.Parse(Config.GameConfig.PublicAddress);
LengthedSocket.InitializeEventArgsPool(Config.SocketAsyncConfig.MaxClients * Config.SocketAsyncConfig.ConcurrentOperationsByClient);
BufferManager.Initialize(Config.SocketAsyncConfig.BufferSize, Config.SocketAsyncConfig.MaxClients, Config.SocketAsyncConfig.ConcurrentOperationsByClient);
CommandProcessor.RegisterCommand("exit", ProcessExitCommand);
CommandProcessor.RegisterCommand("reload", ProcessReloadCommand);
}
private bool SetupCommunicator()
{
if (Config.CommunicatorConfig.Port == 0 || Config.CommunicatorConfig.Address == null || Config.CommunicatorConfig.Backlog == 0)
{
Logger.WriteLog(LogType.Error, "Invalid Communicator config data! Can't connect!");
return(false);
}
try
{
AuthCommunicator = new LengthedSocket(SizeType.Word);
AuthCommunicator.OnAccept += OnCommunicatorAccept;
AuthCommunicator.Bind(new IPEndPoint(IPAddress.Parse(Config.CommunicatorConfig.Address), Config.CommunicatorConfig.Port));
AuthCommunicator.Listen(Config.CommunicatorConfig.Backlog);
}
catch (Exception e)
{
Logger.WriteLog(LogType.Error, "Unable to create or start listening on the communicator socket! Exception:");
Logger.WriteLog(LogType.Error, e);
return(false);
}
AuthCommunicator.AcceptAsync();
Timer.Add("ServerInfoUpdate", 1000, true, () =>
{
lock (GameServers)
foreach (var server in GameServers)
{
if ((DateTime.Now - server.Value.LastRequestTime).TotalMilliseconds > 30000)
{
server.Value.RequestServerInfo();
}
}
});
Logger.WriteLog(LogType.Network, $"*** Listening for Game servers on port {Config.CommunicatorConfig.Port}");
return(true);
}
public Server()
{
Configuration.OnLoad += ConfigLoaded;
Configuration.OnReLoad += ConfigReLoaded;
Configuration.Load();
Loop = new MainLoop(this, MainLoopTime);
Timer = new Timer();
SetupServerList();
LengthedSocket.InitializeEventArgsPool(Config.SocketAsyncConfig.MaxClients * Config.SocketAsyncConfig.ConcurrentOperationsByClient);
BufferManager.Initialize(Config.SocketAsyncConfig.BufferSize, Config.SocketAsyncConfig.MaxClients, Config.SocketAsyncConfig.ConcurrentOperationsByClient);
AuthDatabaseAccess.Initialize(Config.DatabaseConnectionString);
CommandProcessor.RegisterCommand("exit", ProcessExitCommand);
CommandProcessor.RegisterCommand("reload", ProcessReloadCommand);
CommandProcessor.RegisterCommand("create", ProcessCreateCommand);
}
public LoginClient(LoginManager manager, LengthedSocket socket)
{
Manager = manager;
Socket = socket;
Socket.AutoReceive = false;
Socket.OnReceive += OnReceive;
Socket.OnError += OnError;
DHKeyExchange.GeneratePrivateAndPublicA(PrivateKey, PublicKey);
Socket.Send(new ServerKeyPacket
{
PublicKey = PublicKey,
Prime = DHKeyExchange.ConstantPrime,
Generator = DHKeyExchange.ConstantGenerator
});
Socket.OnEncrypt += OnEncrypt;
Socket.ReceiveAsync();
}
public void ConnectCommunicator()
{
if (AuthCommunicator?.Connected ?? false)
{
AuthCommunicator?.Close();
}
try
{
AuthCommunicator = new LengthedSocket(SizeType.Word);
AuthCommunicator.OnConnect += OnCommunicatorConnect;
AuthCommunicator.ConnectAsync(new IPEndPoint(IPAddress.Parse(Config.CommunicatorConfig.Address), Config.CommunicatorConfig.Port));
}
catch (Exception e)
{
Logger.WriteLog(LogType.Error, "Unable to create or start listening on the client socket! Retrying soon... Exception:");
Logger.WriteLog(LogType.Error, e);
}
Logger.WriteLog(LogType.Network, $"*** Connecting to auth server! Address: {Config.CommunicatorConfig.Address}:{Config.CommunicatorConfig.Port}");
}
public void RegisterAtServer(Server server, LengthedSocket socket, ClientCryptData cryptData)
{
Socket = socket;
Data = cryptData;
Server = server;
State = ClientState.Connected;
Socket.OnError += OnError;
Socket.OnReceive += OnReceive;
Socket.OnEncrypt += OnEncrypt;
Socket.OnDecrypt += OnDecrypt;
Socket.ReceiveAsync();
for (var i = 0; i < 256; ++i)
{
SendSequence[i] = 1;
}
Logger.WriteLog(LogType.Network, "*** Client connected from {0}", Socket.RemoteAddress);
}
public Server(IHostApplicationLifetime hostApplicationLifetime, IAuthUnitOfWorkFactory authUnitOfWorkFactory)
{
_hostApplicationLifetime = hostApplicationLifetime;
_authUnitOfWorkFactory = authUnitOfWorkFactory;
Configuration.OnLoad += ConfigLoaded;
Configuration.OnReLoad += ConfigReLoaded;
Configuration.Load();
Loop = new MainLoop(this, MainLoopTime);
Timer = new Timer();
SetupServerList();
LengthedSocket.InitializeEventArgsPool(Config.SocketAsyncConfig.MaxClients * Config.SocketAsyncConfig.ConcurrentOperationsByClient);
BufferManager.Initialize(Config.SocketAsyncConfig.BufferSize, Config.SocketAsyncConfig.MaxClients, Config.SocketAsyncConfig.ConcurrentOperationsByClient);
CommandProcessor.RegisterCommand("exit", ProcessExitCommand);
CommandProcessor.RegisterCommand("reload", ProcessReloadCommand);
CommandProcessor.RegisterCommand("create", ProcessCreateCommand);
}
public Client(LengthedSocket socket, ClientCryptData data, Server server)
{
_handler = new ClientPacketHandler(this);
Socket = socket;
Data = data;
Server = server;
State = ClientState.Connected;
Socket.OnError += OnError;
Socket.OnReceive += OnReceive;
Socket.OnEncrypt += OnEncrypt;
Socket.OnDecrypt += OnDecrypt;
Socket.ReceiveAsync();
for (var i = 0; i < 256; ++i)
{
SendSequence[i] = 1;
}
Logger.WriteLog(LogType.Network, "*** Client connected from {0}", Socket.RemoteAddress);
}
public void LoginSocket(LengthedSocket socket)
{
lock (Clients)
Clients.Add(new LoginClient(this, socket));
}
