示例#1
0
        private void RegisterGatewayPacketListener()
        {
            if (this.m_gatewayComponent != null)
            {
                this.m_gatewayComponent.OnPacketReceived += new Func <SROClient, SROPacket, PacketSocketType, PacketResult>(delegate(SROClient client, SROPacket packet, PacketSocketType socketType) {
                    this.ClientComponent.OnPacketReceived?.Invoke(client, packet, socketType);

                    //Received from CLIENT
                    if (socketType == PacketSocketType.CLIENT)
                    {
                        return(GetPacketResultOnClientPacketReceived(client, packet));

                        //Received from REMOTE
                    }
                    else if (socketType == PacketSocketType.SERVER)
                    {
                        if (this.m_client.IsClientless)
                        {
                            if (!this.m_client.CanSwitchClient)
                            {
                                //Request Patch
                                if (packet.Opcode == 0x2001)
                                {
                                    if (packet.ReadAscii() == "GatewayServer")
                                    {
                                        Packet response = new Packet(0x6100, true);
                                        response.WriteByte(this.m_client.LocaleID);
                                        response.WriteAscii("SR_Client");
                                        response.WriteUInt(this.m_client.VersionID);
                                        return(new PacketResult(PacketOperationType.RESPONSE, new PacketResult.PacketResponseResultInfo(response)));
                                    }
                                }

                                //Reconnect to AgentServer on successfull login
                                if (packet.Opcode == 0xA100)
                                {
                                    byte result = packet.ReadByte();
                                    if (result == 1)
                                    {
                                        this.m_client.SessionID = packet.ReadUInt();
                                        this.m_client.AgentIP   = packet.ReadAscii();
                                        this.m_client.AgentPort = packet.ReadUShort();

                                        //CanDoAgentServerConnect = true;

                                        //this.m_agentComponent.DOConnect(new IPEndPoint(IPAddress.Parse(this.m_client.AgentIP), this.m_client.AgentPort), delegate (bool status, BindErrorType error) {

                                        //    Console.WriteLine("m_agentComponent DOConnect status : " + status);
                                        //    Console.WriteLine("m_agentComponent DOConnect error : " + error);

                                        //});

                                        //this.m_gatewayComponent.UNBind();
                                        //this.m_agentComponent.SetServiceEndPoint(new IPEndPoint(IPAddress.Parse(this.m_client.AgentIP), this.m_client.AgentPort));
                                        //this.m_agentComponent.DOBind(delegate (bool success, BindErrorType error) {
                                        //    if (success) {
                                        //        Console.WriteLine("CONTEXT.Connect() AGENT PROXY bind SUCCESS");
                                        //    } else {
                                        //        Console.WriteLine("AGENT bind FAILED -- Reason : " + error);
                                        //    }
                                        //});
                                    }
                                }

                                if (packet.Opcode == 0xA101)
                                {
                                    //GlobalServer
                                    bool nextGlobalServer = packet.ReadBool();
                                    do
                                    {
                                        packet.ReadByte();  //GlobalOperationID
                                        packet.ReadAscii(); //GlobalOperationName

                                        nextGlobalServer = packet.ReadBool();
                                    } while (nextGlobalServer);

                                    //ShardList
                                    bool nextShard = packet.ReadBool();
                                    this.m_shards.Clear();
                                    do
                                    {
                                        this.m_shards.Add(new Shard(packet));
                                        nextShard = packet.ReadBool();
                                    } while (nextShard);
                                }

                                //Request Server List
                                if (packet.Opcode == 0xA102)
                                {
                                    byte errorCode = packet.ReadByte();
                                    if (errorCode == 1)   //Connected to Agent Server
                                    {
                                        this.ClientComponent.OnAccountStatusChanged?.Invoke(client, AccountStatusType.LOGIN_SUCCESS);

                                        Packet response = new Packet(0x6101, true);
                                        return(new PacketResult(PacketOperationType.RESPONSE, new PacketResult.PacketResponseResultInfo(response)));
                                    }
                                    else if (errorCode == 2)     //Cannot connect Agent Server.
                                    {
                                        switch (packet.ReadUInt8())
                                        {
                                        //Wrong ID/PW
                                        case 1: {
                                            byte totalattempts = packet.ReadUInt8();
                                            byte num1          = packet.ReadUInt8();
                                            byte num2          = packet.ReadUInt8();
                                            byte num3          = packet.ReadUInt8();
                                            byte attempts      = packet.ReadUInt8();

                                            this.ClientComponent.OnAccountStatusChanged?.Invoke(client, AccountStatusType.LOGIN_FAILED);
                                            break;
                                        }

                                        //Account action
                                        case 2:

                                            //Blocked
                                            if (packet.ReadUInt8() == 1)
                                            {
                                                this.ClientComponent.OnAccountStatusChanged?.Invoke(client, AccountStatusType.BANNED);
                                                //Reason -> packet.ReadAscii());
                                            }
                                            break;

                                        //Character is already logged on
                                        case 3:
                                            this.ClientComponent.OnAccountStatusChanged?.Invoke(client, AccountStatusType.ALREADY_LOGGED_ON);
                                            break;

                                        //Maybe offline or error ?
                                        default: {
                                            this.ClientComponent.OnAccountStatusChanged?.Invoke(client, AccountStatusType.LOGIN_FAILED);
                                            break;
                                        }
                                        }
                                    }
                                    else
                                    {
                                        Console.WriteLine("There is an update or you are using an invalid silkroad version.");
                                        return(new PacketResult(PacketOperationType.IGNORE));
                                    }
                                }



                                //CAPTCHA
                                if (packet.Opcode == 0x2322)
                                {
                                    this.ClientComponent.OnCaptchaStatusChanged?.Invoke(client, CaptchaStatusType.FETCH);

                                    //var captcha = Captcha.GeneratePacketCaptcha(packet);
                                    //Captcha.SaveCaptchaToBMP(captcha, Environment.CurrentDirectory + "\\captcha.bmp");
                                    //Program.main.picCaptcha.Image = Bitmap.FromFile(Environment.CurrentDirectory + "\\captcha.bmp");
                                    //Program.main.groupImageCode.Enabled = true;
                                }


                                if (packet.Opcode == 0xA323)
                                {
                                    byte result = packet.ReadByte();
                                    if (result == 1)
                                    {
                                        this.ClientComponent.OnCaptchaStatusChanged?.Invoke(client, CaptchaStatusType.CORRECT);
                                    }
                                    else
                                    {
                                        this.ClientComponent.OnCaptchaStatusChanged?.Invoke(client, CaptchaStatusType.WRONG);
                                    }
                                    //if (result != 1) {
                                    //    //Get captcha image ?
                                    //    this.m_client.CanCaptchaCheck = true;

                                    //    Packet response = this.ClientComponent.GetCaptchaPacket();
                                    //    return new PacketResult(PacketOperationType.RESPONSE, new PacketResult.PacketResponseResultInfo(response));

                                    //} else if (result == 2) {
                                    //    //Wrong Captcha
                                    //    this.m_client.CanCaptchaCheck = false;
                                    //}
                                }
                            }
                        }
                        else
                        {
                            #region Redirect client to local AgentListener

                            if (packet.Opcode == 0xA102)
                            {
                                byte result = packet.ReadByte();
                                if (result == 1)
                                {
                                    this.m_client.SessionID = packet.ReadUInt();
                                    this.m_client.AgentIP   = packet.ReadAscii();
                                    this.m_client.AgentPort = packet.ReadUShort();


                                    //Create fake response for Client to redirect to localIP/localPort
                                    SROPacket response = new SROPacket(0xA102, true);
                                    response.WriteByte(result);
                                    response.WriteUInt(this.m_client.SessionID);
                                    response.WriteAscii(this.ClientComponent.LocalAgentEndPoint.Address.ToString());
                                    response.WriteUShort((ushort)this.ClientComponent.LocalAgentEndPoint.Port);
                                    //response.WriteAscii(System.Net.IPAddress.Loopback.ToString());
                                    //response.WriteUShort(this.m_client.LocalPort);
                                    response.Lock();
                                    this.m_client.IsConnectedToAgent = true;
                                    this.m_agentComponent.SetServiceEndPoint(new IPEndPoint(IPAddress.Parse(this.m_client.AgentIP), this.m_client.AgentPort));
                                    this.m_agentComponent.DOBind(delegate(bool success, BindErrorType error) {
                                        if (success)
                                        {
                                            Console.WriteLine("[AGENT LISTENER] PROXY bind SUCCESS");
                                        }
                                        else
                                        {
                                            Console.WriteLine("[AGENT LISTENER] PROXY bind FAILED -- Reason : " + error);
                                        }
                                    });

                                    return(new PacketResult(PacketOperationType.RESPONSE, new PacketResult.PacketResponseResultInfo(response)));
                                    //packet = response;
                                }
                                else
                                {
                                    this.m_client.CanAccountLogin = true;
                                }

                                client.SendPacket(packet);
                            }

                            #endregion
                        }
                    }

                    return(new PacketResult(PacketOperationType.NOTHING));
                });
            }
        }