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 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; } }
private static void SendConnectionRequest(ClientInfo client, byte sessionID) { QPacket qp = new QPacket(); qp.m_oSourceVPort = new QPacket.VPort(0x11); qp.m_oDestinationVPort = new QPacket.VPort(0x11); qp.type = QPacket.PACKETTYPE.SYN; qp.flags = new List <QPacket.PACKETFLAG>() { QPacket.PACKETFLAG.FLAG_ACK, QPacket.PACKETFLAG.FLAG_HAS_SIZE }; qp.m_uiConnectionSignature = client.IDsend; qp.payload = new byte[0]; DO.Send(qp, client); qp = new QPacket(); qp.m_bySessionID = sessionID; qp.m_oSourceVPort = new QPacket.VPort(0x11); qp.m_oDestinationVPort = new QPacket.VPort(0x11); qp.type = QPacket.PACKETTYPE.CONNECT; qp.flags = new List <QPacket.PACKETFLAG>() { QPacket.PACKETFLAG.FLAG_RELIABLE, QPacket.PACKETFLAG.FLAG_NEED_ACK, QPacket.PACKETFLAG.FLAG_HAS_SIZE }; qp.m_uiSignature = client.IDsend; qp.m_uiConnectionSignature = client.IDrecv; MemoryStream m = new MemoryStream(); Helper.WriteU32(m, 8); Helper.WriteU32(m, new DupObj(DupObjClass.Station, 1)); Helper.WriteU32(m, new DupObj(DupObjClass.Station, 2)); DO.MakeAndSend(client, qp, m.ToArray()); }
public static QPacket ProcessCONNECT(ClientInfo client, QPacket p) { client.IDsend = p.m_uiConnectionSignature; QPacket reply = new QPacket(); reply.m_oSourceVPort = p.m_oDestinationVPort; reply.m_oDestinationVPort = p.m_oSourceVPort; reply.flags = new List <QPacket.PACKETFLAG>() { QPacket.PACKETFLAG.FLAG_ACK }; reply.type = QPacket.PACKETTYPE.CONNECT; reply.m_bySessionID = p.m_bySessionID; reply.m_uiSignature = client.IDsend; reply.uiSeqId = p.uiSeqId; reply.m_uiConnectionSignature = client.IDrecv; if (p.payload != null && p.payload.Length > 0) { reply.payload = MakeConnectPayload(client, p); } else { reply.payload = new byte[0]; } return(reply); }
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 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 QPacket ProcessSYN(QPacket p, IPEndPoint ep, out ClientInfo client) { client = Global.GetClientByEndPoint(ep); if (client == null) { Log.WriteLine(2, "[QAZAL] Creating new client data..."); client = new ClientInfo(); client.ep = ep; client.IDrecv = Global.idCounter++; client.PID = Global.pidCounter++; Global.clients.Add(client); } QPacket reply = new QPacket(); reply.m_oSourceVPort = p.m_oDestinationVPort; reply.m_oDestinationVPort = p.m_oSourceVPort; reply.flags = new List <QPacket.PACKETFLAG>() { QPacket.PACKETFLAG.FLAG_ACK }; reply.type = QPacket.PACKETTYPE.SYN; reply.m_bySessionID = p.m_bySessionID; reply.m_uiSignature = p.m_uiSignature; reply.uiSeqId = p.uiSeqId; reply.m_uiConnectionSignature = client.IDrecv; reply.payload = new byte[0]; return(reply); }
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 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 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 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 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 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 RMCP(QPacket p) { MemoryStream m = new MemoryStream(p.payload); Helper.ReadU32(m); ushort b = Helper.ReadU8(m); isRequest = (b >> 7) == 1; try { if ((b & 0x7F) != 0x7F) { proto = (PROTOCOL)(b & 0x7F); } else { b = Helper.ReadU16(m); proto = (PROTOCOL)(b); } } catch { Log.WriteLine(1, "[RMC Packet] Error: Unknown RMC packet protocol 0x" + b.ToString("X2")); return; } _afterProtocolOffset = (int)m.Position; }
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 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 Send(UdpClient udp, QPacket p, ClientInfo client) { byte[] data = p.toBuffer(); StringBuilder sb = new StringBuilder(); foreach (byte b in data) { sb.Append(b.ToString("X2") + " "); } WriteLog(5, "send : " + p.ToStringShort()); WriteLog(10, "send : " + sb.ToString()); WriteLog(10, "send : " + p.ToStringDetailed()); udp.Send(data, data.Length, client.ep); Log.LogPacket(true, data); }
public static void Send(string source, QPacket p, IPEndPoint ep, UdpClient listener) { byte[] data = p.toBuffer(); StringBuilder sb = new StringBuilder(); foreach (byte b in data) { sb.Append(b.ToString("X2") + " "); } Log.WriteLine(5, "[" + source + "] send : " + p.ToStringShort()); Log.WriteLine(10, "[" + source + "] send : " + sb.ToString()); Log.WriteLine(10, "[" + source + "] send : " + p.ToStringDetailed()); listener.Send(data, data.Length, ep); Log.LogPacket(true, data); }
private static void SendACK(UdpClient udp, QPacket p, ClientInfo client) { QPacket np = new QPacket(p.toBuffer()); np.flags = new List <QPacket.PACKETFLAG>() { QPacket.PACKETFLAG.FLAG_ACK }; np.m_oSourceVPort = p.m_oDestinationVPort; np.m_oDestinationVPort = p.m_oSourceVPort; np.m_uiSignature = client.IDsend; np.payload = new byte[0]; np.payloadSize = 0; WriteLog(10, "send ACK packet"); Send(udp, np, client); }
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 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 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 MakeAndSend(ClientInfo client, QPacket np, byte[] data) { MemoryStream m = new MemoryStream(data); if (data.Length < 0x3C3) { np.uiSeqId++; np.payload = data; np.payloadSize = (ushort)np.payload.Length; WriteLog(10, "sent packet"); Send(client.udp, np, client); } else { np.flags.Add(QPacket.PACKETFLAG.FLAG_HAS_SIZE); int pos = 0; m.Seek(0, 0); np.m_byPartNumber = 0; while (pos < data.Length) { np.uiSeqId++; bool isLast = false; int len = 0x3C3; if (len + pos >= data.Length) { len = data.Length - pos; isLast = true; } if (!isLast) { np.m_byPartNumber++; } else { np.m_byPartNumber = 0; } byte[] buff = new byte[len]; m.Read(buff, 0, len); np.payload = buff; np.payloadSize = (ushort)np.payload.Length; Send(client.udp, np, client); pos += len; } WriteLog(10, "sent packets"); } }
public static QPacket ProcessDISCONNECT(ClientInfo client, QPacket p) { QPacket reply = new QPacket(); reply.m_oSourceVPort = p.m_oDestinationVPort; reply.m_oDestinationVPort = p.m_oSourceVPort; reply.flags = new List <QPacket.PACKETFLAG>() { QPacket.PACKETFLAG.FLAG_ACK }; reply.type = QPacket.PACKETTYPE.DISCONNECT; reply.m_bySessionID = p.m_bySessionID; reply.m_uiSignature = client.IDsend - 0x10000; reply.uiSeqId = p.uiSeqId; reply.payload = new byte[0]; return(reply); }
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; } }