Exemple #1
0
        internal void Process()
        {
            switch (Identifier)
            {
            case 10100:
                /// _handler.Send(PacketBuilder2(20103, 4, LoginFailed.LockAccount.Payload(Constants.LoginFailed.Error.Default)));
                break;

            case 10101:
                Console.WriteLine(BitConverter.ToString(Payload).Replace("-", ""));
                var ToProcess = LoginOk.Array();
                //_handler.Send(PacketBuilder(20104, 1, ToProcess));
                var ToProcess2 = OwnHomeData.OwnHomeDataArray();
                _handler.Send(PacketBuilder(24101, 1, ToProcess2));
                // var ToProcess2 = SectorState.Array();
                // _handler.Send(PacketBuilder(21903, 1, ToProcess2));
                Logger.Log($"We Sent SectorState", Logger.DefCon.DEBUGSERVER);
                break;
            }
            //internal void lock() {
            //lock.all.ip(accountlockmode.UseGeneratedCode))
            {
                // code.iscorrect.LoginOk.Array = true;
            }
        }
Exemple #2
0
 public virtual Msg ReplyFromServer()
 {
     lock (ContainerLock())
     {
         var userName = ReadString();
         var password = ReadString();
         var server   = ServerMessageDispatcher().Server();
         var found    = server.GetUser(userName);
         if (found != null)
         {
             if (found.password.Equals(password))
             {
                 ServerMessageDispatcher().SetDispatcherName(userName);
                 LogMsg(32, userName);
                 int blockSize = Container().BlockSize();
                 var encrypt   = Container()._handlers.i_encrypt ? 1 : 0;
                 ServerMessageDispatcher().Login();
                 return(LoginOk.GetWriterForInts(Transaction(), new[]
                 {
                     blockSize, encrypt
                     , ServerMessageDispatcher().DispatcherID()
                 }));
             }
         }
     }
     return(Failed);
 }
Exemple #3
0
        public override void RunImpl()
        {
            CipherParameters key = _client.RsaPair._privateKey;
            RSAEngine        rsa = new RSAEngine();

            rsa.init(false, key);

            byte[] decrypt = rsa.processBlock(Raw, 0, 128);

            if (decrypt.Length < 128)
            {
                byte[] temp = new byte[128];
                Array.Copy(decrypt, 0, temp, 128 - decrypt.Length, decrypt.Length);
                decrypt = temp;
            }

            string username = Encoding.ASCII.GetString(decrypt, 0x5e, 14).Replace("\0", string.Empty);
            string password = Encoding.ASCII.GetString(decrypt, 0x6c, 16).Replace("\0", string.Empty);

            AccountModel account = AccountService.GetAccountByLogin(username);

            if (account == null)
            {
                if (Config.Config.Instance.ServerConfig.AutoCreate)
                {
                    account = AccountService.CreateAccount(username, L2Security.HashPassword(password));
                }
                else
                {
                    _client.Send(LoginFail.ToPacket(LoginFailReason.ReasonUserOrPassWrong));
                    _client.Close();
                    return;
                }
            }
            else
            {
                if (!AccountService.CheckIfAccountIsCorrect(username, L2Security.HashPassword(password)))
                {
                    _client.Send(LoginFail.ToPacket(LoginFailReason.ReasonUserOrPassWrong));
                    _client.Close();
                    return;
                }

                if (ServerThreadPool.Instance.LoggedAlready(username.ToLower()))
                {
                    _client.Send(LoginFail.ToPacket(LoginFailReason.ReasonAccountInUse));
                    _client.Close();
                    return;
                }
            }

            Random rnd = new Random();

            _client.ActiveAccount = account;
            _client.SetLoginPair(rnd.Next(), rnd.Next());
            _client.SetPlayPair(rnd.Next(), rnd.Next());

            _client.Send(LoginOk.ToPacket(_client));
        }
