public static void PlayerLoginRequestLS(IRealmClient client, RealmPacketIn packet)
{
if (!client.IsConnected || client.AuthAccount == null || client.Account == null)
{
client.Disconnect();
return;
}
if (client.ActiveCharacter != null && client.ActiveCharacter.IsConnected)
{
//it's ok when you press ok your character start login if you press one more time you already connecting we need to wait more
//log.Warn("Client {0} try's to connect to already connected character", client.AccountName);
//client.Disconnect();
return;
}
packet.Position += 5; //unknown default : 0
var charNum = packet.ReadByte(); //default : 10
if (charNum < 10 || charNum > 12)
{
client.Disconnect();
return;
}
var charLowId = (uint)(client.Account.AccountId + 1000000 * charNum);
if (client.Account.GetCharacterRecord(charLowId) == null)
{
client.Disconnect();
return;
}
PreLoginCharacter(client, charLowId, true);
}
[PacketHandler(RealmServerOpCode.CharacterInitOnLogin, IsGamePacket = false, RequiresLogin = false)]//4001
public static void CharacterInitOnLoginRequest(IRealmClient client, RealmPacketIn packet)
{
var accID = packet.ReadInt32(); //default : 0
packet.Position += 2; // default : 0
var characterNum = packet.ReadInt16(); //default : 0
if (characterNum < 10 || characterNum > 12)
{
client.TcpSocket.Close();
return;
}
packet.Position += 4;// default : -1
var charLowId = (uint)(accID + characterNum * 1000000);
var ip = client.ClientAddress.ToString();
var acc = AccountMgr.GetAccount(accID);
if (acc == null || acc.LastIPStr != ip)
{
if (acc != null)
{
Log.Create(Log.Types.AccountOperations, LogSourceType.Account, (uint)accID)
.AddAttribute("operation", 1, "login_game_server_bad_ip")
.AddAttribute("name", 0, acc.Name)
.AddAttribute("ip", 0, client.ClientAddress.ToString())
.AddAttribute("old_ip", 0, acc.LastIPStr)
.Write();
}
client.Disconnect();
return;
}
var realmAcc = RealmServer.Instance.GetLoggedInAccount(acc.Name);
if (realmAcc == null || realmAcc.ActiveCharacter == null)
{
Log.Create(Log.Types.AccountOperations, LogSourceType.Account, (uint)accID)
.AddAttribute("operation", 1, "login_game_server_no_character_selected")
.AddAttribute("name", 0, acc.Name)
.AddAttribute("ip", 0, client.ClientAddress.ToString())
.AddAttribute("old_ip", 0, acc.LastIPStr)
.Write();
client.Disconnect();
return;
}
client.IsGameServerConnection = true;
client.Account = realmAcc;
Log.Create(Log.Types.AccountOperations, LogSourceType.Account, (uint)accID)
.AddAttribute("operation", 1, "login_game_server")
.AddAttribute("name", 0, acc.Name)
.AddAttribute("ip", 0, client.ClientAddress.ToString())
.AddAttribute("character", client.Account.ActiveCharacter.EntryId, client.Account.ActiveCharacter.Name)
.AddAttribute("chrLowId", charLowId)
.Write();
Log.Create(Log.Types.AccountOperations, LogSourceType.Character, (uint)charLowId)
.AddAttribute("operation", 1, "login_game_server")
.AddAttribute("ip", 0, client.ClientAddress.ToString())
.Write();
PreLoginCharacter(client, charLowId, false);
}
public static void PlayerLoginRequestLS(IRealmClient client, RealmPacketIn packet)
{
if (!client.IsConnected || client.AuthAccount == null || client.Account == null)
{
client.Disconnect(false);
}
else
{
if (client.ActiveCharacter != null && client.ActiveCharacter.IsConnected)
{
return;
}
packet.Position += 5;
byte num1 = packet.ReadByte();
if (num1 < 10 || num1 > 12)
{
client.Disconnect(false);
}
else
{
uint num2 = (uint)(client.Account.AccountId + 1000000 * num1);
if (client.Account.GetCharacterRecord(num2) == null)
{
client.Disconnect(false);
}
else
{
PreLoginCharacter(client, num2, true);
}
}
}
}
private static void LoginCharacter(IRealmClient client, uint charLowId, bool isLoginStep)
{
RealmAccount account = client.Account;
if (account == null)
{
return;
}
CharacterRecord record = client.Account.GetCharacterRecord(charLowId);
if (record == null)
{
Asda2LoginHandler.log.Error(string.Format(WCell_RealmServer.CharacterNotFound, (object)charLowId,
(object)account.Name));
client.Disconnect(false);
}
else
{
if (client.ActiveCharacter != null)
{
return;
}
Character character = (Character)null;
try
{
Func <IRealmClient, CharacterRecord, CharacterRecord> beforeLogin = Asda2LoginHandler.BeforeLogin;
if (beforeLogin != null)
{
record = beforeLogin(client, record);
if (record == null)
{
throw new ArgumentNullException("record", "BeforeLogin returned null");
}
}
character = record.CreateCharacter();
if (isLoginStep)
{
character.IsLoginServerStep = true;
character.IsFirstGameConnection = true;
}
character.Create(account, record, client);
character.LoadAndLogin();
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to load Character from Record: " + (object)record,
new object[0]);
if (character == null)
{
return;
}
character.Dispose();
client.Disconnect(false);
}
}
}
private static void LoginCharacter(IRealmClient client, uint charLowId, bool isLoginStep)
{
var acc = client.Account;
if (acc == null)
{
return;
}
var record = client.Account.GetCharacterRecord(charLowId);
if (record == null)
{
log.Error(String.Format(WCell_RealmServer.CharacterNotFound, charLowId, acc.Name));
client.Disconnect();
}
else if (client.ActiveCharacter == null)
{
Character chr = null;
try
{
var evt = BeforeLogin;
if (evt != null)
{
record = evt(client, record);
if (record == null)
{
throw new ArgumentNullException("record", "BeforeLogin returned null");
}
}
chr = record.CreateCharacter();
if (isLoginStep)
{
chr.IsLoginServerStep = true;
chr.IsFirstGameConnection = true;
}
chr.Create(acc, record, client);
chr.LoadAndLogin();
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to load Character from Record: " + record);
if (chr != null)
{
// Force client to relog
chr.Dispose();
client.Disconnect();
}
}
}
}
public static void CharacterInitOnChanelChangeRequest(IRealmClient client, RealmPacketIn packet)
{
if (client == null || client.ClientAddress == null)
{
return;
}
int num = packet.ReadInt32();
Account account = AccountMgr.GetAccount(num);
if (account == null || account.LastIPStr != client.ClientAddress.ToString())
{
if (account != null)
{
Log.Create(Log.Types.AccountOperations, LogSourceType.Account, (uint)num)
.AddAttribute("operation", 1.0, "login_on_map_change_bad_ip")
.AddAttribute("name", 0.0, account.Name)
.AddAttribute("ip", 0.0, client.ClientAddress.ToString())
.AddAttribute("old_ip", 0.0, account.LastIPStr).Write();
}
client.Disconnect(false);
}
else
{
RealmAccount loggedInAccount =
ServerApp <RealmServer> .Instance.GetLoggedInAccount(account.Name);
if (loggedInAccount == null || loggedInAccount.ActiveCharacter == null)
{
client.Disconnect(false);
}
else
{
client.IsGameServerConnection = true;
client.Account = loggedInAccount;
LogHelperEntry lgDelete = Log.Create(Log.Types.AccountOperations, LogSourceType.Account, (uint)num)
.AddAttribute("operation", 1.0, "login_on_map_change").AddAttribute("name", 0.0, account.Name)
.AddAttribute("chr", loggedInAccount.ActiveCharacter.EntryId,
loggedInAccount.ActiveCharacter.Name)
.AddAttribute("ip", 0.0, client.ClientAddress.ToString()).Write();
Log.Create(Log.Types.AccountOperations, LogSourceType.Character,
loggedInAccount.ActiveCharacter.EntityId.Low)
.AddAttribute("operation", 1.0, "login_on_map_change")
.AddAttribute("ip", 0.0, client.ClientAddress.ToString()).AddAttribute("chr",
loggedInAccount.ActiveCharacter.EntryId, loggedInAccount.ActiveCharacter.Name)
.AddReference(lgDelete).Write();
PreLoginCharacter(client, loggedInAccount.ActiveCharacter.EntityId.Low, false);
}
}
}
[PacketHandler(RealmServerOpCode.CharacterInitOnChanelChange, IsGamePacket = false, RequiresLogin = false)]//5058
public static void CharacterInitOnChanelChangeRequest(IRealmClient client, RealmPacketIn packet)
{
if (client == null || client.ClientAddress == null)
{
return;
}
var accId = packet.ReadInt32();
var acc = AccountMgr.GetAccount(accId);
if (acc == null || acc.LastIPStr != client.ClientAddress.ToString())
{
if (acc != null)
{
Log.Create(Log.Types.AccountOperations, LogSourceType.Account, (uint)accId)
.AddAttribute("operation", 1, "login_on_map_change_bad_ip")
.AddAttribute("name", 0, acc.Name)
.AddAttribute("ip", 0, client.ClientAddress.ToString())
.AddAttribute("old_ip", 0, acc.LastIPStr)
.Write();
}
client.Disconnect();
return;
}
var realmAcc = RealmServer.Instance.GetLoggedInAccount(acc.Name);
if (realmAcc == null || realmAcc.ActiveCharacter == null)
{
client.Disconnect();
return;
}
client.IsGameServerConnection = true;
client.Account = realmAcc;
var accLog = Log.Create(Log.Types.AccountOperations, LogSourceType.Account, (uint)accId)
.AddAttribute("operation", 1, "login_on_map_change")
.AddAttribute("name", 0, acc.Name)
.AddAttribute("chr", realmAcc.ActiveCharacter.EntryId, realmAcc.ActiveCharacter.Name)
.AddAttribute("ip", 0, client.ClientAddress.ToString())
.Write();
Log.Create(Log.Types.AccountOperations, LogSourceType.Character, realmAcc.ActiveCharacter.EntityId.Low)
.AddAttribute("operation", 1, "login_on_map_change")
.AddAttribute("ip", 0, client.ClientAddress.ToString())
.AddAttribute("chr", realmAcc.ActiveCharacter.EntryId, realmAcc.ActiveCharacter.Name)
.AddReference(accLog)
.Write();
PreLoginCharacter(client, realmAcc.ActiveCharacter.EntityId.Low, false);
}
/// <summary>
/// Checks whether the client is allowed to login and -if so- logs it in
/// </summary>
/// <remarks>Executed in IO-Context.</remarks>
/// <param name="client"></param>
/// <param name="charLowId"></param>
private static void LoginCharacter(IRealmClient client, uint charLowId)
{
RealmAccount account = client.Account;
if (account == null)
{
return;
}
CharacterRecord record = client.Account.GetCharacterRecord(charLowId);
if (record == null)
{
LoginHandler.log.Error(string.Format(WCell_RealmServer.CharacterNotFound, (object)charLowId,
(object)account.Name));
LoginHandler.SendCharacterLoginFail((IPacketReceiver)client, LoginErrorCode.CHAR_LOGIN_NO_CHARACTER);
}
else if (record.CharacterFlags.HasAnyFlag(CharEnumFlags.NeedsRename | CharEnumFlags.LockedForBilling))
{
LoginHandler.SendCharacterLoginFail((IPacketReceiver)client, LoginErrorCode.AUTH_BILLING_EXPIRED);
}
else
{
if (client.ActiveCharacter != null)
{
return;
}
Character character = (Character)null;
try
{
Func <IRealmClient, CharacterRecord, CharacterRecord> beforeLogin = LoginHandler.BeforeLogin;
if (beforeLogin != null)
{
record = beforeLogin(client, record);
if (record == null)
{
throw new ArgumentNullException("record", "BeforeLogin returned null");
}
}
character = record.CreateCharacter();
character.Create(account, record, client);
character.LoadAndLogin();
string str = string.Format("Welcome to " + WCell.RealmServer.RealmServer.FormattedTitle);
MiscHandler.SendMotd((IPacketReceiver)client, str);
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to load Character from Record: " + (object)record,
new object[0]);
if (character == null)
{
return;
}
character.Dispose();
client.Disconnect(false);
}
}
}
/// <summary>
/// Checks whether the client is allowed to login and -if so- logs it in
/// </summary>
/// <remarks>Executed in IO-Context.</remarks>
/// <param name="client"></param>
/// <param name="charLowId"></param>
private static void LoginCharacter(IRealmClient client, uint charLowId)
{
var acc = client.Account;
if (acc == null)
{
return;
}
var record = client.Account.GetCharacterRecord(charLowId);
if (record == null)
{
log.Error(String.Format(WCell_RealmServer.CharacterNotFound, charLowId, acc.Name));
SendCharacterLoginFail(client, LoginErrorCode.CHAR_LOGIN_NO_CHARACTER);
}
else if (record.CharacterFlags.HasAnyFlag(CharEnumFlags.NeedsRename | CharEnumFlags.LockedForBilling))
{
// TODO: Check in Char Enum?
SendCharacterLoginFail(client, LoginErrorCode.AUTH_BILLING_EXPIRED);
}
else if (client.ActiveCharacter == null)
{
Character chr = null;
try
{
var evt = BeforeLogin;
if (evt != null)
{
record = evt(client, record);
if (record == null)
{
throw new ArgumentNullException("record", "BeforeLogin returned null");
}
}
chr = record.CreateCharacter();
chr.Create(acc, record, client);
chr.LoadAndLogin();
var message = String.Format("Welcome to " + RealmServer.FormattedTitle);
//chr.SendSystemMessage(message);
MiscHandler.SendMotd(client, message);
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to load Character from Record: " + record);
if (chr != null)
{
// Force client to relog
chr.Dispose();
client.Disconnect();
}
}
}
}
public static void CharacterRenameRequest(IRealmClient client, RealmPacketIn packet)
{
if (client.Account == null || client.ActiveCharacter != null)
return;
var guid = packet.ReadEntityId();
var newName = packet.ReadCString();
var record = client.Account.GetCharacterRecord(guid.Low);
if (record == null)
{
log.Error(WCell_RealmServer.IllegalRenameAttempt, guid.ToString(), client);
}
else
{
if (record.CharacterFlags.HasFlag(CharEnumFlags.NeedsRename))
{
// their character isn't flagged to be renamed, what do they think they're doing? ;)
client.Disconnect();
}
else
{
LoginErrorCode errorCode = IsNameValid(ref newName);
if (errorCode != LoginErrorCode.RESPONSE_SUCCESS)
{
SendCharacterRenameError(client, errorCode);
}
else
{
log.Debug(WCell_RealmServer.RenamingCharacter, record.Name, newName);
record.Name = newName;
var charRenameTask =
new Message4<IRealmClient, CharacterRecord, string, EntityId>(CharacterRenameCallback)
{
Parameter1 = client,
Parameter2 = record,
Parameter3 = newName,
Parameter4 = guid
};
// only enqueue to IO Queue if we are in a map context?
RealmServer.IOQueue.AddMessage(charRenameTask);
}
}
}
}
public static void HandleRequestAccountData(IRealmClient client, RealmPacketIn packet)
{
if (client.Account == null)
{
return;
}
var type = packet.ReadUInt32();
if (type > 8)
{
s_log.Error("{0} sent data type > 8", client);
client.Disconnect();
return;
}
SendAccountData(client, type);
}
public static void HandleRequestAccountData(IRealmClient client, RealmPacketIn packet)
{
if (client.Account == null)
{
return;
}
var type = packet.ReadUInt32();
if (type > 8)
{
s_log.Error("{0} sent data type > 8", client);
client.Disconnect();
return;
}
//TODO
//SendAccountData(client, type);
}
public static void HandleUpdateAccountData(IRealmClient client, RealmPacketIn packet)
{
if (client.Account == null)
{
return;
}
var type = packet.ReadUInt32();
var time = packet.ReadUInt32();
var compressedSize = packet.ReadUInt32();
if (compressedSize > 65535)
{
s_log.Warn("{0} sent a too large data update: " + compressedSize, client.Account);
client.Disconnect();
return;
}
client.Account.AccountData.SetAccountData(type, time, packet.ReadBytes(packet.RemainingLength), compressedSize);
}
public static void HandleUpdateAccountData(IRealmClient client, RealmPacketIn packet)
{
if (client.Account == null)
{
return;
}
var type = packet.ReadUInt32();
var time = packet.ReadUInt32();
var compressedSize = packet.ReadUInt32();
if (compressedSize > 65535)
{
s_log.Warn("{0} sent a too large data update: " + compressedSize, client.Account);
client.Disconnect();
return;
}
client.Account.AccountData.SetAccountData(type, time, packet.ReadBytes(packet.RemainingLength), compressedSize);
}
/// <summary>
/// Called from within the IO-Context
/// </summary>
/// <param name="client"></param>
/// <param name="accountName"></param>
internal static void InitializeAccount(IRealmClient client, string accountName)
{
if (!client.IsConnected)
{
return;
}
if (RealmServer.Instance.IsAccountLoggedIn(accountName))
{
log.Info("Client ({0}) tried to use online Account: {1}.", client, accountName);
AuthenticationHandler.OnLoginError(client, AccountStatus.AccountInUse);
client.Disconnect();
return;
}
var addr = client.ClientAddress;
if (addr == null)
{
return;
}
var accountInfo = new AccountInfo
{
AccountId = client.AuthAccount.AccountId,
EmailAddress = "",
LastIP = client.ClientAddress.GetAddressBytes(),
LastLogin = DateTime.Now,
RoleGroupName = client.AuthAccount.RoleGroupName
};
var account = new RealmAccount(accountName, accountInfo);
RealmServer.Instance.RegisterAccount(account);
account.LoadCharacters();
account.LoadAccountData();
account.Client = client;
client.Account = account;
log.Info("Account \"{0}\" logged in from {1}.", accountName, client.ClientAddress);
}
public static void AuthSessionRequest(IRealmClient client, RealmPacketIn packet)
{
if (client.ActiveCharacter != null || client.Account != null)
{
// Already logged in
SendAuthSessionErrorReply(client, LoginErrorCode.AUTH_ALREADY_ONLINE);
client.Disconnect();
}
else if (!client.IsEncrypted)
{
var builtNumberClient = packet.ReadUInt32();
var new302 = packet.ReadUInt32(); // NEW 0.0.2.8970
var accName = packet.ReadCString();
var unk322 = packet.ReadUInt32();
client.ClientSeed = packet.ReadUInt32();
var unk1 = packet.ReadUInt32(); // 3.3.5a
var unk2 = packet.ReadUInt32(); // 3.3.5a
var unk3 = packet.ReadUInt32(); // 3.3.5a
var unk4 = packet.ReadUInt64();
client.ClientDigest = packet.ReadBigInteger(20);
#if DEBUG
log.Debug("builtNumberClient:{0} new302:{1} accName:{2} unk322:{3} client.ClientSeed:{4} unk4:{5} ClientDigest:{6}",
builtNumberClient,
new302, accName, unk322, client.ClientSeed, unk4, client.ClientDigest);
#endif
var decompressedDataLength = packet.ReadInt32();
var compressedData = packet.ReadBytes(packet.RemainingLength);
client.Addons = new byte[decompressedDataLength];
Compression.DecompressZLib(compressedData, client.Addons);
var acctLoadTask = Message.Obtain(() => RealmAccount.InitializeAccount(client, accName));
client.Server.AddMessage(acctLoadTask);
}
}
public static void AuthSessionRequest(IRealmClient client, RealmPacketIn packet)
{
if (client.ActiveCharacter != null || client.Account != null)
{
// Already logged in
SendAuthSessionErrorReply(client, LoginErrorCode.AUTH_ALREADY_ONLINE);
client.Disconnect();
}
else if (!client.IsEncrypted)
{
var builtNumberClient = packet.ReadUInt32();
var new302 = packet.ReadUInt32(); // NEW 0.0.2.8970
var accName = packet.ReadCString();
var unk322 = packet.ReadUInt32();
client.ClientSeed = packet.ReadUInt32();
var unk1 = packet.ReadUInt32(); // 3.3.5a
var unk2 = packet.ReadUInt32(); // 3.3.5a
var unk3 = packet.ReadUInt32(); // 3.3.5a
var unk4 = packet.ReadUInt64();
client.ClientDigest = packet.ReadBigInteger(20);
#if DEBUG
log.Debug("builtNumberClient:{0} new302:{1} accName:{2} unk322:{3} client.ClientSeed:{4} unk4:{5} ClientDigest:{6}",
builtNumberClient,
new302, accName, unk322, client.ClientSeed, unk4, client.ClientDigest);
#endif
var decompressedDataLength = packet.ReadInt32();
var compressedData = packet.ReadBytes(packet.RemainingLength);
client.Addons = new byte[decompressedDataLength];
Compression.DecompressZLib(compressedData, client.Addons);
var acctLoadTask = Message.Obtain(() => RealmAccount.InitializeAccount(client, accName));
RealmServer.IOQueue.AddMessage(acctLoadTask);
}
}
/// <summary>Called from within the IO-Context</summary>
/// <param name="client"></param>
/// <param name="accountName"></param>
internal static void InitializeAccount(IRealmClient client, string accountName)
{
if (!client.IsConnected)
{
return;
}
if (ServerApp <WCell.RealmServer.RealmServer> .Instance.IsAccountLoggedIn(accountName))
{
RealmAccount.log.Info("Client ({0}) tried to use online Account: {1}.", (object)client,
(object)accountName);
AuthenticationHandler.OnLoginError(client, AccountStatus.AccountInUse);
client.Disconnect(false);
}
else
{
if (client.ClientAddress == null)
{
return;
}
AccountInfo accountInfo = new AccountInfo()
{
AccountId = client.AuthAccount.AccountId,
EmailAddress = "",
LastIP = client.ClientAddress.GetAddressBytes(),
LastLogin = new DateTime?(DateTime.Now),
RoleGroupName = client.AuthAccount.RoleGroupName
};
RealmAccount acc = new RealmAccount(accountName, (IAccountInfo)accountInfo);
ServerApp <WCell.RealmServer.RealmServer> .Instance.RegisterAccount(acc);
acc.LoadCharacters();
acc.LoadAccountData();
acc.Client = client;
client.Account = acc;
RealmAccount.log.Info("Account \"{0}\" logged in from {1}.", (object)accountName,
(object)client.ClientAddress);
}
}
public static void CharacterInitOnLoginRequest(IRealmClient client, RealmPacketIn packet)
{
int num1 = packet.ReadInt32();
packet.Position += 2;
short num2 = packet.ReadInt16();
if (num2 < 10 || num2 > 12)
{
client.TcpSocket.Close();
}
else
{
packet.Position += 4;
uint num3 = (uint)(num1 + num2 * 1000000);
string str = client.ClientAddress.ToString();
Account account = AccountMgr.GetAccount(num1);
if (account == null || account.LastIPStr != str)
{
if (account != null)
{
Log.Create(Log.Types.AccountOperations, LogSourceType.Account, (uint)num1)
.AddAttribute("operation", 1.0, "login_game_server_bad_ip")
.AddAttribute("name", 0.0, account.Name)
.AddAttribute("ip", 0.0, client.ClientAddress.ToString())
.AddAttribute("old_ip", 0.0, account.LastIPStr).Write();
}
client.Disconnect(false);
}
else
{
RealmAccount loggedInAccount =
ServerApp <RealmServer> .Instance.GetLoggedInAccount(account.Name);
if (loggedInAccount == null || loggedInAccount.ActiveCharacter == null)
{
Log.Create(Log.Types.AccountOperations, LogSourceType.Account, (uint)num1)
.AddAttribute("operation", 1.0, "login_game_server_no_character_selected")
.AddAttribute("name", 0.0, account.Name)
.AddAttribute("ip", 0.0, client.ClientAddress.ToString())
.AddAttribute("old_ip", 0.0, account.LastIPStr).Write();
client.Disconnect(false);
}
else
{
client.IsGameServerConnection = true;
client.Account = loggedInAccount;
Log.Create(Log.Types.AccountOperations, LogSourceType.Account, (uint)num1)
.AddAttribute("operation", 1.0, "login_game_server").AddAttribute("name", 0.0, account.Name)
.AddAttribute("ip", 0.0, client.ClientAddress.ToString())
.AddAttribute("character", client.Account.ActiveCharacter.EntryId,
client.Account.ActiveCharacter.Name).AddAttribute("chrLowId", num3, "")
.Write();
Log.Create(Log.Types.AccountOperations, LogSourceType.Character, num3)
.AddAttribute("operation", 1.0, "login_game_server")
.AddAttribute("ip", 0.0, client.ClientAddress.ToString()).Write();
PreLoginCharacter(client, num3, false);
}
}
}
}
/// <summary>
/// Checks whether the client is allowed to login and -if so- logs it in
/// </summary>
/// <remarks>Executed in IO-Context.</remarks>
/// <param name="client"></param>
/// <param name="charLowId"></param>
private static void LoginCharacter(IRealmClient client, uint charLowId)
{
var acc = client.Account;
if (acc == null)
{
return;
}
var record = client.Account.GetCharacterRecord(charLowId);
if (record == null)
{
log.Error(String.Format(WCell_RealmServer.CharacterNotFound, charLowId, acc.Name));
SendCharacterLoginFail(client, LoginErrorCode.CHAR_LOGIN_NO_CHARACTER);
}
else if (record.CharacterFlags.HasAnyFlag(CharEnumFlags.NeedsRename | CharEnumFlags.LockedForBilling))
{
// TODO: Check in Char Enum?
SendCharacterLoginFail(client, LoginErrorCode.AUTH_BILLING_EXPIRED);
}
else
{
Character chr = null;
try
{
var evt = BeforeLogin;
if (evt != null)
{
record = evt(client, record);
if (record == null)
{
throw new ArgumentNullException("OnBeforeLogin returned null");
}
}
chr = record.CreateCharacter();
chr.Create(acc, record, client);
chr.LoadAndLogin();
var message = String.Format("Welcome to " + RealmServer.FormattedTitle);
//chr.SendSystemMessage(message);
MiscHandler.SendMotd(client, message);
if (CharacterHandler.NotifyPlayerStatus)
{
World.Broadcast("{0} is now " + ChatUtility.Colorize("Online", Color.Green) + ".", chr.Name);
}
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to load Character from Record: " + record);
if (chr != null)
{
// Force client to relog
chr.Dispose();
client.Disconnect();
}
}
}
}
