protected override void OnCharacterHandoffComplete(INetworkConnection con, ServerCharacterInfo character, Guid owner)
{
base.OnCharacterHandoffComplete(con, character, owner);
OutboundServerConnection ocon = con as OutboundServerConnection;
// we uncache a character when they disconnect (even as part of a transfer, just in case they never reconnect).
// now that they have reconnected, recache them.
CharacterCache.CacheCharacter(character, ocon.ServerUserID, TimeSpan.MaxValue);
}
/// <summary>
/// Gets called when the player login/transfer request has been resolved - i.e. the player connected and gave us login credentials. Return false to prevent login. Don't forget to call base.OnPlayerLoginResolved
/// if you override this method so that all necessary packet handlers can be registered.
/// </summary>
protected override bool OnPlayerLoginResolved(PacketLoginRequest login, bool result, ref string msg)
{
if (base.OnPlayerLoginResolved(login, result, ref msg))
{
if (ServerUser.CurrentCharacter != null)
{
CharacterCache.CacheCharacter(ServerUser.CurrentCharacter, MyServer.ServerUserID, TimeSpan.FromMinutes(60));
}
}
return(result);
}
/// <summary>
/// Gets called when the parent server wishes to handoff a player off
/// </summary>
/// <param name="msg">request details</param>
private void OnPlayerHandoffRequest(INetworkConnection con, Packet pck)
{
PacketRelayPlayerHandoffRequest msg = pck as PacketRelayPlayerHandoffRequest;
// Create an auth ticket for the player, if we want to allow them to connect.
ServerUser su = new ServerUser();
su.OwningServer = msg.OwningServer;
su.AuthTicket = Guid.Empty;
su.ID = msg.Player;
su.AccountName = msg.AccountName;
su.Profile = msg.Profile;
if (msg.Character != null)
{
msg.Character.OwningAccount = su;
su.CurrentCharacter = msg.Character;
su.CurrentCharacter.TargetResource = msg.TargetResource;
}
string rmsg = "";
su.AuthTicket = OnPlayerConnectionRequest(su, ref rmsg);
bool allowed = su.AuthTicket != Guid.Empty;
if (allowed)
{
ConnectionManager.AuthorizeUser(su, false);
if (msg.Character != null)
{
CharacterCache.CacheCharacter(su.CurrentCharacter, ServerUser.AccountName);
}
}
PacketPlayerAuthorizedForTransfer p = (PacketPlayerAuthorizedForTransfer)CreatePacket((int)ServerPacketType.PacketPlayerAuthorizedForTransfer, 0, true, true);
p.ReplyCode = allowed ? ReplyType.OK : ReplyType.Failure;
p.Profile = msg.Profile;
p.AccountName = msg.AccountName;
p.AuthTicket = su.AuthTicket;
p.ReplyMessage = allowed ? "Welcome to " + MyServer.ServerName + ", " + msg.AccountName : "Server is currently not accepting logins. Try again a little later. " + rmsg;
p.Player = msg.Player;
p.TargetResource = msg.TargetResource;
msg.ReplyPacket = p; // reply will be sent by NetworkConnection.OnAfterPacketProcessed
}
protected override void OnConnectionReady()
{
base.OnConnectionReady();
// Assign default character if necessary
if (!MyServer.UseCharacters)
{
ServerCharacterInfo ci = CharacterUtil.Instance.GetOrCreateDefaultCharacter(!MyServer.RequireAuthentication, ServerUser);
if (ci == null)
{
// disconnect user. couldn't get or create character.
Log1.Logger("Server.Character").Error("Internal server error. Couldn't get or create default character for user " + ServerUser.AccountName);
KillConnection("Internal Server Error. Failed to get or create default character for user " + ServerUser.AccountName);
return;
}
ServerUser.CurrentCharacter = ci;
CharacterCache.CacheCharacter(ci, MyServer.ServerUserID, TimeSpan.MaxValue);
}
ServerUser.OwningServer = MyServer.ServerUserID;
}
private void OnCharacterSelectRequest(INetworkConnection con, Packet mesg)
{
PacketGenericMessage genMsg = mesg as PacketGenericMessage;
string msg = "";
ReplyType rslt = ReplyType.OK;
int id = genMsg.Parms.GetIntProperty((int)PropertyID.CharacterId).GetValueOrDefault(-1);
ServerCharacterInfo ci = null;
// if we don't use characters, there wont be one in the DB
if (MyServer.UseCharacters)
{
ci = CharacterUtil.Instance.LoadCharacter(ServerUser, id, ref msg);
}
if (ci == null && ServerUser.CurrentCharacter != null && ServerUser.CurrentCharacter.ID == id)
{
ci = ServerUser.CurrentCharacter;
}
PacketReply rep = CreateStandardReply(genMsg, rslt, msg);
//genMsg.ReplyPacket = rep;
if (ci == null)
{
genMsg.ReplyPacket = rep;
rep.ReplyCode = ReplyType.Failure;
rep.ReplyMessage = "Unable to load character.";
return;
}
ServerUser.CurrentCharacter = ci;
CharacterCache.CacheCharacter(ci, MyServer.ServerUserID, TimeSpan.MaxValue);
rep.Parms.SetProperty((int)PropertyID.CharacterInfo, ci.CharacterInfo as IComponent);
Send(rep); // reply needs to arrive before the OnSelected event is fired, in case OnSelected results in a server transfer
OnCharacterSelected(ci);
}
/// <summary>
/// Returns the authorized user object, or null if the user isn't currently authorized
/// </summary>
/// <param name="account"></param>
/// <returns></returns>
public static ServerUser GetAuthorizedUser(string account, ServerBase server, PacketLoginRequest.ConnectionType conType)
{
ServerUser u = null;
if (conType == PacketLoginRequest.ConnectionType.AssistedTransfer)
{
lock (m_AuthorizedAccountsSyncRoot)
{
AuthorizedAccounts.TryGetValue(account.ToLower(), out u);
}
}
else if (conType == PacketLoginRequest.ConnectionType.UnassistedTransfer)
{
Guid ticket = Guid.Empty;
string authServer = "";
DateTime whenAuthd = DateTime.MinValue;
int character = -1;
string targetServerID = "";
Guid accountID = Guid.Empty;
if (!DB.Instance.User_GetAuthorizationTicket(account, out authServer, out ticket, out whenAuthd, out character, out targetServerID, out accountID) || ticket == Guid.Empty)
{
return(null);
}
if (targetServerID != server.ServerUserID)
{
// we weren't authorized to be on this server.
Log1.Logger(server.ServerUserID).Error("[" + account + "] attempted unassisted transfer to [" + server.ServerUserID + "], but that user was only authorized to transfer to target server ID [" + targetServerID + "]. Connection denied.");
return(null);
}
if (whenAuthd + AuthTicketLifetime < DateTime.UtcNow)
{
// ticket expired.
Log1.Logger(server.ServerUserID).Error("[" + account + "] attempted unassisted transfer to [" + server.ServerUserID + "], but that user's auth ticket is expired. Connection denied.");
return(null);
}
// Got a ticket. Load up the user from the DB.
u = new ServerUser();
u.OwningServer = server.ServerUserID;
u.AuthTicket = ticket;
u.ID = accountID;
u.AccountName = account;
// load the profile
AccountProfile ap = new AccountProfile(account);
u.Profile = ap;
ap.Load(server.RequireAuthentication);
// load the character
if (character > -1)
{
string msg = "";
u.CurrentCharacter = CharacterUtil.Instance.LoadCharacter(u, character, ref msg);
if (u.CurrentCharacter == null)
{
// Couldn't load character.
Log1.Logger(server.ServerUserID).Error("[" + account + "] attempted unassisted transfer with characer [" + character + "], but that character could not be loaded from the DB: [" + msg + "]. Connection denied.");
return(null);
}
u.CurrentCharacter.OwningAccount = u;
CharacterCache.CacheCharacter(u.CurrentCharacter, server.ServerUserID);
}
}
AuthorizeUser(u); // gotta call this to activate/renew the auth ticket on this server.
return(u);
}