Exemple #4
0
        public override async Task RunImpl()
        {
            if (_client.State != LoginClientState.AuthedGG)
            {
                await _client.SendAsync(LoginFail.ToPacket(LoginFailReason.ReasonAccessFailed));

                _client.Close();
                return;
            }

            byte[] decrypt = DecryptPacket();

            string username = Encoding.ASCII.GetString(decrypt, 0x5e, 14).Replace("\0", string.Empty);
            string password = Encoding.ASCII.GetString(decrypt, 0x6c, 16).Replace("\0", string.Empty);

            AccountContract account = await _accountService.GetAccountByLogin(username);

            if (account == null)
            {
                if (_config.ServerConfig.AutoCreate)
                {
                    account = await _accountService.CreateAccount(username, password);
                }
                else
                {
                    await _client.SendAsync(LoginFail.ToPacket(LoginFailReason.ReasonUserOrPassWrong));

                    _client.Close();
                    return;
                }
            }
            else
            {
                if (!await _accountService.CheckIfAccountIsCorrect(username, password))
                {
                    await _client.SendAsync(LoginFail.ToPacket(LoginFailReason.ReasonUserOrPassWrong));

                    _client.Close();
                    return;
                }

                if (LoginServer.ServiceProvider.GetService <ServerThreadPool>().LoggedAlready(account.AccountId))
                {
                    await _client.SendAsync(LoginFail.ToPacket(LoginFailReason.ReasonAccountInUse));

                    _client.Close();
                    return;
                }
            }

            _client.ActiveAccount = account;

            _client.State = LoginClientState.AuthedLogin;
            _client.SendAsync(LoginOk.ToPacket(_client));
        }
Exemple #5
0
        internal void Process()
        {
            switch (Identifier)
            {
            case 10100:
                _handler.Send(PacketBuilder2(20103, 4, LoginFailed.Payload(Constants.LoginFailed.Error.Default)));
                break;

            case 10101:
                Console.WriteLine(BitConverter.ToString(Payload).Replace("-", ""));
                var ToProcess = LoginOk.Array();
                _handler.Send(PacketBuilder(20104, 1, ToProcess));
                // var ToProcess2 = OwnHomeData.OwnHomeDataArray();
                // _handler.Send(PacketBuilder(24101, 1, ToProcess2));
                var ToProcess2 = SectorState.Array();
                _handler.Send(PacketBuilder(21903, 1, ToProcess2));
                Logger.Log($"We Sent SectorState", Logger.DefCon.DEBUGSERVER);
                break;

            case 10108:
                var ToProcess3 = KeepAliveOk.Array();
                _handler.Send(PacketBuilder(20108, 1, ToProcess3));
                Logger.Log($"We Sent KeepAliveOk", Logger.DefCon.DEBUGSERVER);
                break;

            case 14104:
                var ToProcess4 = SectorState.Array();
                _handler.Send(PacketBuilder(21903, 1, ToProcess4));
                Logger.Log($"We Sent SectorState", Logger.DefCon.DEBUGSERVER);
                break;

            case 14101:
                var ToProcess5 = OwnHomeData.OwnHomeDataArray();
                _handler.Send(PacketBuilder(24101, 1, ToProcess5));
                Logger.Log($"We Sent OwnHomeData", Logger.DefCon.DEBUGSERVER);
                break;

            case 14102:
                Console.WriteLine("Before : " + BitConverter.ToString(Payload).Replace("-", ""));
                RC4.Decrypt(ref Payload);
                Console.WriteLine("After : " + BitConverter.ToString(Payload).Replace("-", ""));

                /* var EndClientTurnMessage = Payload;
                 *
                 * int Tick;
                 * int Checksum;
                 * int Count;
                 *
                 * byte[] Commands;
                 *
                 * /// Begin Reading the ECT payload.
                 * using (var Reader = new Reader(Payload))
                 * {
                 *   Tick = Reader.ReadVInt();
                 *   Checksum = Reader.ReadVInt();
                 *   Count = Reader.ReadVInt();
                 *
                 *   Commands = Reader.ReadBytes((int)(Reader.BaseStream.Length - Reader.BaseStream.Position));
                 * }
                 *
                 * Console.WriteLine("Tick: " + Tick);
                 * Console.WriteLine("Checksum: " + Checksum);
                 * Console.WriteLine("Count: " + Count);
                 *
                 * if (Count > -1 && Count <= 50)
                 *    using (var Reader = new Reader(Commands))
                 *    {
                 *       for (var i = 0; i < Count; i++)
                 *       {
                 *            var CommandID = Reader.ReadVInt();
                 *
                 *           Console.WriteLine("Waiting to handle " + CommandID);
                 *        }
                 *   }*/
                break;

            case 10905:
                var ToProcess6 = InBoxData.Payload();
                _handler.Send(PacketBuilder(24445, 1, ToProcess6));
                break;

            case 14302:
                var ToProcess8 = AllianceData.Payload();
                _handler.Send(PacketBuilder(24301, 1, ToProcess8));
                break;

            default:
                Logger.Log($"Packet {Identifier} has not been handled!", Logger.DefCon.WARN);
                break;
            }
        }
