Ejemplo n.º 1
0
        public Login(int port)
            : base(port)
        {
            Logger.InfoFormat("LoginConstructor: port is {0}", port);

            PacketHandlers = new LoginPacketHandler[256];

            for (int i = 0; i < 256; ++i)
                PacketHandlers[i] = (c, p) => Logger.WarnFormat("Login: Unhandled opcode 0x{0:X2}", p.Opcode);

            PacketHandlers[0x02] = PacketHandler_0x02_CreateA;
            PacketHandlers[0x03] = PacketHandler_0x03_Login;
            PacketHandlers[0x04] = PacketHandler_0x04_CreateB;
            PacketHandlers[0x10] = PacketHandler_0x10_ClientJoin;
            PacketHandlers[0x26] = PacketHandler_0x26_ChangePassword;
            PacketHandlers[0x4B] = PacketHandler_0x4B_RequestNotification;
            PacketHandlers[0x68] = PacketHandler_0x68_RequestHomepage;
        }
Ejemplo n.º 2
0
        /// <summary>
        /// This method is invoked when the client has data ready to be processed by the server. The server will
        /// switch between the packet type to find an appropriate function for processing the packet. If the
        /// packet was not found, the packet will be outputted to the console as an error.
        /// </summary>
        /// <param name="state">Represents the status of an asynchronous operation.</param>
        public void Receive(AsynchronousState state)
        {
            // Retrieve client information from the asynchronous state:
            var pClient = state.Client as Client;

            if (pClient != null && pClient.Packet != null) // check if it's alright
            {
                var type = (PacketType)BitConverter.ToUInt16(pClient.Packet, 2);
                Action <Client, byte[]> action = m_pProcessor[type];

                // Process the client's packet:
                if (action != null)
                {
                    action(pClient, pClient.Packet);
                }
                else
                {
                    LoginPacketHandler.Report(pClient.Packet);
                }

                #region Moved
                //byte[] pPacket = pClient.Packet;
                //var pType = (PacketType)BitConverter.ToInt16(pPacket, 2);

                //if (BitConverter.ToUInt16(pPacket, 0) == 276 &&
                //    (pType == PacketType.AUTHENTICATION_REQUEST))
                //{
                //    var pRequest = new AuthenticationRequest(pPacket, pClient.IpAddress.GetHashCode());

                //    // tells the console that the user x is trying to login on server y
                //    ServerKernel.Log.SaveLog(string.Format("User [{0}] is trying to login on server [{1}].",
                //        pClient.Account, pRequest.Server));

                //    // let's check if user is spamming login requests
                //    LoginAttemptRecord pLogin = null;
                //    if (!ServerKernel.LoginAttemptRecords.TryGetValue(pClient.IpAddress, out pLogin))
                //    {
                //        pLogin = new LoginAttemptRecord(pClient.IpAddress);
                //        ServerKernel.LoginAttemptRecords.TryAdd(pLogin.IpAddress, pLogin);
                //    }

                //    if (!pLogin.Enabled) // user spamming login?
                //    {
                //        pClient.Send(new AuthenticationResponse(RejectionType.MAXIMUM_LOGIN_ATTEMPTS));
                //        ServerKernel.Log.SaveLog(
                //            string.Format("User [{0}] has passport denied due to exceeding login limit on IP [{1}].",
                //                pRequest.Account, pClient.IpAddress), true, "LoginServer");
                //        pClient.Disconnect();
                //        return;
                //    }

                //    DbAccount pUser = Database.Accounts.SearchByName(pRequest.Account); // fetch user information
                //    if (pUser != null) // user exists?
                //    {
                //        // yes
                //        pClient.Account = pUser;

                //        // check uncommon characters
                //        var szPw = string.Empty;
                //        foreach (var c in pRequest.Password)
                //        {
                //            switch (c)
                //            {
                //                case '-':
                //                    szPw += '0';
                //                    break;
                //                case '#':
                //                    szPw += '1';
                //                    break;
                //                case '(':
                //                    szPw += '2';
                //                    break;
                //                case '"':
                //                    szPw += '3';
                //                    break;
                //                case '%':
                //                    szPw += '4';
                //                    break;
                //                case '\f':
                //                    szPw += '5';
                //                    break;
                //                case '\'':
                //                    szPw += '6';
                //                    break;
                //                case '$':
                //                    szPw += '7';
                //                    break;
                //                case '&':
                //                    szPw += '8';
                //                    break;
                //                case '!':
                //                    szPw += '9';
                //                    break;
                //                default:
                //                    szPw += c;
                //                    break;
                //            }
                //        }

                //        bool bSuccess = true;
                //        // check if user has input the right password
                //        if (pUser.Password != szPw)
                //        {
                //            // invalid pw
                //            pClient.Send(new AuthenticationResponse(RejectionType.INVALID_PASSWORD));
                //            ServerKernel.Log.SaveLog(
                //                string.Format("User [{0}] entered an invalid password [{1}].", pUser.Username,
                //                    pClient.IpAddress), true, "LoginServer");
                //            pClient.Disconnect();
                //            return;
                //        }

                //        if (pUser.Status == 1) // user is banned?
                //        {
                //            // banned
                //            pClient.Send(new AuthenticationResponse(RejectionType.ACCOUNT_BANNED));
                //            ServerKernel.Log.SaveLog(
                //                string.Format("User [{0}] has passport denied due to account lock status.",
                //                    pUser.Username), true, "LoginServer");
                //            pClient.Disconnect();
                //            return;
                //        }

                //        if (pUser.Status == -1) // user has activated account?
                //        {
                //            pClient.Send(new AuthenticationResponse(RejectionType.ACCOUNT_NOT_ACTIVATED));
                //            ServerKernel.Log.SaveLog(
                //                string.Format("User [{0}] has passport denied due to account inactive status.",
                //                    pUser.Username), true, "LoginServer");

                //            pClient.Disconnect();
                //            return;
                //        }

                //        GameServer pServer;
                //        if (!ServerKernel.OnlineServers.TryGetValue(pRequest.Server, out pServer))
                //        // server is not online
                //        {
                //            pClient.Send(new AuthenticationResponse(RejectionType.SERVER_MAINTENANCE));
                //            ServerKernel.Log.SaveLog(
                //                string.Format("User [{0}] tried to login on a invalid server [{1}].", pUser.Username,
                //                    pRequest.Server), true, "LoginServer");

                //            pClient.Disconnect();
                //            return;
                //        }

                //        uint dwHash = (uint)ThreadSafeRandom.RandGet(1000, int.MaxValue);

                //        var pTransferCipher = new TransferCipher(ServerKernel.LoginTransferKey,
                //            ServerKernel.LoginTransferSalt, pClient.IpAddress);
                //        var pCrypto = pTransferCipher.Encrypt(new[] { pUser.Identity, dwHash });

                //        string szAddress = "135.12.15.139"; // random ip just to connect
                //        if (!pServer.IpAddress.StartsWith("127") && pServer.IpAddress != "localhost")
                //            szAddress = pServer.IpAddress;

                //        pServer.Send(new MsgUsrLogin(pUser.Identity, dwHash) { IpAddress = pClient.IpAddress });

                //        pClient.Send(new AuthenticationResponse(pCrypto[0], pCrypto[1], szAddress, 5816));
                //        ServerKernel.Log.SaveLog(string.Format("User [{0}] has successfully logged into {1}.",
                //            pUser.Username, pRequest.Server), true, LogType.MESSAGE);
                //        return;
                //    }
                //    else
                //    {
                //        // no
                //        pClient.Send(new AuthenticationResponse(RejectionType.INVALID_ACCOUNT));
                //        ServerKernel.Log.SaveLog(
                //            string.Format("User [{0}] doesn't exist. Connection [{1}].", pRequest.Account,
                //                pClient.IpAddress), true, "LoginServer");
                //    }
                //}
                //else
                //{
                //    pClient.Send(new AuthenticationResponse(RejectionType.INVALID_AUTHENTICATION_PROTOCOL));
                //    ServerKernel.Log.SaveLog(string.Format("User has tried to connect with an invalid protocol at {0}.", pClient.IpAddress));
                //}

                //pClient.Disconnect();
                #endregion
            }
        }