public static void HandlePartyServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponsePartyService_GetInviteeList(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 4: reply = new RMCPacketResponsePartyService_GetInviteList(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 7: case 8: case 9: case 0xB: case 0xC: case 0xD: reply = new RMCPResponseEmpty(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC PartyService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandlePlayerProfileServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 2: reply = new RMCPResponseEmpty(); break; case 0xF: reply = new RMCPacketResponsePlayerProfileService_GetAllFaceSkinTones(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 0x10: reply = new RMCPResponseEmpty(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 0x11: reply = new RMCPacketResponsePlayerProfileService_Method11(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 0x12: reply = new RMCPacketResponsePlayerProfileService_LoadCharacterProfiles(client); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC PlayerProfileService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandlePacket(UdpClient udp, QPacket p) { ClientInfo client = Global.GetClientByIDrecv(p.m_uiSignature); if (client == null) { return; } client.sessionID = p.m_bySessionID; if (p.uiSeqId > client.seqCounter) { client.seqCounter = p.uiSeqId; } client.udp = udp; if (p.flags.Contains(QPacket.PACKETFLAG.FLAG_ACK)) { return; } WriteLog(10, "Handling packet..."); RMCP rmc = new RMCP(p); if (rmc.isRequest) { HandleRequest(client, p, rmc); } else { HandleResponse(client, p, rmc); } }
public static void HandleServerInfoRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponseServerInfo_Method1(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 2: reply = new RMCPacketResponseServerInfo_Method2(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 5: reply = new RMCPacketResponseServerInfo_GetServerTime(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC ServerInfoService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleLootServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponseLootService_GetLootStatic(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 4: reply = new RMCPacketResponseLootService_Method4(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 5: reply = new RMCPacketResponseLootService_Method5(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC LootService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleSecureServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 4: RMCPacketRequestRegisterEx h = (RMCPacketRequestRegisterEx)rmc.request; switch (h.className) { case "UbiAuthenticationLoginCustomData": reply = new RMCPacketResponseRegisterEx(client.PID); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC Secure] Error: Unknown Custom Data class " + h.className); break; } break; default: Log.WriteLine(1, "[RMC Secure] Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleMissionServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 3: reply = new RMCPacketResponseMissionService_Method3(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 4: reply = new RMCPacketResponseMissionService_GetAllMissionTemplate(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 7: reply = new RMCPResponseEmpty(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC MissionService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleUnlockServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponseUnlockService_GetCurrentUserUnlock(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 2: reply = new RMCPacketResponseUnlockService_Method2(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 3: reply = new RMCPacketResponseUnlockService_Method3(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC UnlockService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void ProcessChatServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 0x5: reply = new RMCPacketResponseChatService_Method5(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 0x9: case 0xA: reply = new RMCPResponseEmpty(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 0xE: reply = new RMCPacketResponseChatService_GetPlayerStatuses(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 0x10: reply = new RMCPacketResponseChatService_Method10(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC ChatService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleStoreServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponseStoreService_GetSKUs(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 8: reply = new RMCPacketResponseStoreService_EnterCoupons(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 9: reply = new RMCPResponseEmpty(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 0xB: reply = new RMCPacketResponseStoreService_GetShoppingDetails(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC StoreService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void SendResponseWithACK(UdpClient udp, QPacket p, RMCP rmc, ClientInfo client, RMCPResponse reply, bool useCompression = true, uint error = 0) { WriteLog(2, "Response : " + reply.ToString()); string payload = reply.PayloadToString(); if (payload != "") { WriteLog(5, "Response Data Content : \n" + payload); } SendACK(udp, p, client); SendResponsePacket(udp, p, rmc, client, reply, useCompression, error); }
public static void ProcessSecureServiceRequest(Stream s, RMCP rmc) { switch (rmc.methodID) { case 4: rmc.request = new RMCPacketRequestRegisterEx(s); break; default: Log.WriteLine(1, "[RMC Secure] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void ProcessTelemetryServiceRequest(Stream s, RMCP rmc) { switch (rmc.methodID) { case 1: rmc.request = new RMCPacketRequestTelemetry_Method1(s); break; default: Log.WriteLine(1, "[RMC Telemetry] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleAuthenticationServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 2: RMCPacketRequestLoginCustomData h = (RMCPacketRequestLoginCustomData)rmc.request; switch (h.className) { case "UbiAuthenticationLoginCustomData": reply = new RMCPResponseEmpty(); ClientInfo user = DBHelper.GetUserByName(h.username); if (user != null) { if (user.pass == h.password) { reply = new RMCPacketResponseLoginCustomData(client.PID, client.sPID, client.sPort); client.name = h.username; client.pass = h.password; client.sessionKey = ((RMCPacketResponseLoginCustomData)reply).ticket.sessionKey; RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); } else { RMC.SendResponseWithACK(client.udp, p, rmc, client, reply, true, 0x80030065); } } else { RMC.SendResponseWithACK(client.udp, p, rmc, client, reply, true, 0x80030064); } break; default: Log.WriteLine(1, "[RMC Authentication] Error: Unknown Custom Data class " + h.className); break; } break; case 3: reply = new RMCPacketResponseRequestTicket(client.PID, client.sPID); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC Authentication] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleProfanityFilterServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponseProfanityFilterService_GetAllProfaneWords(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC ProfanityFilterService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleOverlordNewsProtocolRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponseOverlordNewsProtocol_Method1(client); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC OverlordNewsProtocolService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleAMMDedicatedServerServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 6: reply = new RMCPacktResponseAMMDS_Method6(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC AMMDedicatedServerService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleDBGTelemetryServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponseDBGTelemetry_DBGAMMClientInfo(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC DBGTelemetryService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void ProcessAuthenticationServiceRequest(Stream s, RMCP rmc) { switch (rmc.methodID) { case 2: rmc.request = new RMCPacketRequestLoginCustomData(s); break; case 3: rmc.request = new RMCPacketRequestRequestTicket(s); break; default: Log.WriteLine(1, "[RMC Authentication] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void ProcessResponse(ClientInfo client, QPacket p, RMCP rmc) { MemoryStream m = new MemoryStream(p.payload); m.Seek(rmc._afterProtocolOffset, 0); rmc.success = m.ReadByte() == 1; if (rmc.success) { rmc.callID = Helper.ReadU32(m); rmc.methodID = Helper.ReadU32(m); } else { rmc.error = Helper.ReadU32(m); rmc.callID = Helper.ReadU32(m); } WriteLog(1, "Got response for Protocol " + rmc.proto + " = " + (rmc.success ? "Success" : "Fail")); }
private static void SendResponsePacket(UdpClient udp, QPacket p, RMCP rmc, ClientInfo client, RMCPResponse reply, bool useCompression, uint error) { MemoryStream m = new MemoryStream(); if ((ushort)rmc.proto < 0x7F) { Helper.WriteU8(m, (byte)rmc.proto); } else { Helper.WriteU8(m, 0x7F); Helper.WriteU16(m, (ushort)rmc.proto); } byte[] buff; if (error == 0) { Helper.WriteU8(m, 0x1); Helper.WriteU32(m, rmc.callID); Helper.WriteU32(m, rmc.methodID | 0x8000); buff = reply.ToBuffer(); m.Write(buff, 0, buff.Length); } else { Helper.WriteU8(m, 0); Helper.WriteU32(m, error); Helper.WriteU32(m, rmc.callID); } buff = m.ToArray(); m = new MemoryStream(); Helper.WriteU32(m, (uint)buff.Length); m.Write(buff, 0, buff.Length); QPacket np = new QPacket(p.toBuffer()); np.flags = new List <QPacket.PACKETFLAG>() { QPacket.PACKETFLAG.FLAG_NEED_ACK }; np.m_oSourceVPort = p.m_oDestinationVPort; np.m_oDestinationVPort = p.m_oSourceVPort; np.m_uiSignature = client.IDsend; MakeAndSend(client, np, m.ToArray()); }
public static void SendNotification(ClientInfo client, uint source, uint type, uint subType, uint param1, uint param2, uint param3, string paramStr) { WriteLog(1, "Send Notification: [" + source.ToString("X8") + " " + type.ToString("X8") + " " + subType.ToString("X8") + " " + param1.ToString("X8") + " " + param2.ToString("X8") + " " + param3.ToString("X8") + " \"" + paramStr + "\"]"); MemoryStream m = new MemoryStream(); Helper.WriteU32(m, source); Helper.WriteU32(m, type * 1000 + subType); Helper.WriteU32(m, param1); Helper.WriteU32(m, param2); Helper.WriteU16(m, (ushort)(paramStr.Length + 1)); foreach (char c in paramStr) { m.WriteByte((byte)c); } m.WriteByte(0); Helper.WriteU32(m, param3); byte[] payload = m.ToArray(); QPacket q = new QPacket(); q.m_oSourceVPort = new QPacket.VPort(0x31); q.m_oDestinationVPort = new QPacket.VPort(0x3f); q.type = QPacket.PACKETTYPE.DATA; q.flags = new List <QPacket.PACKETFLAG>(); q.payload = new byte[0]; q.uiSeqId = (ushort)(++client.seqCounter); q.m_bySessionID = client.sessionID; RMCP rmc = new RMCP(); rmc.proto = RMCP.PROTOCOL.GlobalNotificationEventProtocol; rmc.methodID = 1; rmc.callID = ++client.callCounterRMC; RMCPCustom reply = new RMCPCustom(); reply.buffer = payload; RMC.SendRequestPacket(client.udp, q, rmc, client, reply, true, 0); }
public static void HandleInventoryServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponseInventoryService_GetTemplateItems(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 2: reply = new RMCPacketResponseInventoryService_Method2(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 3: reply = new RMCPacketResponseInventoryService_Method3(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 4: reply = new RMCPacketResponseInventoryService_GetAllApplyItems(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 6: reply = new RMCPacketResponseInventoryService_GetUserInventoryByBagType(p.payload[21], p.payload[17]); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 16: reply = new RMCPacketResponseInventoryService_GetAllDefaultLoadoutKits(client); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC InventoryService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleSkillsServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponseSkillsService_GetGameClass(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 2: reply = new RMCPacketResponseSkillsService_GetSkills(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 3: reply = new RMCPacketResponseSkillsService_Method3(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 4: reply = new RMCPacketResponseSkillsService_GetModifierLists(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 5: reply = new RMCPacketResponseSkillsService_GetModifiers(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 7: reply = new RMCPacketResponseSkillsService_Method7(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC SkillService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleOpsProtocolServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 19: reply = new RMCPacketResponseOpsProtocolService_GetAllOperatorVariables(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 23: reply = new RMCPacketResponseOpsProtocolService_GetAllPriorityBroadcasts(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC OpsProtocolService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleAbilityServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 1: reply = new RMCPacketResponseAbilityService_GetPersonaAbilityUpgrades(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 2: reply = new RMCPacketResponseAbilityService_Method2(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC AbilityService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleAchievementsServiceRequest(QPacket p, RMCP rmc, ClientInfo client) { RMCPResponse reply; switch (rmc.methodID) { case 2: reply = new RMCPacketResponseAchievementsService_Method2(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 4: reply = new RMCPacketResponseAchievementsService_Method4(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 9: reply = new RMCPacketResponseAchievementsService_Method9(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 0xC: reply = new RMCPResponseEmpty(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; case 0xD: reply = new RMCPacketResponseAchievementsService_MethodD(); RMC.SendResponseWithACK(client.udp, p, rmc, client, reply); break; default: Log.WriteLine(1, "[RMC AchievementsService] Error: Unknown Method 0x" + rmc.methodID.ToString("X")); break; } }
public static void HandleRequest(ClientInfo client, QPacket p, RMCP rmc) { ProcessRequest(client, p, rmc); if (rmc.callID > client.callCounterRMC) { client.callCounterRMC = rmc.callID; } WriteLog(1, "Received Request : " + rmc.ToString()); string payload = rmc.PayLoadToString(); if (payload != "") { WriteLog(5, payload); } switch (rmc.proto) { case RMCP.PROTOCOL.AuthenticationService: AuthenticationService.HandleAuthenticationServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.SecureService: SecureService.HandleSecureServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.TelemetryService: TelemetryService.HandleTelemetryServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.AMMGameClientService: AMMGameClientService.HandleAMMGameClientRequest(p, rmc, client); break; case RMCP.PROTOCOL.PlayerProfileService: PlayerProfileService.HandlePlayerProfileServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.ArmorService: ArmorService.HandleArmorServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.InventoryService: InventoryService.HandleInventoryServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.LootService: LootService.HandleLootServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.WeaponService: WeaponService.HandleWeaponServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.FriendsService: FriendsService.HandleFriendsServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.ChatService: ChatService.ProcessChatServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.MissionService: MissionService.HandleMissionServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.PartyService: PartyService.HandlePartyServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.StatisticsService: StatisticsService.HandleStatisticsServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.AchievementsService: AchievementsService.HandleAchievementsServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.ProgressionService: ProgressionService.HandleProgressionServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.DBGTelemetryService: DBGTelemetryService.HandleDBGTelemetryServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.RewardService: RewardService.HandleRewardServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.StoreService: StoreService.HandleStoreServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.AdvertisementsService: AdvertisementsService.HandleAdvertisementsServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.SkillsService: SkillService.HandleSkillsServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.LoadoutService: LoadoutService.HandleLoadoutServiceLoadout(p, rmc, client); break; case RMCP.PROTOCOL.UnlockService: UnlockService.HandleUnlockServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.AvatarService: AvatarService.HandleAvatarServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.WeaponProficiencyService: WeaponProficiencyService.HandleWeaponProficiencyServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.OpsProtocolService: OpsProtocolService.HandleOpsProtocolServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.ServerInfoService: ServerInfoService.HandleServerInfoRequest(p, rmc, client); break; case RMCP.PROTOCOL.LeaderboardService: LeaderboardService.HandleLeaderboardServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.PveArchetypeService: PveArchetypeService.HandlePveArchetypeServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.InboxMessageService: InboxMessageService.HandleInboxMessageServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.ProfanityFilterService: ProfanityFilterService.HandleProfanityFilterServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.AbilityService: AbilityService.HandleAbilityServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.SurveyService: SurveyService.HandleSurveyServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.OverlordNewsProtocolService: OverlordNewsProtocolService.HandleOverlordNewsProtocolRequest(p, rmc, client); break; case RMCP.PROTOCOL.AMMDedicatedServerService: AMMDedicatedServerService.HandleAMMDedicatedServerServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.MatchMakingService: MatchMakingService.HandleMatchMakingServiceRequest(p, rmc, client); break; case RMCP.PROTOCOL.NATTraversalRelayProtocol: NATTraversalService.HandleNATTraversalServiceRequest(p, rmc, client); break; default: WriteLog(1, "Error: No handler implemented for packet protocol " + rmc.proto); break; } }
public static void HandleResponse(ClientInfo client, QPacket p, RMCP rmc) { ProcessResponse(client, p, rmc); WriteLog(1, "Received Response : " + rmc.ToString()); }
public static void ProcessRequest(ClientInfo client, QPacket p, RMCP rmc) { MemoryStream m = new MemoryStream(p.payload); m.Seek(rmc._afterProtocolOffset, 0); rmc.callID = Helper.ReadU32(m); rmc.methodID = Helper.ReadU32(m); switch (rmc.proto) { case RMCP.PROTOCOL.AuthenticationService: AuthenticationService.ProcessAuthenticationServiceRequest(m, rmc); break; case RMCP.PROTOCOL.SecureService: SecureService.ProcessSecureServiceRequest(m, rmc); break; case RMCP.PROTOCOL.TelemetryService: TelemetryService.ProcessTelemetryServiceRequest(m, rmc); break; case RMCP.PROTOCOL.AMMGameClientService: case RMCP.PROTOCOL.PlayerProfileService: case RMCP.PROTOCOL.ArmorService: case RMCP.PROTOCOL.InventoryService: case RMCP.PROTOCOL.LootService: case RMCP.PROTOCOL.WeaponService: case RMCP.PROTOCOL.FriendsService: case RMCP.PROTOCOL.ChatService: case RMCP.PROTOCOL.MissionService: case RMCP.PROTOCOL.PartyService: case RMCP.PROTOCOL.StatisticsService: case RMCP.PROTOCOL.AchievementsService: case RMCP.PROTOCOL.ProgressionService: case RMCP.PROTOCOL.DBGTelemetryService: case RMCP.PROTOCOL.RewardService: case RMCP.PROTOCOL.StoreService: case RMCP.PROTOCOL.AdvertisementsService: case RMCP.PROTOCOL.SkillsService: case RMCP.PROTOCOL.LoadoutService: case RMCP.PROTOCOL.UnlockService: case RMCP.PROTOCOL.AvatarService: case RMCP.PROTOCOL.WeaponProficiencyService: case RMCP.PROTOCOL.OpsProtocolService: case RMCP.PROTOCOL.ServerInfoService: case RMCP.PROTOCOL.LeaderboardService: case RMCP.PROTOCOL.PveArchetypeService: case RMCP.PROTOCOL.InboxMessageService: case RMCP.PROTOCOL.ProfanityFilterService: case RMCP.PROTOCOL.AbilityService: case RMCP.PROTOCOL.SurveyService: case RMCP.PROTOCOL.OverlordNewsProtocolService: case RMCP.PROTOCOL.AMMDedicatedServerService: case RMCP.PROTOCOL.MatchMakingService: case RMCP.PROTOCOL.NATTraversalRelayProtocol: break; default: WriteLog(1, "Error: No request reader implemented for packet protocol " + rmc.proto); break; } }