Exemple #6
0
        public override void RunImpl()
        {
            if (_client.State != LoginClientState.AuthedGG)
            {
                _client.Send(LoginFail.ToPacket(LoginFailReason.ReasonAccessFailed));
                _client.Close();
                return;
            }

            var       key = _client.RsaPair._privateKey;
            RSAEngine rsa = new RSAEngine();

            rsa.init(false, key);

            byte[] decrypt = rsa.processBlock(Raw, 0, 128);

            if (decrypt.Length < 128)
            {
                byte[] temp = new byte[128];
                Array.Copy(decrypt, 0, temp, 128 - decrypt.Length, decrypt.Length);
                decrypt = temp;
            }

            string username = Encoding.ASCII.GetString(decrypt, 0x5e, 14).Replace("\0", string.Empty);
            string password = Encoding.ASCII.GetString(decrypt, 0x6c, 16).Replace("\0", string.Empty);

            AccountContract account = _accountService.GetAccountByLogin(username);

            if (account == null)
            {
                if (_config.ServerConfig.AutoCreate)
                {
                    account = _accountService.CreateAccount(username, L2Security.HashPassword(password));
                }
                else
                {
                    _client.Send(LoginFail.ToPacket(LoginFailReason.ReasonUserOrPassWrong));
                    _client.Close();
                    return;
                }
            }
            else
            {
                if (!_accountService.CheckIfAccountIsCorrect(username, L2Security.HashPassword(password)))
                {
                    _client.Send(LoginFail.ToPacket(LoginFailReason.ReasonUserOrPassWrong));
                    _client.Close();
                    return;
                }

                if (LoginServer.ServiceProvider.GetService <ServerThreadPool>().LoggedAlready(username.ToLower()))
                {
                    _client.Send(LoginFail.ToPacket(LoginFailReason.ReasonAccountInUse));
                    _client.Close();
                    return;
                }
            }

            _client.ActiveAccount = account;

            _client.State = LoginClientState.AuthedLogin;
            _client.Send(LoginOk.ToPacket(_client));
        }
        /// <summary>
        /// The read.
        /// </summary>
        /// <param name="client">
        /// </param>
        /// <param name="packet">
        /// </param>
        public static void Read(Client client, ref byte[] packet)
        {
            MemoryStream m_stream = new MemoryStream(packet);
            BinaryReader m_reader = new BinaryReader(m_stream);

            // now we should do password check and then send OK or Error
            // sending OK now
            m_stream.Position = 12;

            short  userNameLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt16());
            string userName       = Encoding.ASCII.GetString(m_reader.ReadBytes(userNameLength));
            short  loginKeyLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt16());
            string loginKey       = Encoding.ASCII.GetString(m_reader.ReadBytes(loginKeyLength));

            uint characterId = BitConverter.ToUInt32(new[] { packet[11], packet[10], packet[9], packet[8] }, 0);

            LoginEncryption loginEncryption = new LoginEncryption();

            if (loginEncryption.IsValidLogin(loginKey, client.ServerSalt, userName) &&
                loginEncryption.IsCharacterOnAccount(userName, characterId))
            {
                byte[] loginok = LoginOk.Create();
                client.Send(loginok);
            }
            else
            {
                byte[] loginerr = LoginError.Create();
                client.Send(loginerr);
                client.Server.DisconnectClient(client);
                byte[] invalid = BitConverter.GetBytes(characterId);

                ZoneCom.SendMessage(99, invalid);
                return;
            }

            // save characters ID in client - note, this is usually 0 if it is a chat client connecting
            client.Character = new Character(characterId, client);

            // add client to connected clients list
            if (!client.ChatServer().ConnectedClients.ContainsKey(client.Character.CharacterId))
            {
                client.ChatServer().ConnectedClients.Add(client.Character.CharacterId, client);
            }

            // add yourself to that list
            client.KnownClients.Add(client.Character.CharacterId);

            // and give client its own name lookup
            byte[] pname = PlayerName.Create(client, client.Character.CharacterId);
            client.Send(pname);

            // send server welcome message to client
            byte[] anonv = MsgAnonymousVicinity.Create(
                string.Empty,
                string.Format(
                    client.ChatServer().MessageOfTheDay,
                    AssemblyInfoclass.RevisionName + " " + AssemblyInfoclass.AssemblyVersion),
                string.Empty);
            client.Send(anonv);

            client.ChatServer().AddClientToChannels(client);
        }
