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;
}
}