public void LoadData()
{
Out.Info("Loading ServerList...");
Servers = ServersManager.GetServers();
Out.Info("Loading BlockedIp");
BlockedIp = AccountManager.GetBlockedIps(); Out.Debug($"{BlockedIp.Count} ips blocked");
}
public void Disconnect()
{
thread.Abort();
server.Clients.Remove(this);
socket.Dispose();
Out.Debug($" -User {Ip}");
}
private bool CheckChallengeNr(EndPoint addr, int challenge)
{
for (var i = 0; i < _serverQueryChallenges.Count; i++)
{
if (_serverQueryChallenges[i].Addr.CompareAddr(addr, true))
{
if (challenge != _serverQueryChallenges[i].Challenge)
{
return(false);
}
// allow challenge values to last for 1 hour
if (Networking.NetTime > _serverQueryChallenges[i].Time + ChallengeLifetime)
{
_serverQueryChallenges.RemoveAt(i);
Out.Warning("Old challenge from {0}", addr);
return(false);
}
return(true);
}
// clean up any old entries
if (Networking.NetTime > _serverQueryChallenges[i].Time + ChallengeLifetime)
{
_serverQueryChallenges.RemoveAt(i);
}
}
if (challenge != -1)
{
Out.Debug("No challenge from {0}", addr);
}
return(false);
}
/// <summary>
/// system.diagnostics.debug
/// </summary>
public void Debug(
string s,
bool lineBreak = false,
[CallerFilePath] string callerFilePath = "",
[CallerMemberName] string callerMemberName = "",
[CallerLineNumber] int callerLineNumber = -1)
=> Out.Debug(s, lineBreak, callerFilePath, callerMemberName, callerLineNumber);
public void Initialize(string ip, int port)
{
DateTime startTime = DateTime.Now;
Out.Info("Initializing server...");
try
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Bind(new IPEndPoint(IPAddress.Parse(ip), port));
socket.Listen(100);
Ip = ip;
Port = port;
}
catch (SocketException e)
{
Out.Error(e.Message);
Dispose();
return;
}
Clients = new Dictionary <Socket, IBaseClient>();
Servers = new Dictionary <int, WorldServer>();
Out.Info("Loading Config...");
if (!File.Exists("config.txt"))
{
Out.Error("Can't load 'config.txt' !");
Dispose();
return;
}
Config = ConfigManager.GetConfig();
if (Config.ContainsKey("Debug") && Config["Debug"] == "true")
{
Out.DebugMode = true;
}
if (Config.ContainsKey("Maintenance") && Config["Maintenance"] == "true")
{
onMaintenance = true;
}
ProtocolVersion = int.Parse(Config["ProtocolVersion"]);
if (!ConfigManager.CheckConfig(Config))
{
Dispose();
return;
}
Out.Info("Initializing database...");
DatabaseManager.Initialize(Config["Database_Host"], Config["Database_User"], Config["Database_Password"], Config["Database_Auth"]);
if (Config.ContainsKey("AuthServer_Name"))
{
Console.Title = Config["AuthServer_Name"];
}
AccountManager.Initialize(DatabaseManager.connection);
ServersManager.Initialize(DatabaseManager.connection);
LoadData();
Out.Info($"Server started successfuly (Elapsed time : {DateTime.Now.Subtract(startTime).TotalMilliseconds.ToString("### ###")} ms)");
socket.BeginAccept(AcceptCallBack, null);
Out.Debug("Waiting for clients...");
}
public static void HandleIdentification(BigEndianReader reader, AuthClient client, AuthServer server)
{
IdentificationWithLoginTokenMessage message = new IdentificationWithLoginTokenMessage();
message.Unpack(reader);
Account account = AccountManager.GetAccount(message.login);
DateTime dateNow = DateTime.Now;
//IF ACCOUNT EXIST
if (account == null ||
message.password != Tools.GetMd5(account.Password + client.Ticket)) //Test password
{
client.Send(new IdentificationFailedMessage((sbyte)IdentificationFailureReasonEnum.WRONG_CREDENTIALS));
client.Disconnect();
return;
}
client.account = account;
//IF LIFE BANNED OR IP BANNED
if (account.Banned || server.BlockedIp.Contains(client.Ip))
{
client.Send(new IdentificationFailedMessage((sbyte)IdentificationFailureReasonEnum.BANNED));
client.Disconnect();
return;
}
//IF TEMP BANNED
if (account.EndBan > dateNow)
{
int ms = 0;
ms = (int)account.EndBan.Subtract(dateNow).TotalMinutes;
client.Send(new IdentificationFailedBannedMessage((sbyte)IdentificationFailureReasonEnum.BANNED, ms));
client.Disconnect();
return;
}
//IF ON MAINTENANCE
if (AuthServer.onMaintenance && !account.isAdmin)
{
client.Send(new IdentificationFailedMessage((sbyte)IdentificationFailureReasonEnum.IN_MAINTENANCE));
client.Disconnect();
return;
}
//TODO QUEUE MANAGEMENT
if (account.Pseudo == null || account.Pseudo.Length == 0)
{
client.Send(new NicknameRegistrationMessage());
Out.Info($"First connection for account '{account.Username}'. Requesting a nickname.");
return;
}
SendAccServer(client, server);
//TODO AUTO CONNECT TO THE FIRST AVAILABLE SERVER
if (message.autoconnect)
{
//client.Send(new SelectedServerRefusedMessage(1, (sbyte)ServerConnectionErrorEnum.SERVER_CONNECTION_ERROR_DUE_TO_STATUS, (sbyte)ServerStatusEnum.NOJOIN));
Out.Debug(account.isAdmin ? $"+Admin {account.Pseudo}" : $"+User {account.Pseudo}");
}
}
public static void HandleCharacterList(BigEndianReader reader, WorldClient client, WorldServer server)
{
if (Char != null)
{
client.Send(new CharactersListMessage(false, new CharacterBaseInformations[] { Char }));
Out.Debug(Char.sex.ToString() + Char.breed.ToString(), "Infos");
return;
}
client.Send(new CharactersListMessage(false, new List <CharacterBaseInformations>()));
//TODO : Get list of characters and send them
}
public override void SendClientMessages(bool sendSnapshots)
{
var receivingClients = new List <GameClient>();
foreach (var cl in Clients)
{
var client = (GameClient)cl;
if (!client.ShouldSendMessage())
{
continue;
}
Out.Debug("Write snapshot");
if (sendSnapshots && client.IsActive())
{
receivingClients.Add(client);
}
else
{
// if client never send a netchannl packet yet, send ConnectionAccept because it could get lost in multiplayer
if (client.NetChannel.GetSequenceNr(EFlowType.Incoming) == 0)
{
Networking.OutOfBandPrintf(Socket, client.NetChannel.GetRemoteAddress(), "{0}00000000000000", (char)EConnectionType.ConnectionAccept);
}
client.NetChannel.Transmit();
client.UpdateSendState();
}
}
if (receivingClients.Count > 0)
{
// if any client wants an update, take new snapshot now
var snapshot = Program.FrameSnapshotManager.TakeTickSnapshot(TickCount);
// copy temp ents references to pSnapshot
CopyTempEntities(snapshot);
foreach (var cl in receivingClients)
{
var frame = cl.GetSendFrame();
if (frame == null)
{
continue;
}
cl.SendSnapshot(frame);
cl.UpdateSendState();
}
snapshot.ReleaseRefrence();
}
}
public void OnRequestFullUpdate()
{
// client requests a full update
_lastSnapshot = null;
// free old baseline snapshot
FreeBaselines();
Baseline = Program.FrameSnapshotManager.CreateEmptySnapshot(0, 1 << 11);
Out.Debug("Sending full update to client \"{0}\"", GetClientName());
}
//6072
public static void HandleCharacterSelectedForceReadyMessage(BigEndianReader reader, WorldClient client, WorldServer server)
{
Out.Debug(CharSelectActions.Char.name, "NAME");
client.Send(new CharacterSelectedSuccessMessage(new CharacterBaseInformations(
1,
200,
"TEST",
CharSelectActions.Char.entityLook,
1,
false
)));
}
public void AcceptCallBack(IAsyncResult result)
{
AuthClient _newClient = new AuthClient(socket.EndAccept(result), this)
{
Ticket = Tools.RandomString(32, false)
};
Out.Debug($"New socket [{_newClient.socket.RemoteEndPoint}]");
_newClient.Initialize();
Clients.Add(_newClient.socket, _newClient);
socket.BeginAccept(AcceptCallBack, null);
}
public static Dictionary <int, WorldServer> GetServers()
{
Dictionary <int, WorldServer> srvList = new Dictionary <int, WorldServer>();
var request = database.Query <WorldServer>("SELECT * FROM serverlist WHERE Usable=1", null);
foreach (var srv in request)
{
WorldServer serv = srv;
srvList.Add(serv.ServerId, serv);
Out.Debug($" +SERVER [{serv.ServerId}]\t {serv.Name} \t {serv.Status} \t {serv.Completion}");
}
return(srvList);
}
public void Initialize()
{
try
{
Send(new ProtocolRequired(AuthServer.ProtocolVersion, AuthServer.ProtocolVersion));
Send(new HelloConnectMessage(1, Ticket)); //Send password encryption key
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceiveCallBack, socket);
}
catch (Exception)
{
Out.Debug($"User {Ip} disconnected because of an error");
Disconnect();
}
}
public static void Initialize(string host, string user, string password, string database)
{
try
{
Out.Debug($"Connecting to:\n\t\tHOST = {host}\n\t\tUSER = {user}\n\t\tPWD = {password}\n\t\tDATABASE = {database}");
string m_mysql = string.Format($"server={host};database={database};uid={user};pwd={password};Allow User Variables=True");
connection = new MySqlConnection(m_mysql);
connection.Open();
Out.Debug($"Connection to database {database} openned");
}
catch (MySqlException e)
{
Out.Error(e.ToString());
}
}
public static void HandleAuthAdminCommand(BigEndianReader reader, AuthClient client, AuthServer server)
{
//TODO HANDLE AUTH COMMANDS
AdminCommandMessage message = new AdminCommandMessage();
message.Unpack(reader);
switch (message.content.Split(' ')[0])
{
default:
client.Send(new ConsoleMessage((sbyte)ConsoleMessageTypeEnum.CONSOLE_ERR_MESSAGE, "Unknown command"));
break;
}
Out.Debug($"User {client.account.Pseudo} performed command '{message.content}'");
}
public void Send(Message message)
{
try
{
using (BigEndianWriter writer = new BigEndianWriter())
{
message.Pack(writer);
socket.BeginSend(writer.Data, 0, writer.Data.Length, SocketFlags.None, new AsyncCallback(SendCallBack), socket);
Out.Debug($"{"New Packet", -12} : {message.ToString(), 36} --> {Ip, -12}");
}
}
catch (Exception e)
{
Out.Warn($" USER DISCONNECTED (sending packet) {e.Message}");
Disconnect();
}
}
public static void HandlePacket(byte[] data, WorldClient client, WorldServer server)
{
BigEndianReader reader = new BigEndianReader(data);
short header = reader.ReadShort();
uint Id = (uint)header >> 2;
uint Length = (uint)header & 3;
reader = UpdateReader(reader, Length);
if (!packetList.ContainsKey(Id))
{
Out.Warn($"Unexpected packet from { client.Ip}. Invalid packet ID[{ Id}]" +
"\nDisconnecting client");
return;
}
Out.Debug($"{"New Packet",-12} : {packetList[Id].Method.Name.Remove(0, 6),30}[{Id,4}] <-- {client.Ip,-12}");
packetList[Id](reader, client, server);
}
public void AcceptCallBack(IAsyncResult result)
{
try
{
WorldClient _newClient = new WorldClient(_world.EndAccept(result), this);
Out.Debug($"New socket [{_newClient.socket.RemoteEndPoint}]");
Clients.Add(_newClient);
}
catch (Exception e)
{
if (Clients != null)
{
Out.Error(e.Message);
}
}
_world.BeginAccept(AcceptCallBack, null);
}
public void Initialize()
{
try
{
//TODO HANDLE WORLD CONNECTION
Send(new ProtocolRequired(1375, 1375));
Send(new HelloGameMessage());
Send(new BasicTimeMessage(1, 0));
Send(new AccountCapabilitiesMessage(1, false, 16383, 4095)); //-> Binary (each bit correspond to one class)
Send(new TrustStatusMessage(true));
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceiveCallBack, socket);
}
catch (Exception e)
{
Out.Debug($"User {Ip} disconnected because of an error");
Out.Error(e.Message);
Disconnect();
}
}
public virtual void SendClientMessages(bool sendSnapshots)
{
foreach (var client in Clients)
{
if (!client.ShouldSendMessage())
{
continue;
}
if (client.NetChannel != null)
{
client.NetChannel.Transmit();
client.UpdateSendState();
}
else
{
Out.Debug("Client has no NetChannel!");
}
}
}
public void AcceptCallBack(IAsyncResult result)
{
try
{
AuthClient _newClient = new AuthClient(socket.EndAccept(result), this)
{
Ticket = Tools.RandomString(32, false)
};
Out.Debug($"New socket [{_newClient.socket.RemoteEndPoint}]");
//_newClient.Initialize();
Clients.Add(_newClient.socket, _newClient);
socket.BeginAccept(AcceptCallBack, null);
}catch (Exception e)
{
if (Clients != null)
{
Out.Error(e.Message);
}
}
}
public void ProcessConnectionlessPacket(NetPacket packet)
{
var msg = packet.Message;
var type = (EConnectionType)msg.ReadChar();
if (!CheckConnectionLessRateLimits(packet.From))
{
return;
}
switch (type)
{
case EConnectionType.GetChallenge:
ReplyChallenge(packet.From);
break;
case EConnectionType.RequestInfo:
// TODO: Responde player's info, map ect.
break;
case EConnectionType.PlayerConnect:
var protocol = msg.ReadInt();
var authProtocol = msg.ReadInt();
var challengeNr = msg.ReadInt();
var playerName = msg.ReadString();
var serverPassword = msg.ReadString();
ConnectClient(packet.From, protocol, authProtocol, challengeNr, playerName, serverPassword);
break;
default:
Out.Debug("Unknown connectionless type '{0}'!", type);
return;
}
}
public static void BuildPacket(byte[] data, AuthClient client, AuthServer server)
{
BigEndianReader reader = new BigEndianReader(data);
AuthClient cl = client;
short header = reader.ReadShort();
uint Id = (uint)header >> 2;
uint Length = (uint)header & 3;
reader = UpdateReader(reader, Length);
Out.Debug($"=> Packet[{Id}] from {client.Ip}");
#region
switch (Id)
{
case 4:
IdentificationWithLoginTokenMessage message = new IdentificationWithLoginTokenMessage();
message.Unpack(reader);
Account account = AccountManager.GetAccount(message.login);
DateTime dateNow = DateTime.Now;
List <GameServerInformations> servers = new List <GameServerInformations>();
foreach (WorldServer s in server.Servers.Values) //Load each server
{
int nbChar = AccountManager.GetNbChar(s.ServerId, account.Id);
servers.Add(new GameServerInformations((ushort)s.ServerId, (sbyte)s.Status, (sbyte)s.Completion, true, (sbyte)nbChar));
}
if (servers.Count < 1)
{
AuthServer.onMaintenance = true;
}
if (account == null ||
message.password != Tools.GetMd5(account.Password + cl.Ticket)) //Test password
{
client.Send(new IdentificationFailedMessage((sbyte)IdentificationFailureReasonEnum.WRONG_CREDENTIALS));
client.Disconnect();
return;
}
if (account.Banned) // ban a vie
{
client.Send(new IdentificationFailedMessage((sbyte)IdentificationFailureReasonEnum.BANNED));
client.Disconnect();
return;
}
if (account.EndBan > dateNow) //Ban temp
{
int ms = 0;
ms = (int)account.EndBan.Subtract(dateNow).TotalMinutes;
client.Send(new IdentificationFailedBannedMessage((sbyte)IdentificationFailureReasonEnum.BANNED, ms));
client.Disconnect();
return;
}
if (AuthServer.onMaintenance) //Maintenance (In config)
{
client.Send(new IdentificationFailedMessage((sbyte)IdentificationFailureReasonEnum.IN_MAINTENANCE));
client.Disconnect();
return;
}
client.account = account;
double msSub = 0;
if (account.EndSub > DateTime.Now)
{
msSub = account.EndSub.Subtract(DateTime.Now).TotalMilliseconds;
}
client.Send(new IdentificationSuccessMessage(account.isAdmin, true, account.Pseudo, account.Id, 0, account.Question, msSub));
Out.Debug(account.isAdmin? $"+Admin {account.Pseudo}" : $"+User {account.Pseudo}");
client.Send(new ServersListMessage(servers));
//TODO Get number of characters for each server
return;
default:
client.Disconnect();
return;
}
#endregion
}
public static void HandleCharacterCreation(BigEndianReader reader, WorldClient client, WorldServer server)
{
try
{
CharacterCreationRequestMessage message = new CharacterCreationRequestMessage();
message.Unpack(reader);
client.Send(new CharacterCreationResultMessage(0));
Thread.Sleep(1000);
int y = 0;
int[] colors = new int[5];
foreach (int x in message.colors)
{
if (y < 5 && x != -1)
{
colors[y] = (y + 1 & 255) << 24 | x & 16777215;
//((nb & 255) << 24 | color & 16777215)
y++;
}
else
{
break;
}
}
for (int x = 0; x < colors.Length; x++)
{
Out.Debug(colors[x].ToString(), "Colors");
}
//x => x.Key << 24 | x.Value.ToArgb() & 0xFFFFFF
int style = message.breed * 10;
if (message.sex)
{
style++;
}
Char = new CharacterBaseInformations(
1,
200,
message.name,
new EntityLook(1, new short[] { (short)style }, colors, new short[] { 125 }, new SubEntity[] { }),
message.breed,
message.sex);
IEnumerable <CharacterBaseInformations> chars = new List <CharacterBaseInformations>()
{
Char
};
client.Send(new CharactersListMessage(false, chars));
}
catch (Exception e)
{
Out.Error(e.Message);
}
//var_character =
//{
// Level = 1,
// Name = message.name,
// Breed = message.breed,
// Sex = message.sex,
// EntityLook = EntityManager.Instance.BuildEntityLook(message.breed, message.sex, message.colors.ToList()),
// MapId = BreedManager.Instance.GetStartMap(message.breed),
// CellId = BreedManager.Instance.GetStartCell(message.breed),
// Direction = BreedManager.Instance.GetStartDirection(message.breed),
// SpellsPoints = 1
//};
}
public void Disconnect()
{
server.Clients.Remove(socket);
socket.Dispose();
Out.Debug($" -User {Ip}");
}