Exemple #8
0
        public void Response(Proto.Packet packet)
        {
            IUpperReceivedCmd cmd = null;

            switch (packet.Type) //Packet→Cmd
            {
            case 0:
                cmd = new HBReq();
                break;

            case 1:
                //客户端主动发心跳的回复,不需操作
                break;

            case 111:
                cmd = new News();
                break;

            case 112:
                cmd = new StopNews();
                break;

            case 121:
                cmd = new Poster();
                break;

            case 1002:
                cmd = new LoginOk();
                break;

            case 1003:
                cmd = new LoginFail();
                break;

            case 1102:
                cmd = new Config();
                break;

                #region 2000+
            case 2002:
                cmd = new EditUserInfoResult();
                break;

            case 2004:
                cmd = new NicknameProvided();
                break;

            case 2012:
                cmd = new UserHeartInfo();
                break;

            case 2022:
                cmd = new UpgradeSkillOk();
                break;

            case 2023:
                cmd = new UpgradeSkillFail();
                break;

            case 2025:
                cmd = new UpgradeVegetableOk();
                break;

            case 2026:
                cmd = new UpgradeVegetableFail();
                break;

            case 2032:
                cmd = new BuyCharacterOk();
                break;

            case 2033:
                cmd = new BuyCharacterFail();
                break;

            case 2042:
                cmd = new SpeedUpVegetableUpgradeOk();
                break;

            case 2043:
                cmd = new SpeedUpVegetableUpgradeFail();
                break;

            case 2102:
                cmd = new ExchangeOk();
                break;

            case 2103:
                cmd = new ExchangeFail();
                break;

            case 2202:
                cmd = new UseEquipOk();
                break;

            case 2203:
                cmd = new UseEquipFail();
                break;

            case 2212:
                cmd = new ChangeCharacterOk();
                break;

            case 2213:
                cmd = new ChangeCharacterFail();
                break;

            case 2222:
                cmd = new UserVegetable();
                break;

            case 2223:
                cmd = new RequestUserVegetableFail();
                break;

            case 2232:
                cmd = new UserMailList();
                break;

            case 2242:
                cmd = new RequestMailGiftOK();
                break;

            case 2243:
                cmd = new RequestMailGiftFail();
                break;

            case 2301:
                cmd = new NeedOAuthInfo();
                break;

            case 2303:
                cmd = new BindOAuthInfoOk();
                break;

            case 2304:
                cmd = new BindOAuthInfoFail();
                break;

            case 2312:
                cmd = new SNSFriendInfoList();
                break;

            case 2322:
                cmd = new RandomTeamMemberList();
                break;

                #endregion
            case 10003:
                cmd = new MatchOk();
                break;

            case 10004:
                cmd = new MatchFail();
                break;

            case 10021:
                cmd = new StartRound();
                break;

            case 10022:
                cmd = new EndRound();
                break;

            case 10023:
                cmd = new SyncData();
                break;

            case 10032:
                cmd = new UseSkillOk();
                break;

            case 10033:
                cmd = new UseSkillFail();
                break;

            case 10034:
                cmd = new RivalUseSkill();
                break;

                #region 挑战
            case 10102:
                cmd = new RequestChallengeOk();
                break;

            case 10103:
                cmd = new RequestChallengeFail();
                break;

            case 10105:
                cmd = new StartChallenge();
                break;

            case 10106:
                cmd = new RequestStartChallengeFail();
                break;

            case 10108:
                cmd = new UploadChallengeOk();
                break;

            case 10109:
                cmd = new UploadChallengeFail();
                break;

                #endregion
                #region 排行榜
            case 10202:
                cmd = new Leaderboard();
                break;

                #endregion
            default:
                Debug.LogError("未处理的Cmd:" + packet.Type);
                break;
            }
            if (cmd != null)
            {
                try
                {
                    if (packet.Content != null)
                    {
                        cmd.ParseFrom(packet.Content);
                    }
                    Debug.Log(string.Format("{0}:{1}", cmd.GetType().Name, cmd));
                    Execute(cmd);
                }
                catch (Exception e)
                {
                    Debug.LogException(e);
                }
            }
        }
