Ejemplo n.º 1
0
    void UpdateRealms(object source, ElapsedEventArgs e)
    {
        PreparedStatement stmt   = DB.Login.GetPreparedStatement(LoginStatements.SEL_REALMLIST);
        SQLResult         result = DB.Login.Query(stmt);

        Dictionary <RealmHandle, string> existingRealms = new Dictionary <RealmHandle, string>();

        foreach (var p in _realms)
        {
            existingRealms[p.Key] = p.Value.Name;
        }

        _realms.Clear();

        // Circle through results and add them to the realm map
        if (!result.IsEmpty())
        {
            do
            {
                var  realm   = new Realm();
                uint realmId = result.Read <uint>(0);
                realm.Name            = result.Read <string>(1);
                realm.ExternalAddress = IPAddress.Parse(result.Read <string>(2));
                realm.LocalAddress    = IPAddress.Parse(result.Read <string>(3));
                realm.LocalSubnetMask = IPAddress.Parse(result.Read <string>(4));
                realm.Port            = result.Read <ushort>(5);
                RealmType realmType = (RealmType)result.Read <byte>(6);
                if (realmType == RealmType.FFAPVP)
                {
                    realmType = RealmType.PVP;
                }
                if (realmType >= RealmType.MaxType)
                {
                    realmType = RealmType.Normal;
                }

                realm.Type     = (byte)realmType;
                realm.Flags    = (RealmFlags)result.Read <byte>(7);
                realm.Timezone = result.Read <byte>(8);
                AccountTypes allowedSecurityLevel = (AccountTypes)result.Read <byte>(9);
                realm.AllowedSecurityLevel = (allowedSecurityLevel <= AccountTypes.Administrator ? allowedSecurityLevel : AccountTypes.Administrator);
                realm.PopulationLevel      = result.Read <float>(10);
                realm.Build = result.Read <uint>(11);
                byte region      = result.Read <byte>(12);
                byte battlegroup = result.Read <byte>(13);

                realm.Id = new RealmHandle(region, battlegroup, realmId);

                UpdateRealm(realm);

                var subRegion = new RealmHandle(region, battlegroup, 0).GetAddressString();
                if (!_subRegions.Contains(subRegion))
                {
                    _subRegions.Add(subRegion);
                }

                if (!existingRealms.ContainsKey(realm.Id))
                {
                    Log.outInfo(LogFilter.Realmlist, "Added realm \"{0}\" at {1}:{2}", realm.Name, realm.ExternalAddress.ToString(), realm.Port);
                }
                else
                {
                    Log.outDebug(LogFilter.Realmlist, "Updating realm \"{0}\" at {1}:{2}", realm.Name, realm.ExternalAddress.ToString(), realm.Port);
                }

                existingRealms.Remove(realm.Id);
            }while (result.NextRow());
        }

        foreach (var pair in existingRealms)
        {
            Log.outInfo(LogFilter.Realmlist, "Removed realm \"{0}\".", pair.Value);
        }
    }
