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);
}
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 ProcessPacket(string source, byte[] data, IPEndPoint ep, UdpClient listener, uint serverPID, ushort listenPort, bool removeConnectPayload = false)
{
StringBuilder sb = new StringBuilder();
foreach (byte b in data)
{
sb.Append(b.ToString("X2") + " ");
}
while (true)
{
QPacket p = new QPacket(data);
MemoryStream m = new MemoryStream(data);
byte[] buff = new byte[(int)p.realSize];
m.Seek(0, 0);
m.Read(buff, 0, buff.Length);
Log.LogPacket(false, buff);
Log.WriteLine(5, "[" + source + "] received : " + p.ToStringShort());
Log.WriteLine(10, "[" + source + "] received : " + sb.ToString());
Log.WriteLine(10, "[" + source + "] received : " + p.ToStringDetailed());
QPacket reply = null;
ClientInfo client = null;
if (p.type != QPacket.PACKETTYPE.SYN && p.type != QPacket.PACKETTYPE.NATPING)
{
client = Global.GetClientByIDrecv(p.m_uiSignature);
}
switch (p.type)
{
case QPacket.PACKETTYPE.SYN:
reply = QPacketHandler.ProcessSYN(p, ep, out client);
break;
case QPacket.PACKETTYPE.CONNECT:
if (client != null && !p.flags.Contains(QPacket.PACKETFLAG.FLAG_ACK))
{
client.sPID = serverPID;
client.sPort = listenPort;
if (removeConnectPayload)
{
p.payload = new byte[0];
p.payloadSize = 0;
}
reply = QPacketHandler.ProcessCONNECT(client, p);
}
break;
case QPacket.PACKETTYPE.DATA:
if (p.m_oSourceVPort.type == QPacket.STREAMTYPE.OldRVSec)
{
RMC.HandlePacket(listener, p);
}
if (p.m_oSourceVPort.type == QPacket.STREAMTYPE.DO)
{
DO.HandlePacket(listener, p);
}
break;
case QPacket.PACKETTYPE.DISCONNECT:
if (client != null)
{
reply = QPacketHandler.ProcessDISCONNECT(client, p);
}
break;
case QPacket.PACKETTYPE.PING:
if (client != null)
{
reply = QPacketHandler.ProcessPING(client, p);
}
break;
case QPacket.PACKETTYPE.NATPING:
ulong time = BitConverter.ToUInt64(p.payload, 5);
if (timeToIgnore.Contains(time))
{
timeToIgnore.Remove(time);
}
else
{
reply = p;
m = new MemoryStream();
byte b = (byte)(reply.payload[0] == 1 ? 0 : 1);
m.WriteByte(b);
Helper.WriteU32(m, 166202); //RVCID
Helper.WriteU64(m, time);
reply.payload = m.ToArray();
Send(source, reply, ep, listener);
m = new MemoryStream();
b = (byte)(b == 1 ? 0 : 1);
m.WriteByte(b);
Helper.WriteU32(m, 166202); //RVCID
time = Helper.MakeTimestamp();
timeToIgnore.Add(time);
Helper.WriteU64(m, Helper.MakeTimestamp());
reply.payload = m.ToArray();
}
break;
}
if (reply != null)
{
Send(source, reply, ep, listener);
}
if (p.realSize != data.Length)
{
m = new MemoryStream(data);
int left = (int)(data.Length - p.realSize);
byte[] newData = new byte[left];
m.Seek(p.realSize, 0);
m.Read(newData, 0, left);
data = newData;
}
else
{
break;
}
}
}
public static string MakeDetailedPacketLog(byte[] data, bool isSinglePacket = false)
{
StringBuilder sb = new StringBuilder();
while (true)
{
QPacket qp = new QPacket(data);
sb.AppendLine("##########################################################");
sb.AppendLine(qp.ToStringDetailed());
if (qp.type == QPacket.PACKETTYPE.DATA && qp.m_byPartNumber == 0)
{
switch (qp.m_oSourceVPort.type)
{
case QPacket.STREAMTYPE.OldRVSec:
if (qp.flags.Contains(QPacket.PACKETFLAG.FLAG_ACK))
{
break;
}
sb.AppendLine("Trying to process RMC packet...");
try
{
MemoryStream m = new MemoryStream(qp.payload);
RMCP p = new RMCP(qp);
m.Seek(p._afterProtocolOffset + 4, 0);
if (!p.isRequest)
{
m.ReadByte();
}
p.methodID = Helper.ReadU32(m);
sb.AppendLine("\tRMC Request : " + p.isRequest);
sb.AppendLine("\tRMC Protocol : " + p.proto);
sb.AppendLine("\tRMC Method : " + p.methodID.ToString("X"));
if (p.proto == RMCP.PROTOCOL.GlobalNotificationEventProtocol && p.methodID == 1)
{
sb.AppendLine("\t\tNotification :");
sb.AppendLine("\t\t\tSource".PadRight(20) + ": 0x" + Helper.ReadU32(m).ToString("X8"));
uint type = Helper.ReadU32(m);
sb.AppendLine("\t\t\tType".PadRight(20) + ": " + (type / 1000));
sb.AppendLine("\t\t\tSubType".PadRight(20) + ": " + (type % 1000));
sb.AppendLine("\t\t\tParam 1".PadRight(20) + ": 0x" + Helper.ReadU32(m).ToString("X8"));
sb.AppendLine("\t\t\tParam 2".PadRight(20) + ": 0x" + Helper.ReadU32(m).ToString("X8"));
sb.AppendLine("\t\t\tParam String".PadRight(20) + ": " + Helper.ReadString(m));
sb.AppendLine("\t\t\tParam 3".PadRight(20) + ": 0x" + Helper.ReadU32(m).ToString("X8"));
}
sb.AppendLine();
}
catch
{
sb.AppendLine("Error processing RMC packet");
sb.AppendLine();
}
break;
case QPacket.STREAMTYPE.DO:
if (qp.flags.Contains(QPacket.PACKETFLAG.FLAG_ACK))
{
break;
}
sb.AppendLine("Trying to unpack DO messages...");
try
{
MemoryStream m = new MemoryStream(qp.payload);
uint size = Helper.ReadU32(m);
byte[] buff = new byte[size];
m.Read(buff, 0, (int)size);
DO.UnpackMessage(buff, 1, sb);
sb.AppendLine();
}
catch
{
sb.AppendLine("Error processing DO messages");
sb.AppendLine();
}
break;
}
}
int size2 = qp.toBuffer().Length;
if (size2 == data.Length || isSinglePacket)
{
break;
}
MemoryStream m2 = new MemoryStream(data);
m2.Seek(size2, 0);
size2 = (int)(m2.Length - m2.Position);
if (size2 <= 8)
{
break;
}
data = new byte[size2];
m2.Write(data, 0, size2);
}
return(sb.ToString());
}