Exemple #9
0
        /// <summary>
        /// The read.
        /// </summary>
        /// <param name="client">
        /// </param>
        /// <param name="packet">
        /// </param>
        public static void Read(Client client, ref byte[] packet)
        {
            MemoryStream m_stream = new MemoryStream(packet);
            BinaryReader m_reader = new BinaryReader(m_stream);

            // now we should do password check and then send OK or Error
            // sending OK now
            m_stream.Position = 12;

            short  userNameLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt16());
            string userName       = Encoding.ASCII.GetString(m_reader.ReadBytes(userNameLength));
            short  loginKeyLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt16());
            string loginKey       = Encoding.ASCII.GetString(m_reader.ReadBytes(loginKeyLength));

            uint characterId = BitConverter.ToUInt32(new[] { packet[11], packet[10], packet[9], packet[8] }, 0);

            LoginEncryption loginEncryption = new LoginEncryption();

            if (loginEncryption.IsValidLogin(loginKey, client.ServerSalt, userName) &&
                loginEncryption.IsCharacterOnAccount(userName, characterId))
            {
                byte[] loginok = LoginOk.Create();
                client.Send(loginok);
            }
            else
            {
                byte[] loginerr = LoginError.Create();
                client.Send(loginerr);
                client.Server.DisconnectClient(client);
                byte[] invalid = BitConverter.GetBytes(characterId);

                ZoneCom.Client.SendMessage(99, invalid);
                return;
            }

            // server welcome message
            string motd = ConfigReadWrite.Instance.CurrentConfig.Motd;

            // save characters ID in client - note, this is usually 0 if it is a chat client connecting
            client.Character = new Character(characterId, client);

            // add client to connected clients list
            if (!client.Server.ConnectedClients.ContainsKey(client.Character.characterId))
            {
                client.Server.ConnectedClients.Add(client.Character.characterId, client);
            }

            // add yourself to that list
            client.KnownClients.Add(client.Character.characterId);

            // and give client its own name lookup
            byte[] pname = PlayerName.New(client, client.Character.characterId);
            client.Send(pname);

            // send server welcome message to client
            byte[] anonv = MsgAnonymousVicinity.Create(
                string.Empty,
                string.Format(motd, AssemblyInfoclass.Description + " " + AssemblyInfoclass.AssemblyVersion),
                string.Empty);
            client.Send(anonv);

            // tell client to join channel "Global"
            // hardcoded right now
            foreach (ChannelsEntry channel in ChatChannels.ChannelNames)
            {
                byte[] chanGlobal = ChannelJoin.Create(
                    channel.Id, channel.Name, channel.ChannelMode, new byte[] { 0x00, 0x00 });
                client.Send(chanGlobal);
            }

            // First Attempt at Guild Channel....
            // This code is completly untested however if it works
            // we will have to add some what for you to join GuildChat on creation of guild
            // and when you join a guild...  this just connects you to it if you already exist in a guild
            // at character login.. enjoy hope it works.. I cant seem to test it my computer wont let me install the sql tables atm..

            if (client.Character.orgId == 0)
            {
            }
            else
            {
                ulong channelBuffer = (ulong)ChannelType.Organization << 32;
                channelBuffer |= (uint)client.Character.orgId;

                byte[] guildChannel = ChannelJoin.Create(channelBuffer, client.Character.orgName, 0x8044, new byte[] { 0x00, 0x00 });
                client.Send(guildChannel);
            }


            // Do Not Delete this just yet!
            // byte[] chn_global = new Packets.ChannelJoin().Create
            // (
            // new byte[] { 0x04, 0x00, 0x00, 0x23, 0x28 },
            // "Global",
            // 0x8044,
            // new byte[] { 0x00, 0x00 }
            // );
            // client.Send(chn_global);
        }
        /// <summary>
        /// Handles incoming packet.
        /// </summary>
        /// <param name="p">Received <see cref="Packet"/> object.</param>
        internal static void Handle(Packet p)
        {
            switch (p.FirstOpcode)
            {
            case ServiceLayer.Identity:
            {
                switch (p.SecondOpcode)
                {
                case ServiceLayer.InitializeRequest:
                {
                    return;                 // login service not handles incoming connections.
                }

                case ServiceLayer.InitializeResponse:             // connection init response
                {
                    InitializeResponse data = new InitializeResponse(p);

                    switch (data.Answer)
                    {
                    case InitializeResponse.Accepted:
                    {
                        CacheServiceConnection.Connection.SetRemoteService(data.RemoteServiceID, ( ServiceType )data.RemoteServiceType);
                        Logger.WriteLine(Source.InnerNetwork, "Authorized on {0} (0x{1})", CacheServiceConnection.Connection.ServiceType, CacheServiceConnection.Connection.ServiceID.ToString("x2"));

                        // send set-settings request
                        CacheServiceConnection.Send
                        (
                            new SetSettingsRequest().ToPacket
                            (
                                new LoginServiceSettings
                                (
                                    Settings.Default.ServiceUniqueID,
                                    Settings.Default.LoginServiceAutoCreateUsers,
                                    Settings.Default.LoginServiceDefaultAccessLevel
                                )
                            )
                        );

                        return;
                    }

                    case InitializeResponse.Rejected:
                    {
                        Logger.WriteLine(Source.InnerNetwork, "Connection rejected by {0} (0x{1})", ( ServiceType )data.RemoteServiceType, data.RemoteServiceID);
                        return;
                    }
                    }

                    return;
                }

                case ServiceLayer.SetSettingsRequest:
                {
                    return;                 // login service not handles remote service settings request
                }

                case ServiceLayer.SetSettingsResponse:
                {
                    SetSettingsResponse response = new SetSettingsResponse(p);

                    switch (response.Response)
                    {
                    case SetSettingsResponse.Accepted:
                    {
                        Logger.WriteLine(Source.InnerNetwork, "Cache service accepted service settings.");
                        //UserConnectionsListener.Enable(); // start listen incoming user connections
                        return;
                    }

                    default:
                    {
                        Service.Terminate(new ServiceShutdownEventArgs("Cache service rejected settings setup."));
                        return;
                    }
                    }
                }

                default:
                {
                    Logger.WriteLine("Unknown packet received on layer 0x{0}: {1}", ServiceLayer.Identity.ToString("x2"), p.ToString());
                    return;
                }
                }
            }

            case UserDataLayer.Identity:
            {
                switch (p.SecondOpcode)
                {
                case UserDataLayer.UserAuthenticationResponse:
                {
                    UserAuthenticationResponse response = new UserAuthenticationResponse(p);
                    QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);

                    if (QueuedRequest.IsValid(request))
                    {
                        switch (response.Response)
                        {
                        case UserAuthenticationResponseType.UserAccepted:                     // accepted or created by cache
                        {
                            request.UserConnection.Session.AccountID = response.UserID;
                            request.UserConnection.Session.LastWorld = response.LastWorldID;

                            if (response.AccessLevel < Settings.Default.LoginServiceAllowedAccessLevel)
                            {
                                request.Send(LoginFailed.ToPacket(UserAuthenticationResponseType.AccessFailed));
                                UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                                return;
                            }

                            long requestId = long.MinValue;

                            if (QueuedRequestsPool.Enqueue(request.UserConnection, ref requestId))
                            {
                                CacheServiceConnection.Send
                                (
                                    new CacheUserSessionRequest
                                    (
                                        requestId,
                                        request.UserConnection.Session
                                    ).ToPacket()
                                );
                            }
                            else
                            {
                                Logger.WriteLine(Source.InnerNetwork, "Failed to send CacheUserSessionRequest to cache service, request was not enqueued by QueuedRequestsPool ?...");
                                UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                            }

                            return;
                        }

                        default:
                        {
                            request.Send(LoginFailed.ToPacket(response.Response));
                            UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                            return;
                        }
                        }
                    }

                    break;
                }

                case UserDataLayer.CacheUserSessionResponse:
                {
                    CacheUserSessionResponse response = new CacheUserSessionResponse(p);
                    QueuedRequest            request  = QueuedRequestsPool.Dequeue(response.RequestID);

                    if (QueuedRequest.IsValid(request))
                    {
                        switch (response.Response)
                        {
                        case CacheUserSessionResponse.Failed:
                        {
                            Logger.WriteLine("Failed to cache user session data on cache server side");
                            request.Send(LoginFailed.ToPacket(UserAuthenticationResponseType.SystemError));
                            UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                            return;
                        }

                        case CacheUserSessionResponse.Accepted:
                        {
                            request.Send(LoginOk.ToPacket(request.UserConnection.Session));
                            return;
                        }
                        }
                    }
                    else
                    {
                        Logger.WriteLine(Source.OuterNetwork, "Failed to send ServerPackets.WorldsList to client, request was not dequeued by QueuedRequestsPool ?...");
                        UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                    }

                    return;
                }

                case UserDataLayer.WorldsListResponse:
                {
                    WorldsListResponse response = new WorldsListResponse(p);
                    QueuedRequest      request  = QueuedRequestsPool.Dequeue(response.RequestID);

                    if (QueuedRequest.IsValid(request))
                    {
                        request.Send(ServerList.ToPacket(request.UserConnection.Session.LastWorld, response.Data));
                    }
                    else
                    {
                        Logger.WriteLine(Source.OuterNetwork, "Failed to send ServerPackets.WorldsList to client, request was not dequeued by QueuedRequestsPool ?...");
                        UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                    }

                    return;
                }

                case UserDataLayer.JoinWorldResponse:
                {
                    JoinWorldResponse response = new JoinWorldResponse(p);
                    QueuedRequest     request  = QueuedRequestsPool.Dequeue(response.RequestID);

                    if (QueuedRequest.IsValid(request))
                    {
                        switch (response.Result)
                        {
                        case JoinWorldRequestResult.Accepted:
                        {
                            request.UserConnection.Send(PlayAccepted.ToPacket(request.UserConnection.Session));
                            break;
                        }

                        default:
                        {
                            request.UserConnection.Send(PlayFail.ToPacket(response.Result));
                            break;
                        }
                        }
                    }

                    UserConnectionsListener.CloseConnectionWithoutLogout(request.UserConnection);

                    return;
                }
                }

                break;
            }
            }

            Logger.WriteLine("Unknown packet received from {0} service on layer 0x{1}:{2}{3}", ServiceType.LoginService, p.FirstOpcode.ToString("x2"), Environment.NewLine, p.ToString());
        }
