mirror of
https://bitbucket.org/Ioncannon/project-meteor-server.git
synced 2025-04-02 19:42:05 -04:00
217 lines
7.0 KiB
C#
217 lines
7.0 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
using NLog;
|
|
using NLog.Targets;
|
|
|
|
namespace FFXIVClassic.Common
|
|
{
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct SubPacketHeader
|
|
{
|
|
public ushort subpacketSize;
|
|
public ushort type;
|
|
public uint sourceId;
|
|
public uint targetId;
|
|
public uint unknown1;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct GameMessageHeader
|
|
{
|
|
public ushort unknown4; //Always 0x14
|
|
public ushort opcode;
|
|
public uint unknown5;
|
|
public uint timestamp;
|
|
public uint unknown6;
|
|
}
|
|
|
|
public class SubPacket
|
|
{
|
|
public const int SUBPACKET_SIZE = 0x10;
|
|
public const int GAMEMESSAGE_SIZE = 0x10;
|
|
private static readonly Logger logger = LogManager.GetCurrentClassLogger();
|
|
public byte[] data;
|
|
public GameMessageHeader gameMessage;
|
|
|
|
public SubPacketHeader header;
|
|
|
|
public unsafe SubPacket(byte[] bytes, ref int offset)
|
|
{
|
|
if (bytes.Length < offset + SUBPACKET_SIZE)
|
|
throw new OverflowException("Packet Error: Subpacket was too small");
|
|
|
|
fixed (byte* pdata = &bytes[offset])
|
|
{
|
|
header = (SubPacketHeader) Marshal.PtrToStructure(new IntPtr(pdata), typeof(SubPacketHeader));
|
|
}
|
|
|
|
if (header.type == 0x3)
|
|
{
|
|
fixed (byte* pdata = &bytes[offset + SUBPACKET_SIZE])
|
|
{
|
|
gameMessage =
|
|
(GameMessageHeader) Marshal.PtrToStructure(new IntPtr(pdata), typeof(GameMessageHeader));
|
|
}
|
|
}
|
|
|
|
if (bytes.Length < offset + header.subpacketSize)
|
|
throw new OverflowException("Packet Error: Subpacket size didn't equal subpacket data");
|
|
|
|
if (header.type == 0x3)
|
|
{
|
|
data = new byte[header.subpacketSize - SUBPACKET_SIZE - GAMEMESSAGE_SIZE];
|
|
Array.Copy(bytes, offset + SUBPACKET_SIZE + GAMEMESSAGE_SIZE, data, 0, data.Length);
|
|
}
|
|
else
|
|
{
|
|
data = new byte[header.subpacketSize - SUBPACKET_SIZE];
|
|
Array.Copy(bytes, offset + SUBPACKET_SIZE, data, 0, data.Length);
|
|
}
|
|
|
|
offset += header.subpacketSize;
|
|
}
|
|
|
|
public SubPacket(ushort opcode, uint sourceId, byte[] data) : this(true, opcode, sourceId, data) { }
|
|
|
|
public SubPacket(bool isGameMessage, ushort opcode, uint sourceId, byte[] data)
|
|
{
|
|
header = new SubPacketHeader();
|
|
|
|
if (isGameMessage)
|
|
{
|
|
gameMessage = new GameMessageHeader();
|
|
gameMessage.opcode = opcode;
|
|
gameMessage.timestamp = Utils.UnixTimeStampUTC();
|
|
gameMessage.unknown4 = 0x14;
|
|
gameMessage.unknown5 = 0x00;
|
|
gameMessage.unknown6 = 0x00;
|
|
}
|
|
|
|
header.sourceId = sourceId;
|
|
header.targetId = 0;
|
|
|
|
if (isGameMessage)
|
|
header.type = 0x03;
|
|
else
|
|
header.type = opcode;
|
|
|
|
header.unknown1 = 0x00;
|
|
|
|
this.data = data;
|
|
|
|
header.subpacketSize = (ushort) (SUBPACKET_SIZE + data.Length);
|
|
|
|
if (isGameMessage)
|
|
header.subpacketSize += GAMEMESSAGE_SIZE;
|
|
}
|
|
|
|
public SubPacket(SubPacket original, uint newTargetId)
|
|
{
|
|
header = new SubPacketHeader();
|
|
gameMessage = original.gameMessage;
|
|
header.subpacketSize = original.header.subpacketSize;
|
|
header.type = original.header.type;
|
|
header.sourceId = original.header.sourceId;
|
|
header.targetId = newTargetId;
|
|
data = original.data;
|
|
}
|
|
|
|
public void SetTargetId(uint target)
|
|
{
|
|
this.header.targetId = target;
|
|
}
|
|
|
|
public byte[] GetHeaderBytes()
|
|
{
|
|
var size = Marshal.SizeOf(header);
|
|
var arr = new byte[size];
|
|
|
|
var ptr = Marshal.AllocHGlobal(size);
|
|
Marshal.StructureToPtr(header, ptr, true);
|
|
Marshal.Copy(ptr, arr, 0, size);
|
|
Marshal.FreeHGlobal(ptr);
|
|
return arr;
|
|
}
|
|
|
|
public byte[] GetGameMessageBytes()
|
|
{
|
|
var size = Marshal.SizeOf(gameMessage);
|
|
var arr = new byte[size];
|
|
|
|
var ptr = Marshal.AllocHGlobal(size);
|
|
Marshal.StructureToPtr(gameMessage, ptr, true);
|
|
Marshal.Copy(ptr, arr, 0, size);
|
|
Marshal.FreeHGlobal(ptr);
|
|
return arr;
|
|
}
|
|
|
|
public byte[] GetBytes()
|
|
{
|
|
var outBytes = new byte[header.subpacketSize];
|
|
Array.Copy(GetHeaderBytes(), 0, outBytes, 0, SUBPACKET_SIZE);
|
|
|
|
if (header.type == 0x3)
|
|
Array.Copy(GetGameMessageBytes(), 0, outBytes, SUBPACKET_SIZE, GAMEMESSAGE_SIZE);
|
|
|
|
Array.Copy(data, 0, outBytes, SUBPACKET_SIZE + (header.type == 0x3 ? GAMEMESSAGE_SIZE : 0), data.Length);
|
|
return outBytes;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Builds a packet from the incoming buffer + offset. If a packet can be built, it is returned else null.
|
|
/// </summary>
|
|
/// <param name="offset">Current offset in buffer.</param>
|
|
/// <param name="buffer">Incoming buffer.</param>
|
|
/// <returns>Returns either a BasePacket or null if not enough data.</returns>
|
|
public static SubPacket CreatePacket(ref int offset, byte[] buffer, int bytesRead)
|
|
{
|
|
SubPacket newPacket = null;
|
|
|
|
//Too small to even get length
|
|
if (bytesRead <= offset)
|
|
return null;
|
|
|
|
ushort packetSize = BitConverter.ToUInt16(buffer, offset);
|
|
|
|
//Too small to whole packet
|
|
if (bytesRead < offset + packetSize)
|
|
return null;
|
|
|
|
if (buffer.Length < offset + packetSize)
|
|
return null;
|
|
|
|
try
|
|
{
|
|
newPacket = new SubPacket(buffer, ref offset);
|
|
}
|
|
catch (OverflowException)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return newPacket;
|
|
}
|
|
|
|
public void DebugPrintSubPacket()
|
|
{
|
|
#if DEBUG
|
|
logger.ColorDebug(
|
|
string.Format("Size:0x{0:X} Opcode:0x{1:X}{2}{3}", header.subpacketSize, gameMessage.opcode,
|
|
Environment.NewLine,
|
|
Utils.ByteArrayToHex(GetHeaderBytes())), ConsoleOutputColor.DarkRed);
|
|
|
|
if (header.type == 0x03)
|
|
{
|
|
logger.ColorDebug(Utils.ByteArrayToHex(GetGameMessageBytes(), SUBPACKET_SIZE),
|
|
ConsoleOutputColor.DarkRed);
|
|
|
|
logger.ColorDebug(Utils.ByteArrayToHex(data, SUBPACKET_SIZE + GAMEMESSAGE_SIZE),
|
|
ConsoleOutputColor.DarkMagenta);
|
|
}
|
|
else
|
|
logger.ColorDebug(Utils.ByteArrayToHex(data, SUBPACKET_SIZE),
|
|
ConsoleOutputColor.DarkMagenta);
|
|
#endif
|
|
}
|
|
}
|
|
} |