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); }