Exemple #11
0
        internal void Process()
        {
            switch (Identifier)
            {
            case 10100:
                _handler.Send(PacketBuilder2(20103, 4, LoginFailed.Payload(Constants.LoginFailed.Error.OutDatedContent)));
                Constants.ServerConfig.ContentTimes = 1;
                break;

            case 10101:
                if (Constants.ServerConfig.ContentTimes == 0 && Constants.ProtocolConfig.patchClient == true)
                {
                    _handler.Send(PacketBuilder(20103, 4, LoginFailed.Payload(Constants.LoginFailed.Error.OutDatedContent)));
                    Constants.ServerConfig.ContentTimes = 1;
                }
                else
                {
                    Constants.ServerConfig.ContentTimes = 0;
                    var ToProcess = LoginOk.Array();
                    _handler.Send(PacketBuilder(20104, 1, ToProcess));
                    //var ToProcess55 = OwnHomeData.OwnHomeDataArray();
                    //_handler.Send(PacketBuilder(24101, 1, ToProcess55));
                    // Logger.Log($"We Sent OwnHomeData", Logger.DefCon.DEBUGSERVER);
                    //var ToProcess111 = Sodium.Utilities.HexToBinary("0100");
                    //_handler.Send(PacketBuilder(20207, 1, ToProcess111));
                    //var ToProcess100 = AllianceStream.Array();
                    //_handler.Send(PacketBuilder(24311, 1, ToProcess100));
                    //var ToProcess2 = OwnHomeData.OwnHomeDataArray();
                    //_handler.Send(PacketBuilder(24101, 1, ToProcess2));
                    var ToProcess2 = SectorState.Array();
                    _handler.Send(PacketBuilder(21903, 1, ToProcess2));
                    Logger.Log($"Am trimis SectorState", Logger.DefCon.DEBUGSERVER);
                }

                break;

            case 10108:
                var ToProcess3 = KeepAliveOk.Array();
                _handler.Send(PacketBuilder(20108, 1, ToProcess3));
                Logger.Log($"Am trimis KeepAliveOk", Logger.DefCon.DEBUGSERVER);
                break;

            case 14104:
                var ToProcess4 = SectorState.Array();
                _handler.Send(PacketBuilder(21903, 1, ToProcess4));
                Logger.Log($"Am trimis SectorState", Logger.DefCon.DEBUGSERVER);
                break;

            case 14101:
                var ToProcess5 = OwnHomeData.OwnHomeDataArray();
                _handler.Send(PacketBuilder(24101, 1, ToProcess5));
                Logger.Log($"Am trimis OwnHomeData", Logger.DefCon.DEBUGSERVER);
                var ToProcess11 = Sodium.Utilities.HexToBinary("0100");
                _handler.Send(PacketBuilder(20207, 1, ToProcess11));
                var ToProcess10 = AllianceStream.Array();
                _handler.Send(PacketBuilder(24311, 1, ToProcess10));
                var ToProcess1000 = AllianceMessage.Array("Scrie -s pentru a vedea comenzile disponibile!", "PaulModz Bot", 13, 2);
                _handler.Send(PacketBuilder(24312, 1, ToProcess1000));
                break;

            case 14102:
                //var EndClientTurnMessage = Payload;

                //int Tick;
                //int Checksum;
                //int Count;

                //byte[] Commands;

                //// Begin Reading the ECT payload.
                //using (var Reader = new Reader(Payload))
                //{
                //    Tick = Reader.ReadVInt();
                //    Checksum = Reader.ReadVInt();
                //    Count = Reader.ReadVInt();

                //    Commands = Reader.ReadBytes((int)(Reader.BaseStream.Length - Reader.BaseStream.Position));
                //}

                //Console.WriteLine("Tick: " + Tick);
                //Console.WriteLine("Checksum: " + Checksum);
                //Console.WriteLine("Count: " + Count);

                //if (Count > -1 && Count <= 50)
                //    using (var Reader = new Reader(Commands))
                //    {
                //        for (var i = 0; i < Count; i++)
                //        {
                //            var CommandID = Reader.ReadVInt();

                //            Console.WriteLine("Waiting to handle " + CommandID);
                //        }
                //    }
                break;

            case 10905:
                var ToProcess6 = InBoxData.Payload();
                _handler.Send(PacketBuilder(24445, 1, ToProcess6));
                break;

            case 14302:
                var ToProcess8 = AllianceData.Payload();
                _handler.Send(PacketBuilder(24301, 1, ToProcess8));
                break;

            case 14315:
                Console.WriteLine("Message => " + BitConverter.ToString(EncryptedPayload).Replace("-", ""));

                var ToProcess10001 = AllianceMessage.Array("Comanda necunoscuta", "PaulModz Bot", 13, 1);
                _handler.Send(PacketBuilder(24312, 1, ToProcess10001));


                break;

            default:
                Logger.Log($"Packet {Identifier} nu poate fi incarcat.", Logger.DefCon.WARN);
                break;
            }
        }