Ejemplo n.º 2
0
        public BattlenetRpcErrorCode HandleVerifyWebCredentials(Bgs.Protocol.Authentication.V1.VerifyWebCredentialsRequest verifyWebCredentialsRequest)
        {
            PreparedStatement stmt = DB.Login.GetPreparedStatement(LoginStatements.SEL_BNET_ACCOUNT_INFO);

            stmt.AddValue(0, verifyWebCredentialsRequest.WebCredentials.ToStringUtf8());

            SQLResult result = DB.Login.Query(stmt);

            if (result.IsEmpty())
            {
                return(BattlenetRpcErrorCode.Denied);
            }

            _accountInfo = new AccountInfo();
            _accountInfo.LoadResult(result);

            if (_accountInfo.LoginTicketExpiry < Time.UnixTime)
            {
                return(BattlenetRpcErrorCode.TimedOut);
            }

            stmt = DB.Login.GetPreparedStatement(LoginStatements.SEL_BNET_CHARACTER_COUNTS_BY_BNET_ID);
            stmt.AddValue(0, _accountInfo.Id);

            SQLResult characterCountsResult = DB.Login.Query(stmt);

            if (!characterCountsResult.IsEmpty())
            {
                do
                {
                    RealmHandle realmId = new RealmHandle(characterCountsResult.Read <byte>(3), characterCountsResult.Read <byte>(4), characterCountsResult.Read <uint>(2));
                    _accountInfo.GameAccounts[characterCountsResult.Read <uint>(0)].CharacterCounts[realmId.GetAddress()] = characterCountsResult.Read <byte>(1);
                } while (characterCountsResult.NextRow());
            }

            stmt = DB.Login.GetPreparedStatement(LoginStatements.SEL_BNET_LAST_PLAYER_CHARACTERS);
            stmt.AddValue(0, _accountInfo.Id);

            SQLResult lastPlayerCharactersResult = DB.Login.Query(stmt);

            if (!lastPlayerCharactersResult.IsEmpty())
            {
                do
                {
                    RealmHandle realmId = new RealmHandle(lastPlayerCharactersResult.Read <byte>(1), lastPlayerCharactersResult.Read <byte>(2), lastPlayerCharactersResult.Read <uint>(3));

                    LastPlayedCharacterInfo lastPlayedCharacter = new LastPlayedCharacterInfo();
                    lastPlayedCharacter.RealmId        = realmId;
                    lastPlayedCharacter.CharacterName  = lastPlayerCharactersResult.Read <string>(4);
                    lastPlayedCharacter.CharacterGUID  = lastPlayerCharactersResult.Read <ulong>(5);
                    lastPlayedCharacter.LastPlayedTime = lastPlayerCharactersResult.Read <uint>(6);

                    _accountInfo.GameAccounts[lastPlayerCharactersResult.Read <uint>(0)].LastPlayedCharacters[realmId.GetSubRegionAddress()] = lastPlayedCharacter;
                } while (lastPlayerCharactersResult.NextRow());
            }

            string ip_address = GetRemoteIpAddress().ToString();

            // If the IP is 'locked', check that the player comes indeed from the correct IP address
            if (_accountInfo.IsLockedToIP)
            {
                Log.outDebug(LogFilter.Session, "Session.HandleVerifyWebCredentials: Account '{0}' is locked to IP - '{1}' is logging in from '{2}'",
                             _accountInfo.Login, _accountInfo.LastIP, ip_address);

                if (_accountInfo.LastIP != ip_address)
                {
                    return(BattlenetRpcErrorCode.RiskAccountLocked);
                }
            }
            else
            {
                Log.outDebug(LogFilter.Session, "Session.HandleVerifyWebCredentials: Account '{0}' is not locked to ip", _accountInfo.Login);
                if (_accountInfo.LockCountry.IsEmpty() || _accountInfo.LockCountry == "00")
                {
                    Log.outDebug(LogFilter.Session, "Session.HandleVerifyWebCredentials: Account '{0}' is not locked to country", _accountInfo.Login);
                }
                else if (!_accountInfo.LockCountry.IsEmpty() && !_ipCountry.IsEmpty())
                {
                    Log.outDebug(LogFilter.Session, "Session.HandleVerifyWebCredentials: Account '{0}' is locked to country: '{1}' Player country is '{2}'",
                                 _accountInfo.Login, _accountInfo.LockCountry, _ipCountry);

                    if (_ipCountry != _accountInfo.LockCountry)
                    {
                        return(BattlenetRpcErrorCode.RiskAccountLocked);
                    }
                }
            }

            // If the account is banned, reject the logon attempt
            if (_accountInfo.IsBanned)
            {
                if (_accountInfo.IsPermanenetlyBanned)
                {
                    Log.outDebug(LogFilter.Session, "{0} Session.HandleVerifyWebCredentials: Banned account {1} tried to login!", GetClientInfo(), _accountInfo.Login);
                    return(BattlenetRpcErrorCode.GameAccountBanned);
                }
                else
                {
                    Log.outDebug(LogFilter.Session, "{0} Session.HandleVerifyWebCredentials: Temporarily banned account {1} tried to login!", GetClientInfo(), _accountInfo.Login);
                    return(BattlenetRpcErrorCode.GameAccountSuspended);
                }
            }

            Bgs.Protocol.Authentication.V1.LogonResult logonResult = new Bgs.Protocol.Authentication.V1.LogonResult();
            logonResult.ErrorCode      = 0;
            logonResult.AccountId      = new EntityId();
            logonResult.AccountId.Low  = _accountInfo.Id;
            logonResult.AccountId.High = 0x100000000000000;
            foreach (var pair in _accountInfo.GameAccounts)
            {
                if (!pair.Value.IsBanned)
                {
                    EntityId gameAccountId = new EntityId();
                    gameAccountId.Low  = pair.Value.Id;
                    gameAccountId.High = 0x200000200576F57;
                    logonResult.GameAccountId.Add(gameAccountId);
                }
            }

            if (!_ipCountry.IsEmpty())
            {
                logonResult.GeoipCountry = _ipCountry;
            }

            logonResult.SessionKey = ByteString.CopyFrom(new byte[64].GenerateRandomKey(64));

            _authed = true;

            SendRequest((uint)OriginalHash.AuthenticationListener, 5, logonResult);
            return(BattlenetRpcErrorCode.Ok);
        }
Ejemplo n.º 3
0
 public Realm GetRealm(RealmHandle id)
 {
     return(_realms.LookupByKey(id));
 }
Ejemplo n.º 4
0
 public ObjectHandle AsObject(RealmHandle root) => new ObjectHandle(root, link_value.object_ptr);