override public IdentificationStatus Identify(int OpCode, int Size, PacketDirection Direction)
{
if((OpCode == OpManager.OpCodeNameToNumber("OP_ZoneEntry")) && (Direction == PacketDirection.ClientToServer))
return IdentificationStatus.Yes;
return IdentificationStatus.No;
}
public PackerHandlerAttribute(PacketHeader methodId, string name, int size, PacketDirection direction)
{
this.MethodId = (ushort)methodId;
this.Name = name;
this.Size = size;
this.Direction = direction;
}
public Packet(uint Opcode, PacketDirection Direction, byte[] Data, DateTime Time)
{
this.Opcode = Opcode;
this.Direction = Direction;
this.Data = Data;
this.Time = Time;
}
public PacketAttribute(string name, PacketDirection direction, SessionType sessionType = SessionType.None, bool authRequired = true)
{
Name = name;
Direction = direction;
SessionType = sessionType;
AuthRequired = authRequired;
}
public static void Write(PacketDirection dir, byte[] data)
{
if (Config.PacketLog.Enable)
{
string header = "";
switch (dir)
{
case PacketDirection.ServerToPhoenix:
if (!Config.PacketLog.ServerToPhoenix) return;
header = "Server->Phoenix";
break;
case PacketDirection.PhoenixToServer:
if (!Config.PacketLog.PhoenixToServer) return;
header = "Phoenix->Server";
break;
case PacketDirection.ClientToPhoenix:
if (!Config.PacketLog.ClientToPhoenix) return;
header = "Client->Phoenix";
break;
case PacketDirection.PhoenixToClient:
if (!Config.PacketLog.PhoenixToClient) return;
header = "Phoenix->Client";
break;
}
string packet = BuildString(data).Trim().Replace(Environment.NewLine, "\n").Replace("\n", Environment.NewLine);
Trace.WriteLine(packet, header);
}
}
public void ExploreNPCMoveUpdate(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
{
PositionUpdate PosUpdate;
PosUpdate = Decode_OP_NPCMoveUpdate(Buffer.Buffer);
OutputStream.WriteLine("SpawnID: {0}, X = {1}, Y = {2}, Z = {3}, Heading = {4}", PosUpdate.SpawnID, PosUpdate.p.x, PosUpdate.p.y, PosUpdate.p.z, PosUpdate.p.heading);
}
public TORCapturedPacket(int id, TORPacketType type, byte[] data, CaptureSession session, PacketDirection direction)
{
_id = id;
_type = type;
_data = data;
_session = session;
_direction = direction;
}
public override void ExploreItemPacket(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
buffer.SkipBytes(4); // Skip type field.
ExploreSubItem(outputStream, ref buffer);
outputStream.WriteLine("");
}
public void ExploreItemPacket(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
{
Buffer.SkipBytes(4); // Skip type field.
ExploreSubItem(OutputStream, ref Buffer);
OutputStream.WriteLine("");
}
public NetworkMode ReadPacket(MinecraftStream stream, NetworkMode mode, PacketDirection direction)
{
ProtocolVersion = stream.ReadVarInt();
ServerHostname = stream.ReadString();
ServerPort = stream.ReadUInt16();
NextState = (NetworkMode)stream.ReadVarInt();
return NextState;
}
public NetworkMode WritePacket(MinecraftStream stream, NetworkMode mode, PacketDirection direction)
{
stream.WriteVarInt(ProtocolVersion);
stream.WriteString(ServerHostname);
stream.WriteUInt16(ServerPort);
stream.WriteVarInt((int)NextState);
return NextState;
}
public override void ExploreCastSpell(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
UInt32 Slot = buffer.ReadUInt32();
UInt32 SpellID = buffer.ReadUInt32();
outputStream.WriteLine("Casting spell {0} from slot {1}", SpellID, Slot);
outputStream.WriteLine("");
}
public IPPacket(int index,
UInt32 resourceId,
PacketDirection direction,
IPEndPoint localEndpoint,
IPEndPoint remoteEndpoint,
byte[] bytes)
{
Initialize(index, DateTime.Now, resourceId, direction, localEndpoint, remoteEndpoint, bytes);
}
public PacketViewModel Create(PacketDirection packetDirection, byte[] packet)
{
Contract.Requires<ArgumentNullException>(packet != null);
Contract.Requires<ArgumentNullException>(packet.Length >= 16);
Contract.Ensures(Contract.Result<PacketViewModel>() != null);
var packetType = this.packetInspectorService.FindType(packet);
return new PacketViewModel(packetDirection, packet, packetType);
}
public void ExploreCastSpell(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
{
UInt32 Slot = Buffer.ReadUInt32();
UInt32 SpellID = Buffer.ReadUInt32();
OutputStream.WriteLine("Casting spell {0} from slot {1}", SpellID, Slot);
OutputStream.WriteLine("");
}
public PacketViewModel(PacketDirection packetDirection, byte[] packet, Type packetType)
{
Contract.Requires<ArgumentNullException>(packet != null);
Contract.Requires<ArgumentNullException>(packet.Length >= 16);
this.packetDirection = packetDirection;
this.packet = packet;
this.packetType = packetType;
this.timeStamp = DateTime.Now;
}
public override IdentificationStatus Identify(int OpCode, int Size, PacketDirection Direction)
{
if ((OpCode == OpManager.OpCodeNameToNumber("OP_ZoneEntry")) && (Direction == PacketDirection.ClientToServer))
return IdentificationStatus.Tentative;
if ((OpCode == OpManager.OpCodeNameToNumber("OP_SendAATable")) && (Direction == PacketDirection.ServerToClient) &&
(Size == 120))
return IdentificationStatus.Yes;
return IdentificationStatus.No;
}
override public IdentificationStatus Identify(int OpCode, int Size, PacketDirection Direction)
{
if ((OpCode == OpManager.OpCodeNameToNumber("OP_ZoneEntry")) && (Direction == PacketDirection.ClientToServer))
return IdentificationStatus.Tentative;
if ((OpCode == OpManager.OpCodeNameToNumber("OP_PlayerProfile")) && (Direction == PacketDirection.ServerToClient) &&
(Size == ExpectedPPLength))
return IdentificationStatus.Yes;
return IdentificationStatus.No;
}
public static string LogPacket(IPacket packet, PacketDirection direction)
{
var memory = new MemoryStream();
var stream = new StreamWriter(memory);
var type = packet.GetType();
var fields = type.GetFields();
// Log time, direction, name
stream.Write(DateTime.Now.ToString("{hh:mm:ss.fff} "));
if (direction == PacketDirection.Serverbound)
stream.Write("[CLIENT->SERVER] ");
else
stream.Write("[SERVER->CLIENT] ");
stream.Write(FormatPacketName(type.Name));
stream.WriteLine();
// Log fields
foreach (var field in fields)
{
var name = field.Name;
if (field.Name == "PacketId")
continue;
name = AddSpaces(name);
var fValue = field.GetValue(packet);
if (!(fValue is Array))
stream.Write(string.Format(" {0} ({1})", name, field.FieldType.Name));
else
{
var array = fValue as Array;
stream.Write(string.Format(" {0} ({1}[{2}])", name,
array.GetType().GetElementType().Name, array.Length));
}
if (fValue is byte[])
stream.Write(": " + DumpArray(fValue as byte[]) + "\n");
else if (fValue is Array)
{
stream.Write(": ");
var array = fValue as Array;
foreach (var item in array)
stream.Write(string.Format("{0}, ", item.ToString()));
stream.WriteLine();
}
else if (fValue is string)
stream.Write(": \"" + fValue + "\"\n");
else
stream.Write(": " + fValue + "\n");
}
stream.WriteLine();
stream.Flush();
return Encoding.UTF8.GetString(memory.GetBuffer().Take((int)memory.Length).ToArray());
}
public override void ExploreCharInventoryPacket(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
UInt32 ItemCount = buffer.ReadUInt32();
outputStream.WriteLine("There are {0} items in the inventory.\r\n", ItemCount );
for (int i = 0; i < ItemCount; ++i)
{
ExploreSubItem(outputStream, ref buffer);
}
outputStream.WriteLine("");
}
public override void ExploreItemPacket(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
UInt32 StackSize = buffer.ReadUInt32();
buffer.SkipBytes(4);
UInt32 Slot = buffer.ReadUInt32();
UInt32 MerchantSlot = buffer.ReadUInt32();
UInt32 Price = buffer.ReadUInt32();
Int32 Quantity = buffer.ReadInt32();
buffer.SetPosition(68);
string Name = buffer.ReadString(true);
outputStream.WriteLine("Item: {0} at Slot: {1}", Name, Slot);
}
public void ExploreCharInventoryPacket(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
{
UInt32 ItemCount = Buffer.ReadUInt32();
OutputStream.WriteLine("There are {0} items in the inventory.\r\n", ItemCount );
for (int i = 0; i < ItemCount; ++i)
{
ExploreSubItem(OutputStream, ref Buffer);
}
OutputStream.WriteLine("");
}
/// <summary>
/// Creates a new packet from the given type.
/// </summary>
/// <param name="type">Type of the packet to craft.</param>
/// <param name="direction">Direction of the packet.</param>
/// <returns>An instance of this packet or null.</returns>
public static Packet Create(PacketType type, PacketDirection direction)
{
if (!types.ContainsKey(type))
{ // Nothing here.
return null;
}
if (!types[type].ContainsKey(direction))
{ // Nothing here with the requested direction.
return null;
}
// Get a dolly.
return Activator.CreateInstance(types[type][direction]) as Packet;
}
public Packet(byte[] data, PacketDirection direction)
: base(data)
{
this.PacketDirection = direction;
ArrivalTime = DateTime.Now;
EthernetHeader ethernetHeader = new EthernetHeader(data);
IpHeader ipHeader = new IpHeader(this, ethernetHeader);
this.SourceIpAddress = ipHeader.SourceIpAddress;
this.DestinationIpAddress = ipHeader.DestinationIpAddress;
this.Protocol = ipHeader.Protocol;
this.Data = null;
}
public MSNP2PMessage(int index, PacketDirection direction, DateTime startTime,
UInt32 messageID, UInt32 sessionID, UInt32 flags,
UInt64 initialOffset, UInt64 dataSize,
UInt32 ackedMsgID, UInt32 prevAckedMsgID,
UInt64 ackedDataSize)
: base(index, direction, startTime)
{
this.messageID = messageID;
this.sessionID = sessionID;
this.flags = flags;
this.initialOffset = initialOffset;
this.transferred = 0;
this.dataSize = dataSize;
this.ackedMsgID = ackedMsgID;
this.prevAckedMsgID = prevAckedMsgID;
this.ackedDataSize = ackedDataSize;
}
public void LogPacket(IPacket packet, PacketDirection direction, byte[] decryptedPacket)
{
//if (!Active)
// return; // throw expection
var packetType = packet.GetType();
var fileTime = DateTime.Now.ToString("[~HH.mm.ss.fff] ");
var filePrefix = direction == PacketDirection.Server ? "[CLIENT 2 SERVER] " :
"[SERVER 2 CLIENT] ";
var fileName = string.Format("{0} {1} {2} - 0x{3:X2} ({4})", fileTime,
filePrefix,
packetType.Name,
packet.ID, // hex
packet.ID); // decimal
var filePath = Path.Combine(LoggingDirectory, fileName);
File.WriteAllBytes(filePath, decryptedPacket);
}
public override IdentificationStatus Identify(int opCode, int size, PacketDirection direction)
{
if ((opCode == OpManager.OpCodeNameToNumber("OP_ZoneEntry")) && (direction == PacketDirection.ClientToServer))
{
IDStatus = IdentificationStatus.Tentative;
return IdentificationStatus.Tentative;
}
if (IDStatus != IdentificationStatus.Tentative)
return IdentificationStatus.No;
if ((opCode == OpManager.OpCodeNameToNumber("OP_PlayerProfile")) && (direction == PacketDirection.ServerToClient) &&
(size == ExpectedPPLength))
return IdentificationStatus.Yes;
return IdentificationStatus.No;
}
public EQApplicationPacket(System.Net.IPAddress srcIp, System.Net.IPAddress dstIp, ushort srcPort, ushort dstPort, int OpCode, int BufferSize, byte[] Source, int Offset, PacketDirection Direction, DateTime PacketTime)
{
this.OpCode = OpCode;
this.Direction = Direction;
this.PacketTime = PacketTime;
if (BufferSize < 0)
{
//Log("OPCode " + OpCode.ToString("x") + ", Buffer Size " + BufferSize + " Buffer Size < 0 !");
return;
}
Buffer = new byte[BufferSize];
Array.Copy(Source, Offset, Buffer, 0, BufferSize);
}
override public IdentificationStatus Identify(int OpCode, int Size, PacketDirection Direction)
{
if ((OpCode == OpManager.OpCodeNameToNumber(PacketsToMatch[WaitingForPacket].OPCodeName)) &&
(Direction == PacketsToMatch[WaitingForPacket].Direction))
{
if((PacketsToMatch[WaitingForPacket].RequiredSize >= 0) && (Size != PacketsToMatch[WaitingForPacket].RequiredSize))
return IdentificationStatus.No;
if(PacketsToMatch[WaitingForPacket].VersionMatched)
return IdentificationStatus.Yes;
WaitingForPacket++;
return IdentificationStatus.Tentative;
}
return IdentificationStatus.No;
}
public void ExploreClientUpdate(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
{
UInt16 SpawnID = Buffer.ReadUInt16();
Buffer.SkipBytes(6);
float x = Buffer.ReadSingle();
float y = Buffer.ReadSingle();
Buffer.SkipBytes(12);
float z = Buffer.ReadSingle();
Buffer.SkipBytes(4);
UInt32 Temp = Buffer.ReadUInt32();
Temp = Temp & 0x3FFFFF;
Temp = Temp >> 10;
float heading = Utils.EQ19ToFloat((Int32)(Temp));
OutputStream.WriteLine("Loc: {0}, {1}, {2} Heading: {3}", x, y, z, heading);
OutputStream.WriteLine("");
}
virtual public IdentificationStatus Identify(int OpCode, int Size, PacketDirection Direction)
{
return(IdentificationStatus.No);
}
public override void ExploreZoneEntry(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
if (direction != PacketDirection.ServerToClient)
{
return;
}
try
{
var firstName = buffer.ReadString(false); //verified
outputStream.WriteLine("Name = {0}", firstName);
//File.WriteAllBytes(string.Format("{0}.bin",Utils.MakeCleanName(firstName)),buffer.Buffer);
var spawnId = buffer.ReadUInt32(); //verified
outputStream.WriteLine("SpawnID = {0}", spawnId);
var level = buffer.ReadByte(); //verified
outputStream.WriteLine("Level = {0}", level);
buffer.SkipBytes(4);
var isNpc = buffer.ReadByte();//verified
outputStream.WriteLine("IsNPC = {0}", isNpc);
var bitfield = buffer.ReadUInt32();
outputStream.WriteLine("Name: {0}, Bitfield: {1}", firstName, Convert.ToString(bitfield, 2));
outputStream.WriteLine("Gender: {0}", (bitfield & 3));//verified
var otherData = buffer.ReadByte();
outputStream.WriteLine("OtherData = {0}", otherData);
buffer.SkipBytes(8);
// otherdata stuff is unverified
if ((otherData & 1) > 0)
{
outputStream.WriteLine("OD: {0}", buffer.ReadString(false));
outputStream.WriteLine("OD: {0}", buffer.ReadString(false));
outputStream.WriteLine("OD: {0}", buffer.ReadString(false));
buffer.SkipBytes(53);
}
if ((otherData & 4) > 0)
{
outputStream.WriteLine("Aura: {0}", buffer.ReadString(false));
outputStream.WriteLine("Aura: {0}", buffer.ReadString(false));
buffer.SkipBytes(54);
}
//properties unverified in the sense that I don't know if they represent anything useful other than bodytype
var properties = buffer.ReadByte();
outputStream.WriteLine("Properties = {0}, Offset now {1}", properties, buffer.GetPosition());
UInt32 bodyType = 0;
if (properties > 0)
{
bodyType = buffer.ReadUInt32(); //verified
}
outputStream.WriteLine("Bodytype = {0}", bodyType);
if (properties != 1)
{
outputStream.WriteLine("XXXX Properties is {0}", properties);
}
for (var i = 1; i < properties; ++i)
{
outputStream.WriteLine(" Prop: {0}", buffer.ReadUInt32());
}
var hp = buffer.ReadByte(); //not 100% sure this is HP. I got 47% on my character when her hp at 100%. Poss mana?
//Below here is verified
var beardStyle = buffer.ReadByte();
outputStream.WriteLine("Beardstyle is {0}", beardStyle);
var hairColor = buffer.ReadByte();
outputStream.WriteLine("Hair color is {0}", hairColor);
var eye1 = buffer.ReadByte();
outputStream.WriteLine("Eye1 is {0}", eye1);
var eye2 = buffer.ReadByte();
outputStream.WriteLine("Eye2 is {0}", eye2);
var hairStyle = buffer.ReadByte();
outputStream.WriteLine("Hair style is {0}", hairStyle);
var beardColor = buffer.ReadByte();
outputStream.WriteLine("Beard color is {0}", beardColor);
var drakkinHeritage = buffer.ReadUInt32();
outputStream.WriteLine("Drakkin Heritage is {0}", drakkinHeritage);
// an_unemployed_mercenary's and some newer npc's seem to have this set to 255, then have invalid numbers for the next ones
if (drakkinHeritage == 255)
{
outputStream.WriteLine("We should set drakkinHeritage to 0 as well as the other Drakkin stuff.");
outputStream.WriteLine("Drakkin Heritage is 0");
outputStream.WriteLine("Drakkin Tattoo is 0");
outputStream.WriteLine("Drakkin Details is 0");
buffer.SkipBytes(8);
}
else
{
outputStream.WriteLine("Drakkin Tattoo is {0}", buffer.ReadUInt32());
outputStream.WriteLine("Drakkin Details is {0}", buffer.ReadUInt32());
}
var equipChest2 = buffer.ReadByte(); //AKA texture
var useWorn = equipChest2 == 255;
buffer.SkipBytes(2);
var helm = buffer.ReadByte(); //unverified
var size = buffer.ReadSingle(); //verified
var face = buffer.ReadByte(); // Probably correct
var walkSpeed = buffer.ReadSingle(); //dunno valid ranges for this so this is anyone's guess :P
var runSpeed = buffer.ReadSingle(); // verified
var race = buffer.ReadUInt32(); //verified
//dunno about bits below here
outputStream.WriteLine("Holding = {0}", buffer.ReadByte());
outputStream.WriteLine("Deity = {0}", buffer.ReadUInt32()); //verified
outputStream.WriteLine("GuildID = {0}", buffer.ReadUInt32()); //unverified
outputStream.WriteLine("Guildstatus = {0}", buffer.ReadUInt32()); //unverified
outputStream.WriteLine("Class = {0}", buffer.ReadUInt32()); //verified
outputStream.WriteLine("Size: {0}, Face: {1}, Walkspeed: {2}, RunSpeed: {3}, Race: {4}", size, face, walkSpeed, runSpeed, race);
buffer.SkipBytes(1); //PVP-//unverified
outputStream.WriteLine("Stand State = {0}", buffer.ReadByte()); //unverified
outputStream.WriteLine("Light = {0}", buffer.ReadByte()); //unverified
buffer.SkipBytes(1); //Flymode! //unverified
var lastName = buffer.ReadString(false);
outputStream.WriteLine("LastName = {0}", lastName); //verified
buffer.SkipBytes(6);
outputStream.WriteLine("PetOwnerId = {0}", buffer.ReadUInt32()); //unverified
buffer.SkipBytes(isNpc == 1 ? 37 : 25);
if (isNpc == 0 || NPCType.IsPlayableRace(race))
{
var posn = buffer.GetPosition();
for (int ColourSlot = 0; ColourSlot < 9; ++ColourSlot)
{
outputStream.WriteLine("Color {0} is {1}", ColourSlot, buffer.ReadUInt32());
}
var diff = buffer.GetPosition() - posn;
Debug.Assert(diff == 36, "Colour slots wrong!");
//Player equip verified
for (var i = 0; i < 9; ++i)
{
var equip3 = buffer.ReadUInt32();
var equipx = buffer.ReadUInt32();
var equip2 = buffer.ReadUInt32();
var equip1 = buffer.ReadUInt32();
var equip0 = buffer.ReadUInt32();
outputStream.WriteLine("Equip slot {0}: 0,1,2,x,3 is {1}, {2}, {3}, {4}, {5}", i,
equip0, equip1, equip2, equipx, equip3);
}
}
else
{
//vsab at this point this section is 100% untested
// Non playable race
// Melee Texture 1 is 20 bytes in
// Melee Texture 1 is 40 bytes in
// This whole segment is 28 + 24 + 8 = 60
// Skip 20, Read m1, skip 16, read m2, skip 16
/*
* OutputStream.WriteLine("None playable race, offset now {0}", Buffer.GetPosition());
* Buffer.SkipBytes(28);
*
* UInt32 MeleeTexture1 = Buffer.ReadUInt32();
* Buffer.SkipBytes(12);
* UInt32 MeleeTexture2 = Buffer.ReadUInt32();
* Buffer.SkipBytes(12);
*/
outputStream.WriteLine("None playable race, offset now {0}", buffer.GetPosition());
buffer.SkipBytes(20);
var meleeTexture1 = buffer.ReadUInt32();
buffer.SkipBytes(16);
var meleeTexture2 = buffer.ReadUInt32();
buffer.SkipBytes(16);
}
//positions verified!
outputStream.WriteLine("Position starts at offset {0}", buffer.GetPosition());
var position1 = buffer.ReadUInt32();
outputStream.WriteLine("Position1 untreated {0}", position1);
var position2 = buffer.ReadUInt32();
outputStream.WriteLine("Position2 untreated {0}", position2);
var position3 = buffer.ReadUInt32();
outputStream.WriteLine("Position3 untreated {0}", position3);
var position4 = buffer.ReadUInt32();
outputStream.WriteLine("Position4 untreated {0}", position4);
var position5 = buffer.ReadUInt32();
outputStream.WriteLine("Position5 untreated {0}", position5);
var spawnPos = GetSpawnPosition(position1, position2, position3, position4, position5);
outputStream.WriteLine("(X,Y,Z) = {0}, {1}, {2}, Heading = {3}", spawnPos.X, spawnPos.Y, spawnPos.Z, spawnPos.Heading);
if ((otherData & 16) > 1)
{
outputStream.WriteLine("Title: {0}", buffer.ReadString(false)); //verified
}
if ((otherData & 32) > 1)
{
outputStream.WriteLine("Suffix: {0}", buffer.ReadString(false)); //verified
}
buffer.SkipBytes(8);
var isMerc = buffer.ReadByte(); //verified
outputStream.WriteLine("IsMerc: {0}", isMerc);
buffer.SkipBytes(54);
var expectedLength = buffer.Length();
var currentPoint = buffer.GetPosition();
outputStream.WriteLine("Buffer Length: {0}, Current Position: {1}", expectedLength, currentPoint);
Debug.Assert(currentPoint == expectedLength, "Length mismatch while parsing zone spawns");
outputStream.WriteLine("");
}
catch (Exception)
{
}
}
private static PacketWaitEntry CreateWaitEntry(PacketFilterInfo packetFilterInfo,
PacketDirection direction = PacketDirection.Incoming)
{
return(Engine.PacketWaitEntries.Add(packetFilterInfo, direction));
}
public void ProcessPacket(System.Net.IPAddress srcIp, System.Net.IPAddress dstIp, ushort srcPort, ushort dstPort, byte[] Payload, DateTime PacketTime, bool SubPacket, bool Cached)
{
byte Flags = 0x00;
UInt32 OpCode = (UInt32)(Payload[0] * 256 + Payload[1]);
PacketDirection Direction = GetDirection(srcIp, dstIp, srcPort, dstPort);
if ((Direction == PacketDirection.Unknown) && (OpCode != OP_SessionRequest))
{
return;
}
// Check if this is a UCS connection and if so, skip packets until we see another OP_SessionRequest
if (((CryptoFlag & 4) > 0) && (OpCode != OP_SessionRequest))
{
return;
}
if (Direction == PacketDirection.ClientToServer)
{
Debug("Client -> Server");
}
else
{
Debug("Server -> Client");
}
Debug("Delta: " + (PacketTime - LastPacketTime));
TimeSpan Elapsed = PacketTime - LastPacketTime;
//if (Elapsed.Seconds > 1)
// Debug("*** More than 1 second elapsed ***");
LastPacketTime = PacketTime;
switch (OpCode)
{
case OP_SessionRequest:
{
if (PermaLocked)
{
break;
}
ClientIP = srcIp;
ClientPort = srcPort;
ServerIP = dstIp;
ServerPort = dstPort;
Log("-- Locked onto EQ Stream. Client IP " + srcIp + ":" + srcPort + " Server IP " + dstIp + ":" + dstPort);
ExpectedClientSEQ = 0;
ExpectedServerSEQ = 0;
CryptoFlag = 0;
break;
}
case OP_SessionResponse:
{
CryptoFlag = (ushort)(Payload[11] + (Payload[12] * 256));
Log("Stream Crypto Flag is 0x" + CryptoFlag.ToString("x4"));
break;
}
case OP_Combined:
{
if (DEBUG)
{
Debug("OP_Combined, Direction " + (Direction == PacketDirection.ClientToServer ? "Client->Server" : "Server->Client"));
Debug(Utils.HexDump(Payload));
}
byte[] Uncompressed;
if (!SubPacket && (Payload[2] == 0x5a))
{
Uncompressed = DecompressPacket(Payload, 3);
}
else if (!SubPacket && (Payload[2] == 0xa5))
{
Uncompressed = new byte[Payload.Length - 3];
Array.Copy(Payload, 3, Uncompressed, 0, Payload.Length - 3);
}
else
{
Uncompressed = new byte[Payload.Length - 2];
Array.Copy(Payload, 2, Uncompressed, 0, Payload.Length - 2);
}
int BufferPosition = 0;
while (BufferPosition < Uncompressed.Length - 2)
{
int SubPacketSize = Uncompressed[BufferPosition++];
byte[] NewPacket = new byte[SubPacketSize];
Array.Copy(Uncompressed, BufferPosition, NewPacket, 0, SubPacketSize);
BufferPosition += SubPacketSize;
ProcessPacket(srcIp, dstIp, srcPort, dstPort, NewPacket, PacketTime, true, Cached);
}
break;
}
case OP_Packet:
{
if (DEBUG)
{
Debug("OP_Packet, Subpacket = " + SubPacket);
}
byte[] Uncompressed;
if (!SubPacket && (Payload[2] == 0x5a))
{
if (DEBUG)
{
Debug("Compressed");
}
Uncompressed = DecompressPacket(Payload, 3);
}
else if (!SubPacket && (Payload[2] == 0xa5))
{
if (DEBUG)
{
Debug("0xa5");
}
Uncompressed = new byte[Payload.Length - 5];
Array.Copy(Payload, 3, Uncompressed, 0, Payload.Length - 5);
}
else
{
if (DEBUG)
{
Debug("Uncompressed");
}
Uncompressed = new byte[Payload.Length - 2];
Array.Copy(Payload, 2, Uncompressed, 0, Payload.Length - 2);
}
if (DEBUG)
{
//Debug("Raw payload is:");
//Debug(Utils.HexDump(Payload));
//Debug("Uncompressed data is:");
//Debug(Utils.HexDump(Uncompressed));
}
int Seq = Uncompressed[0] * 256 + Uncompressed[1];
Debug("Seq is " + Seq + " Expected " + GetExpectedSeq(Direction));
if (Seq != GetExpectedSeq(Direction))
{
if (Seq > GetExpectedSeq(Direction))
{
if ((Seq - GetExpectedSeq(Direction) < 1000))
{
AddToCache(Seq, Direction, Payload, PacketTime, SubPacket);
}
else
{
Log("Giving up on seeing expected fragment.");
ErrorsInStream = true;
FragmentSeq[(int)Direction] = -1;
AdvanceSeq(Direction);
}
}
break;
}
else
{
AdvanceSeq(Direction);
}
bool Multi = ((Uncompressed[2] == 0x00) && (Uncompressed[3] == 0x19));
if (Multi)
{
int BufferPosition = 4;
while (BufferPosition < (Uncompressed.Length - 2))
{
int Size = 0;
if (Uncompressed[BufferPosition] == 0xff)
{
if (Uncompressed[BufferPosition + 1] == 0x01)
{
Size = 256 + Uncompressed[BufferPosition + 2];
}
else
{
Size = Uncompressed[BufferPosition + 2];
}
BufferPosition += 3;
}
else
{
Size = Uncompressed[BufferPosition++];
}
int OpCodeBytes = 2;
int AppOpCode = Uncompressed[BufferPosition++];
if (AppOpCode == 0)
{
++BufferPosition;
OpCodeBytes = 3;
}
AppOpCode += (Uncompressed[BufferPosition++] * 256);
ProcessAppPacket(srcIp, dstIp, srcPort, dstPort, AppOpCode, Size - OpCodeBytes, Uncompressed, BufferPosition, Direction, PacketTime);
BufferPosition = BufferPosition + (Size - OpCodeBytes);
}
}
else
{
int BufferPosition = 2;
int OpCodeBytes = 2;
int AppOpCode = Uncompressed[BufferPosition++];
if (AppOpCode == 0)
{
++BufferPosition;
OpCodeBytes = 3;
}
AppOpCode += (Uncompressed[BufferPosition++] * 256);
ProcessAppPacket(srcIp, dstIp, srcPort, dstPort, AppOpCode, Uncompressed.Length - (2 + OpCodeBytes), Uncompressed, BufferPosition, Direction, PacketTime);
}
break;
}
case OP_Fragment:
{
if (DEBUG)
{
Debug("OP_Fragment");
Debug("Raw Data");
Debug(Utils.HexDump(Payload));
}
byte[] Uncompressed;
if (!SubPacket && (Payload[2] == 0x5a))
{
if (DEBUG)
{
Debug("Compressed");
}
Uncompressed = DecompressPacket(Payload, 3);
}
else if (!SubPacket && (Payload[2] == 0xa5))
{
if (DEBUG)
{
Debug("0xa5");
}
Uncompressed = new byte[Payload.Length - 5];
Array.Copy(Payload, 3, Uncompressed, 0, Payload.Length - 5);
}
else
{
Uncompressed = new byte[Payload.Length - 2];
Array.Copy(Payload, 2, Uncompressed, 0, Payload.Length - 2);
}
if (DEBUG)
{
Debug("Uncompressed data.");
Debug(Utils.HexDump(Uncompressed));
}
if (FragmentSeq[(int)Direction] == -1)
{
if (DEBUG)
{
Debug("First fragment.");
}
FragmentSeq[(int)Direction] = (Uncompressed[0] * 256) + Uncompressed[1];
if (DEBUG)
{
Debug("FragmentSeq is " + FragmentSeq[(int)Direction] + " Expecting " + GetExpectedSeq(Direction));
}
if (FragmentSeq[(int)Direction] != GetExpectedSeq(Direction))
{
if (FragmentSeq[(int)Direction] > GetExpectedSeq(Direction))
{
if ((FragmentSeq[(int)Direction] - GetExpectedSeq(Direction)) < 1000)
{
AddToCache(FragmentSeq[(int)Direction], Direction, Payload, PacketTime, SubPacket);
}
else
{
Log("Giving up on seeing expected fragment.");
ErrorsInStream = true;
FragmentSeq[(int)Direction] = -1;
AdvanceSeq(Direction);
}
}
FragmentSeq[(int)Direction] = -1;
break;
}
else
{
AdvanceSeq(Direction);
}
FragmentedPacketSize[(int)Direction] = Uncompressed[2] * 0x1000000 + Uncompressed[3] * 0x10000 + Uncompressed[4] * 0x100 + Uncompressed[5];
if ((FragmentedPacketSize[(int)Direction] == 0) || (FragmentedPacketSize[(int)Direction] > 1000000))
{
if (DEBUG)
{
Debug("Got a fragmented packet of size " + FragmentedPacketSize[(int)Direction] + ". Discarding.");
}
ErrorsInStream = true;
FragmentSeq[(int)Direction] = -1;
break;
}
FragmentedBytesCollected[(int)Direction] = Uncompressed.Length - 6;
if (DEBUG)
{
Debug("Total packet size is " + FragmentedPacketSize[(int)Direction]);
}
if ((Uncompressed.Length - 6) > FragmentedPacketSize[(int)Direction])
{
Log("Mangled fragment.");
ErrorsInStream = true;
FragmentSeq[(int)Direction] = -1;
break;
}
Fragments[(int)Direction] = new byte[FragmentedPacketSize[(int)Direction]];
if (DEBUG)
{
Debug("Copying " + (Uncompressed.Length - 6) + " bytes to Fragments starting at index 0");
}
Array.Copy(Uncompressed, 6, Fragments[(int)Direction], 0, Uncompressed.Length - 6);
}
else
{
int LastSeq = FragmentSeq[(int)Direction];
FragmentSeq[(int)Direction] = (Uncompressed[0] * 256) + Uncompressed[1];
if (DEBUG)
{
Debug("FragmentSeq is " + FragmentSeq[(int)Direction] + ". Expecting " + GetExpectedSeq(Direction));
}
if (FragmentSeq[(int)Direction] != GetExpectedSeq(Direction))
{
if (FragmentSeq[(int)Direction] > GetExpectedSeq(Direction))
{
if ((FragmentSeq[(int)Direction] - GetExpectedSeq(Direction)) < 1000)
{
AddToCache(FragmentSeq[(int)Direction], Direction, Payload, PacketTime, SubPacket);
}
else
{
Log("Giving up on seeing expected fragment.");
ErrorsInStream = true;
AdvanceSeq(Direction);
FragmentSeq[(int)Direction] = -1;
}
}
break;
}
else
{
AdvanceSeq(Direction);
}
if (DEBUG)
{
Debug("Copying " + (Uncompressed.Length - 2) + " bytes from Uncompressed to Fragments starting at " + FragmentedBytesCollected[(int)Direction]);
}
if ((Uncompressed.Length - 2) > (Fragments[(int)Direction].Length - FragmentedBytesCollected[(int)Direction]))
{
Log("Mangled fragment. Discarding.");
ErrorsInStream = true;
FragmentSeq[(int)Direction] = -1;
break;
}
Array.Copy(Uncompressed, 2, Fragments[(int)Direction], FragmentedBytesCollected[(int)Direction], Uncompressed.Length - 2);
FragmentedBytesCollected[(int)Direction] += Uncompressed.Length - 2;
if (FragmentedBytesCollected[(int)Direction] == FragmentedPacketSize[(int)Direction])
{
if (DEBUG)
{
Debug("Got whole packet.");
}
if ((Fragments[(int)Direction][0] == 0x00) && (Fragments[1][(int)Direction] == 0x019))
{
if (DEBUG)
{
Debug("Multi packet.");
}
int BufferPosition = 2;
while (BufferPosition < Fragments[(int)Direction].Length)
{
int Size = 0;
if (Fragments[(int)Direction][BufferPosition] == 0xff)
{
if (Fragments[(int)Direction][BufferPosition + 1] == 0x01)
{
Size = 256 + Fragments[(int)Direction][BufferPosition + 2];
}
else
{
Size = Fragments[(int)Direction][BufferPosition + 2];
}
BufferPosition += 3;
}
else
{
Size = Fragments[(int)Direction][BufferPosition++];
}
int OpCodeBytes = 2;
int AppOpCode = Fragments[(int)Direction][BufferPosition++];
if (AppOpCode == 0)
{
++BufferPosition;
OpCodeBytes = 3;
}
AppOpCode += (Fragments[(int)Direction][BufferPosition++] * 256);
ProcessAppPacket(srcIp, dstIp, srcPort, dstPort, AppOpCode, Size - OpCodeBytes, Fragments[(int)Direction], BufferPosition, Direction, PacketTime);
BufferPosition = BufferPosition + (Size - OpCodeBytes);
}
}
else
{
int BufferPosition = 0;
int OpCodeBytes = 2;
int AppOpCode = Fragments[(int)Direction][BufferPosition++];
if (AppOpCode == 0)
{
++BufferPosition;
OpCodeBytes = 3;
}
AppOpCode += (Fragments[(int)Direction][BufferPosition++] * 256);
byte[] NewPacket = new byte[Fragments[(int)Direction].Length - OpCodeBytes];
Array.Copy(Fragments[(int)Direction], BufferPosition, NewPacket, 0, Fragments[(int)Direction].Length - OpCodeBytes);
ProcessAppPacket(srcIp, dstIp, srcPort, dstPort, AppOpCode, NewPacket.Length, NewPacket, 0, Direction, PacketTime);
}
if (DEBUG)
{
Debug("Reseting FragmentSeq to -1");
}
FragmentSeq[(int)Direction] = -1;
}
}
break;
}
case OP_OutOfOrderAck:
{
int Seq = Payload[2] * 256 + Payload[3];
if (DEBUG)
{
Debug("OP_OutOfOrder " + Seq);
}
break;
}
case OP_Ack:
{
int Seq;
if (Payload.Length > 4)
{
Seq = Payload[3] * 256 + Payload[4];
}
else
{
Seq = Payload[2] * 256 + Payload[3];
}
string DirectionString;
if (Direction == PacketDirection.ClientToServer)
{
DirectionString = "Client to Server";
}
else
{
DirectionString = "Server to Client";
}
if (DEBUG)
{
Debug("OP_Ack, Seq " + Seq + " " + DirectionString);
Debug(Utils.HexDump(Payload));
}
break;
}
default:
if (OpCode > 0xff)
{
if (DEBUG)
{
Debug("Unencapsulated EQ Application OpCode. Subpacket is " + SubPacket.ToString());
Debug("--- Raw payload ---");
Debug(Utils.HexDump(Payload));
Debug("-------------------");
}
int AppOpCode;
byte[] NewPacket;
if (SubPacket)
{
AppOpCode = Payload[1] * 256 + Payload[0];
NewPacket = new byte[Payload.Length - 2];
Array.Copy(Payload, 2, NewPacket, 0, Payload.Length - 2);
}
else
{
// This packet has a flag byte between the first and second bytes of the opcode, and also a CRC
Flags = Payload[1];
if (Flags == 0x5a)
{
if (DEBUG)
{
Debug("Compressed unencapsulated packet.");
}
byte[] NewPayload = new byte[Payload.Length - 4];
Array.Copy(Payload, 2, NewPayload, 0, Payload.Length - 4);
byte[] Uncompressed = DecompressPacket(NewPayload, 0);
if (DEBUG)
{
Debug("Uncompressed Payload:");
Debug(Utils.HexDump(Uncompressed));
}
// Opcode is first byte of compressed payload and first byte of uncompressed data
AppOpCode = Uncompressed[0] * 256 + Payload[0];
NewPacket = new byte[Uncompressed.Length - 1];
Array.Copy(Uncompressed, 1, NewPacket, 0, Uncompressed.Length - 1);
}
else
{
AppOpCode = Payload[2] * 256 + Payload[0];
NewPacket = new byte[Payload.Length - 5];
Array.Copy(Payload, 3, NewPacket, 0, Payload.Length - 5);
}
}
ProcessAppPacket(srcIp, dstIp, srcPort, dstPort, AppOpCode, NewPacket.Length, NewPacket, 0, Direction, PacketTime);
}
else
{
if (DEBUG)
{
Debug("OP_Unknown (" + OpCode.ToString("x") + ")");
Debug(Utils.HexDump(Payload));
}
}
break;
}
if (!Cached && !CacheEmpty())
{
ProcessCache();
}
}
protected virtual NetConnection Create(PacketDirection packetDirection, Socket socket, ConnectionConfirmed confirmedAction = null)
{
NetConnection conn = new NetConnection(packetDirection, socket, confirmedAction);
return(conn);
}
public void ExploreNPCMoveUpdate(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
{
PositionUpdate PosUpdate;
PosUpdate = Decode_OP_NPCMoveUpdate(Buffer.Buffer);
OutputStream.WriteLine("SpawnID: {0}, X = {1}, Y = {2}, Z = {3}, Heading = {4}", PosUpdate.SpawnID, PosUpdate.p.x, PosUpdate.p.y, PosUpdate.p.z, PosUpdate.p.heading);
}
public HTTPMessage(int index, PacketDirection direction, DateTime startTime)
: base(index, direction, startTime, startTime)
{
HeaderRowsPerCol = 1000;
}
public PacketBuffer(PacketDirection direction)
{
Direction = direction;
}
/*
* from seq source int32_t ZoneMgr::fillProfileStruct(charProfileStruct *player, const uint8_t *data, size_t len, bool checkLen)
*
* */
public override void ExplorePlayerProfile(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
outputStream.WriteLine("MooDump");
outputStream.WriteLine("{0, -5}: Checksum = {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
// Unknown
buffer.SkipBytes(12);
outputStream.WriteLine("");
outputStream.WriteLine("{0, -5}: Gender = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Race = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Class = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Level = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Level1 = {1}", buffer.GetPosition(), buffer.ReadByte());
// Bind points
int BindCount = buffer.ReadInt32();
outputStream.WriteLine("{0, -5}: BindCount = {1}", buffer.GetPosition() - 4, BindCount);
//not sure if this is right tbh
for (int i = 0; i < BindCount; ++i)
{
outputStream.WriteLine("{0, -5}: Bind: {1} Zone: {2} XYZ: {3},{4},{5} Heading: {6}",
buffer.GetPosition(), i, buffer.ReadUInt32(), buffer.ReadSingle(), buffer.ReadSingle(),
buffer.ReadSingle(), buffer.ReadSingle());
}
outputStream.WriteLine("");
outputStream.WriteLine("{0, -5}: Deity = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Intoxication = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("");
// Spell slot refresh
int spellRefreshCount = buffer.ReadInt32();
outputStream.WriteLine("{0, -5}: SpellRefreshCount = {1}", buffer.GetPosition() - 4, spellRefreshCount);
for (int i = 0; i < spellRefreshCount; i++)
{
outputStream.WriteLine("{0, -5}: SpellRefreshCount{1} = {2}", buffer.GetPosition(), i,
buffer.ReadUInt32());
}
// Equipment
uint EquipmentCount = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: EquipmentCount = {1}", buffer.GetPosition() - 4, EquipmentCount);
for (int i = 0; i < EquipmentCount; ++i)
{
outputStream.Write("{0, -5}: Equip: {1} Values: ", buffer.GetPosition(), i);
for (int j = 0; j < 5; ++j)
{
outputStream.Write(j != 3 ? "{0} " : " ItemId {0} ", buffer.ReadUInt32());
}
outputStream.WriteLine("");
}
// Something (9 ints)
var sCount = buffer.ReadUInt32();
for (var i = 0; i < sCount; i++)
{
buffer.SkipBytes(20);
}
// Something (9 ints)
var sCount1 = buffer.ReadUInt32();
for (var i = 0; i < sCount1; i++)
{
buffer.SkipBytes(4);
}
// Something (9 ints)
var sCount2 = buffer.ReadUInt32();
for (var i = 0; i < sCount2; i++)
{
buffer.SkipBytes(4);
}
int preposn = buffer.GetPosition();
outputStream.WriteLine("{0, -5}: Hair Color = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Beard Color = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Eye1 Color = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Eye2 Color = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Hairstyle = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Beard = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Face = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Drakkin Heritage = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Drakkin Tattoo = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Drakkin Details = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown = {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Height = {1}", buffer.GetPosition(), buffer.ReadSingle());
outputStream.WriteLine("{0, -5}: Unknown = {1}", buffer.GetPosition(), buffer.ReadSingle());
outputStream.WriteLine("{0, -5}: Unknown = {1}", buffer.GetPosition(), buffer.ReadSingle());
outputStream.WriteLine("{0, -5}: Unknown = {1}", buffer.GetPosition(), buffer.ReadSingle());
outputStream.WriteLine("{0, -5}: Primary = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Secondary = {1}", buffer.GetPosition(), buffer.ReadUInt32());
int diff = buffer.GetPosition() - preposn;
outputStream.WriteLine("Diff should be 52: {0}", diff);
// Looks like face, haircolor, beardcolor, eyes, etc. Skipping over it.
//Buffer.SkipBytes(52);
outputStream.WriteLine("{0, -5}: Unspent Skill Points = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Mana = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Current HP = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: STR = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: STA = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: CHA = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: DEX = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: INT = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: AGI = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: WIS = {1}", buffer.GetPosition(), buffer.ReadUInt32());
buffer.SkipBytes(28);
//Buffer.SkipBytes(28);
UInt32 AACount = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: AA Count = {1}", buffer.GetPosition() - 4, AACount);
for (int i = 0; i < AACount; ++i)
{
outputStream.WriteLine(" AA: {0}, Value: {1}, Unknown08: {2}", buffer.ReadUInt32(),
buffer.ReadUInt32(), buffer.ReadUInt32());
//Buffer.SkipBytes(12);
}
// Something (100 ints)
uint sCount3 = buffer.ReadUInt32();
for (int i = 0; i < sCount3; i++)
{
buffer.SkipBytes(4);
}
// Something (25 ints)
uint sCount4 = buffer.ReadUInt32();
for (int i = 0; i < sCount4; i++)
{
buffer.SkipBytes(4);
}
// Something (300 ints)
uint sCount5 = buffer.ReadUInt32();
for (int i = 0; i < sCount5; i++)
{
buffer.SkipBytes(4);
}
// Something (20 ints)
uint sCount6 = buffer.ReadUInt32();
for (int i = 0; i < sCount6; i++)
{
buffer.SkipBytes(4);
}
// Something (20 floats)
uint sCount7 = buffer.ReadUInt32();
for (int i = 0; i < sCount7; i++)
{
buffer.SkipBytes(4);
}
// Something (100 floats)
uint sCount8 = buffer.ReadUInt32();
for (int i = 0; i < sCount8; i++)
{
buffer.SkipBytes(4);
}
UInt32 SpellBookSlots = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: SpellBookSlot Count = {1}", buffer.GetPosition() - 4, SpellBookSlots);
for (int i = 0; i < SpellBookSlots; ++i)
{
buffer.SkipBytes(4);
}
UInt32 SpellMemSlots = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Spell Mem Count = {1}", buffer.GetPosition() - 4, SpellMemSlots);
for (int i = 0; i < SpellMemSlots; ++i)
{
buffer.SkipBytes(4);
}
// Something (13 ints)
uint sCount9 = buffer.ReadUInt32();
for (int i = 0; i < sCount9; i++)
{
buffer.SkipBytes(4);
}
// Unknown
buffer.SkipBytes(1);
UInt32 BuffCount = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Buff Count = {1}", buffer.GetPosition() - 4, BuffCount);
for (int i = 0; i < BuffCount; ++i)
{
buffer.ReadByte();
float UnkFloat = buffer.ReadSingle();
UInt32 PlayerID = buffer.ReadUInt32();
Byte UnkByte = buffer.ReadByte();
UInt32 Counters1 = buffer.ReadUInt32();
UInt32 Duration = buffer.ReadUInt32();
Byte Level = buffer.ReadByte();
UInt32 SpellID = buffer.ReadUInt32();
UInt32 SlotID = buffer.ReadUInt32();
buffer.SkipBytes(5);
UInt32 Counters2 = buffer.ReadUInt32();
outputStream.WriteLine(
"Sl: {0}, UF: {1}, PID: {2}, UByte: {3}, Cnt1: {4}, Dur: {5}, Lvl: {6} SpellID: {7}, SlotID: {8}, Cnt2: {9}",
i, UnkFloat, PlayerID, UnkByte, Counters1, Duration, Level, SpellID, SlotID, Counters2);
buffer.SkipBytes(44);
}
outputStream.WriteLine("{0, -5}: Plat = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Gold = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Silver = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Copper = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Plat Cursor = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Gold Cursor = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Silver Cursor = {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Copper Cursor = {1}", buffer.GetPosition(), buffer.ReadUInt32());
// Unknown
buffer.SkipBytes(20);
outputStream.WriteLine("{0, -5}: AA Spent = {1}", buffer.GetPosition(), buffer.ReadUInt32());
// Unknown
buffer.SkipBytes(4);
outputStream.WriteLine("{0, -5}: AA Assigned = {1}", buffer.GetPosition(), buffer.ReadUInt32());
// Unknown
buffer.SkipBytes(16);
outputStream.WriteLine("{0, -5}: AA Unspent = {1}", buffer.GetPosition(), buffer.ReadUInt32());
// Unknown
buffer.SkipBytes(2);
/*
* // Bandolier
* Buffer.SkipBytes(1319);
*
* // Potion Belt
* Buffer.SkipBytes(160);
*/
//this could be wrong we could just skip
UInt32 BandolierCount = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Bandolier Count = {1}", buffer.GetPosition() - 4, BandolierCount);
for (int i = 0; i < BandolierCount; ++i)
{
buffer.ReadString(false);
buffer.ReadString(false);
buffer.SkipBytes(8);
buffer.ReadString(false);
buffer.SkipBytes(8);
buffer.ReadString(false);
buffer.SkipBytes(8);
buffer.ReadString(false);
buffer.SkipBytes(8);
}
UInt32 PotionCount = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Potion Count = {1}", buffer.GetPosition() - 4, PotionCount);
for (int i = 0; i < PotionCount; ++i)
{
buffer.ReadString(false);
buffer.SkipBytes(8);
}
// Unknown
buffer.SkipBytes(84);
outputStream.WriteLine("{0, -5}: Endurance= {1}", buffer.GetPosition(), buffer.ReadUInt32());
// Unknown
buffer.SkipBytes(8);
UInt32 NameLength = buffer.ReadUInt32();
var posn = buffer.GetPosition();
outputStream.WriteLine("{0, -5}: Name Length: {1}", buffer.GetPosition() - 4, NameLength);
var name = buffer.ReadString(false);
outputStream.WriteLine("{0, -5}: Name: {1}", buffer.GetPosition(), name);
int CurrentPosition = buffer.GetPosition();
diff = CurrentPosition - posn;
var skip = (int)NameLength - diff;
outputStream.WriteLine("Diff is {0}. If it is not 0, then we will go overboard when setting posn. Skipping {1} bytes", diff, skip);
buffer.SkipBytes(skip);
UInt32 LastNameLength = buffer.ReadUInt32();
posn = buffer.GetPosition();
outputStream.WriteLine("{0, -5}: LastName Length: {1}", buffer.GetPosition() - 4, LastNameLength);
name = buffer.ReadString(false);
outputStream.WriteLine("{0, -5}: Last Name: {1}", buffer.GetPosition(), name);
CurrentPosition = buffer.GetPosition();
diff = CurrentPosition - posn;
skip = (int)LastNameLength - diff;
outputStream.WriteLine("Diff is {0}. If it is not 0, then we will go overboard when setting posn. Skipping {1} bytes", diff, skip);
buffer.SkipBytes(skip);
// Unknown
//Buffer.SkipBytes(4);
outputStream.WriteLine("{0, -5}: Birthday {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Account start date {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Last Save Date {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Time played in Minutes {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Time Entitled On Account {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Expansions {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
UInt32 LanguageCount = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Language Count = {1}", buffer.GetPosition() - 4, LanguageCount);
for (int i = 0; i < LanguageCount; ++i)
{
buffer.SkipBytes(1);
}
outputStream.WriteLine("{0, -5}: Zone ID {1}", buffer.GetPosition(), buffer.ReadUInt16());
outputStream.WriteLine("{0, -5}: Zone Instance {1}", buffer.GetPosition(), buffer.ReadUInt16());
outputStream.WriteLine("{0, -5}: Y,X,Z {1},{2},{3} Heading: {4}",
buffer.GetPosition(), buffer.ReadSingle(), buffer.ReadSingle(), buffer.ReadSingle(),
buffer.ReadSingle());
//Moofta all above here is verified
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: GuildID? {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Experience {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Bank Plat {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Bank Gold {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Bank Silver {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Bank Copper {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Shared plat? {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
UInt32 Unknown42 = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Unknown, value 42? {1}", buffer.GetPosition() - 4, Unknown42);
buffer.SkipBytes((int)(Unknown42 * 8));
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Career Tribute Favour {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Current Tribute Favour {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
UInt32 PersonalTributeCount = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Personal Tribute Count {1}", buffer.GetPosition() - 4,
PersonalTributeCount);
buffer.SkipBytes((int)(PersonalTributeCount * 8));
UInt32 GuildTributeCount = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Guild Tribute Count {1}", buffer.GetPosition() - 4, GuildTributeCount);
buffer.SkipBytes((int)(GuildTributeCount * 8));
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("Skipping 121 bytes starting at offset {0}", buffer.GetPosition());
buffer.SkipBytes(121);
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("Position now {0}", buffer.GetPosition());
UInt32 Unknown64 = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Unknown64 {1}", buffer.GetPosition() - 4, Unknown64);
buffer.SkipBytes((int)Unknown64);
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
Unknown64 = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Unknown64 {1}", buffer.GetPosition() - 4, Unknown64);
buffer.SkipBytes((int)Unknown64);
Unknown64 = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Unknown64 {1}", buffer.GetPosition() - 4, Unknown64);
buffer.SkipBytes((int)Unknown64);
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("Skipping 320 bytes starting at offset {0}", buffer.GetPosition());
buffer.SkipBytes(320);
outputStream.WriteLine("Skipping 343 bytes starting at offset {0}", buffer.GetPosition());
buffer.SkipBytes(343);
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
UInt32 Unknown6 = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Unknown6 {1} LDON Stuff then why have the count before it?", buffer.GetPosition() - 4, Unknown6);
//for (int i = 0; i < Unknown6; ++i)
//{
// OutputStream.WriteLine("{0, -5}: Unknown LDON? {1}", Buffer.GetPosition(), Buffer.ReadUInt32());
//}
outputStream.WriteLine("{0, -5}: Ldon GUK points? {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Ldon MIR points? {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Ldon mmc points? {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Ldon ruj points? {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Ldon tak points? {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Ldon available points? {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
Unknown64 = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Unknown64 {1}", buffer.GetPosition() - 4, Unknown64);
buffer.SkipBytes((int)Unknown64 * 4);
// Air remaining ?
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
// Next 7 could be PVP stats,
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
// PVP LastKill struct ?
outputStream.WriteLine("Skipping string + 24 bytes starting at offset {0}", buffer.GetPosition());
//Buffer.SkipBytes(25);
Byte b;
do
{
b = buffer.ReadByte();
} while (b != 0);
buffer.SkipBytes(24);
// PVP LastDeath struct ?
outputStream.WriteLine("Skipping string + 24 bytes starting at offset {0}", buffer.GetPosition());
//Buffer.SkipBytes(25);
do
{
b = buffer.ReadByte();
} while (b != 0);
buffer.SkipBytes(24);
// PVP Number of Kills in Last 24 hours ?
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
UInt32 Unknown50 = buffer.ReadUInt32();
outputStream.WriteLine("{0, -5}: Unknown50 {1}", buffer.GetPosition() - 4, Unknown50);
// PVP Recent Kills ?
outputStream.WriteLine("Pss pvp recent kills Skipping 50 x (String + 24 bytes) starting at offset {0}", buffer.GetPosition());
//Buffer.SkipBytes(1338);
for (int i = 0; i < 50; ++i)
{
do
{
b = buffer.ReadByte();
} while (b != 0);
buffer.SkipBytes(24);
}
//
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Group autoconsent? {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Raid autoconsent? {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Guild autoconsent? {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: Level3? {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("{0, -5}: Showhelm? {1}", buffer.GetPosition(), buffer.ReadByte());
outputStream.WriteLine("{0, -5}: RestTimer? {1}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("Skipping 1028 bytes starting at offset {0}", buffer.GetPosition());
buffer.SkipBytes(1028);
//outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
//outputStream.WriteLine("{0, -5}: Unknown {1:X}", buffer.GetPosition(), buffer.ReadUInt32());
outputStream.WriteLine("Pointer is {0} bytes from end.", buffer.Length() - buffer.GetPosition());
}
private bool HandleSwitchboardSession(IPSession session)
{
List <PacketSlice> slices = new List <PacketSlice>(1);
logger.AddMessage(String.Format("\r\n\r\nparsing session with remote endpoint: {0}\r\n", session.RemoteEndpoint));
while (true)
{
PacketStream stream = session.GetNextStreamDirection();
if (stream.GetBytesAvailable() == 0)
{
stream = session.GetNextStreamDirection();
if (stream.GetBytesAvailable() == 0)
{
break;
}
}
IPPacket pkt = stream.CurPacket;
PacketDirection direction = pkt.Direction;
try
{
string line = stream.PeekLineUTF8();
// Split the line up into CMD and the rest (being arguments, if any)
string[] tokens = line.Split(new char[] { ' ' }, 2);
logger.AddMessage(String.Format("{0} parsing command '{1}' (line: {2})",
(direction == PacketDirection.PACKET_DIRECTION_INCOMING) ? "<<" : ">>",
tokens[0], line));
// Set cmd and create an array of arguments if present
string cmd = tokens[0];
string[] arguments = new string[0];
if (tokens.Length > 1)
{
arguments = tokens[1].Split(new char[] { ' ' });
}
// Create command node
TransactionNode node = new TransactionNode("MSNSBCommand");
node.Description = cmd;
// Command field
stream.ReadBytes(StaticUtils.GetUTF8ByteCount(tokens[0]), slices);
node.AddField("Command", tokens[0], "Switchboard command.", slices);
if (arguments.Length > 0)
{
// Skip space between command and arguments
stream.ReadByte();
stream.ReadBytes(StaticUtils.GetUTF8ByteCount(tokens[1]), slices);
// Arguments fields
node.AddField("Arguments", tokens[1], "Arguments to command.", slices);
}
// Skip CRLF
stream.ReadBytes(2);
// Is there a payload?
bool hasPayload = false;
if (arguments.Length > 0)
{
List <string> payloadCommands =
(direction == PacketDirection.PACKET_DIRECTION_OUTGOING) ? payloadCommandsFromClient : payloadCommandsFromServer;
hasPayload = payloadCommands.Contains(cmd);
}
if (hasPayload)
{
int payloadLength = -1;
try
{
payloadLength = (int)Convert.ToUInt32(arguments[arguments.Length - 1]);
}
catch (FormatException)
{
}
if (payloadLength > 0)
{
TransactionNode payloadNode = new TransactionNode(node, "Payload");
logger.AddMessage(String.Format("Parsing {0} bytes of payload", payloadLength));
PayloadFormat format = PayloadFormat.TEXT;
string cmdUpper = cmd.ToUpper();
if (payloadCommandFormats.ContainsKey(cmdUpper))
{
format = payloadCommandFormats[cmdUpper];
}
if (format == PayloadFormat.MESSAGE)
{
SBParseMSG(stream, payloadNode, payloadLength);
}
else
{
string body = stream.ReadStringUTF8(payloadLength, slices);
switch (format)
{
case PayloadFormat.SLP:
payloadNode.AddTextField("MSNSLP", body, "MSNSLP data.", slices);
break;
case PayloadFormat.XML:
payloadNode.AddXMLField("XML", body, "XML data.", slices);
break;
default:
payloadNode.AddTextField("Text", body, "Text.", slices);
break;
}
}
}
}
session.AddNode(node);
}
catch (EndOfStreamException e)
{
logger.AddMessage(String.Format("MSNSwitchboard: EOS at {0} ({1})", stream.Position, e));
break;
}
}
logger.AddMessage("done with session\r\n\r\n");
return(true);
}
public override void ExploreZoneEntry(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
if (direction != PacketDirection.ServerToClient)
{
return;
}
string SpawnName = buffer.ReadString(true);
UInt32 SpawnID = buffer.ReadUInt32();
byte Level = buffer.ReadByte();
float UnkSize = buffer.ReadSingle();
byte IsNPC = buffer.ReadByte();
UInt32 Bitfield = buffer.ReadUInt32();
/*
* NewSpawn.Showname = (Bitfield >> 28) & 1;
* NewSpawn.TargetableWithHotkey = (Bitfield >> 27) & 1;
* NewSpawn.Targetable = (Bitfield >> 26) & 1;
*
* NewSpawn.ShowHelm = (Bitfield >> 24) & 1;
* NewSpawn.Gender = (Bitfield >> 20) & 3;
*
* NewSpawn.Padding5 = (Bitfield >> 4) & 1;
* NewSpawn.Padding7 = (Bitfield >> 6) & 2047;
* NewSpawn.Padding26 = (Bitfield >> 25) & 1;
*/
Byte OtherData = buffer.ReadByte();
buffer.SkipBytes(8); // Skip 8 unknown bytes
//NewSpawn.DestructableString1 = "";
//NewSpawn.DestructableString2 = "";
//NewSpawn.DestructableString3 = "";
if ((IsNPC > 0) && ((OtherData & 3) > 0))
{
// Destructable Objects. Not handled yet
//
//SQLOut(String.Format("-- OBJECT FOUND SpawnID {0}", SpawnID.ToString("x")));
buffer.ReadString(false);
buffer.ReadString(false);
buffer.ReadString(false);
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadByte();
}
outputStream.WriteLine("Size starts at offset {0}", buffer.GetPosition());
float Size = buffer.ReadSingle();
byte Face = buffer.ReadByte();
float WalkSpeed = buffer.ReadSingle();
float RunSpeed = buffer.ReadSingle();
UInt32 Race = buffer.ReadUInt32();
byte PropCount = buffer.ReadByte();
UInt32 BodyType = 0;
if (PropCount >= 1)
{
BodyType = buffer.ReadUInt32();
for (int j = 1; j < PropCount; ++j)
{
buffer.SkipBytes(4);
}
}
buffer.SkipBytes(1); // Skip HP %
byte HairColor = buffer.ReadByte();
byte BeardColor = buffer.ReadByte();
byte EyeColor1 = buffer.ReadByte();
byte EyeColor2 = buffer.ReadByte();
byte HairStyle = buffer.ReadByte();
byte Beard = buffer.ReadByte();
UInt32 DrakkinHeritage = buffer.ReadUInt32();
UInt32 DrakkinTattoo = buffer.ReadUInt32();
UInt32 DrakkinDetails = buffer.ReadUInt32();
buffer.SkipBytes(1); // Skip Holding
UInt32 Deity = buffer.ReadUInt32();
buffer.SkipBytes(8); // Skip GuildID and GuildRank
byte Class = buffer.ReadByte();
buffer.SkipBytes(4); // Skip PVP, Standstate, Light, Flymode
byte EquipChest2 = buffer.ReadByte();
bool UseWorn = (EquipChest2 == 255);
buffer.SkipBytes(2); // 2 Unknown bytes;
byte Helm = buffer.ReadByte();
string LastName = buffer.ReadString(true);
buffer.SkipBytes(5); // AATitle + unknown byte
UInt32 PetOwnerID = buffer.ReadUInt32();
buffer.SkipBytes(26); // Unknown byte + 6 unknown uint32
outputStream.WriteLine("Position starts at offset {0}", buffer.GetPosition());
UInt32 Position1 = buffer.ReadUInt32();
UInt32 Position2 = buffer.ReadUInt32();
UInt32 Position3 = buffer.ReadUInt32();
UInt32 Position4 = buffer.ReadUInt32();
UInt32 Position5 = buffer.ReadUInt32();
float YPos = Utils.EQ19ToFloat((Int32)(Position3 & 0x7FFFF));
float Heading = Utils.EQ19ToFloat((Int32)(Position4 & 0xFFF));
float XPos = Utils.EQ19ToFloat((Int32)(Position4 >> 12) & 0x7FFFF);
float ZPos = Utils.EQ19ToFloat((Int32)(Position5 & 0x7FFFF));
outputStream.WriteLine("(X,Y,Z) = {0}, {1}, {2}, Heading = {3}", XPos, YPos, ZPos, Heading);
if (NPCType.IsPlayableRace(Race))
{
for (int ColourSlot = 0; ColourSlot < 9; ++ColourSlot)
{
outputStream.WriteLine("Color {0} is {1}", ColourSlot, buffer.ReadUInt32());
}
}
outputStream.WriteLine("");
}
public virtual void ExploreMercenaryPurchaseWindow(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
throw new NotImplementedException();
}
public void ExploreCharInventoryPacket(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
{
UInt32 ItemCount = Buffer.ReadUInt32();
OutputStream.WriteLine("There are {0} items in the inventory.\r\n", ItemCount);
for (int i = 0; i < ItemCount; ++i)
{
ExploreSubItem(OutputStream, ref Buffer);
}
OutputStream.WriteLine("");
}
protected BasePacket(PacketDirection direction)
{
Direction = direction;
}
public void ExploreZoneEntry(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
{
if (Direction != PacketDirection.ServerToClient)
{
return;
}
string Name = Buffer.ReadString(false);
UInt32 SpawnID = Buffer.ReadUInt32();
byte Level = Buffer.ReadByte();
Buffer.SkipBytes(4);
bool IsNPC = (Buffer.ReadByte() != 0);
UInt32 Bitfield = Buffer.ReadUInt32();
string DestructableString1;
string DestructableString2;
string DestructableString3;
UInt32 DestructableUnk1;
UInt32 DestructableUnk2;
UInt32 DestructableID1;
UInt32 DestructableID2;
UInt32 DestructableID3;
UInt32 DestructableID4;
UInt32 DestructableUnk3;
UInt32 DestructableUnk4;
UInt32 DestructableUnk5;
UInt32 DestructableUnk6;
UInt32 DestructableUnk7;
UInt32 DestructableUnk8;
UInt32 DestructableUnk9;
byte DestructableByte;
Byte OtherData = Buffer.ReadByte();
Buffer.SkipBytes(8); // Skip 8 unknown bytes
DestructableString1 = "";
DestructableString2 = "";
DestructableString3 = "";
OutputStream.WriteLine("Spawn Name: {0} ID: {1} Level: {2} {3}\r\n", Name, SpawnID, Level, IsNPC ? "NPC" : "Player");
if ((OtherData & 1) > 0)
{
// Destructable Objects.
DestructableString1 = Buffer.ReadString(false);
DestructableString2 = Buffer.ReadString(false);
DestructableString3 = Buffer.ReadString(false);
DestructableUnk1 = Buffer.ReadUInt32();
DestructableUnk2 = Buffer.ReadUInt32();
DestructableID1 = Buffer.ReadUInt32();
DestructableID2 = Buffer.ReadUInt32();
DestructableID3 = Buffer.ReadUInt32();
DestructableID4 = Buffer.ReadUInt32();
DestructableUnk3 = Buffer.ReadUInt32();
DestructableUnk4 = Buffer.ReadUInt32();
DestructableUnk5 = Buffer.ReadUInt32();
DestructableUnk6 = Buffer.ReadUInt32();
DestructableUnk7 = Buffer.ReadUInt32();
DestructableUnk8 = Buffer.ReadUInt32();
DestructableUnk9 = Buffer.ReadUInt32();
DestructableByte = Buffer.ReadByte();
OutputStream.WriteLine("DESTRUCTABLE OBJECT:\r\n");
OutputStream.WriteLine(" String1: {0}", DestructableString1);
OutputStream.WriteLine(" String2: {0}", DestructableString2);
OutputStream.WriteLine(" String3: {0}\r\n", DestructableString3);
OutputStream.WriteLine(" Unk1: {0,8:x} Unk2: {1,8:x}\r\n ID1 : {2,8:x} ID2 : {3,8:x} ID3 : {4,8:x} ID4 : {5,8:x}\r\n Unk3: {6,8:x} Unk4: {7,8:x} Unk5: {8,8:x} Unk6: {9,8:x}\r\n Unk7: {10,8:x} Unk8: {11,8:x} Unk9: {12,8:x}\r\n UnkByte: {13,2:x}",
DestructableUnk1, DestructableUnk2, DestructableID1, DestructableID2, DestructableID3, DestructableID4,
DestructableUnk3, DestructableUnk4, DestructableUnk5, DestructableUnk6, DestructableUnk7, DestructableUnk8,
DestructableUnk9, DestructableByte);
}
Buffer.SkipBytes(17);
byte PropCount = Buffer.ReadByte();
if (PropCount >= 1)
{
Buffer.SkipBytes(4);
for (int j = 1; j < PropCount; ++j)
{
Buffer.SkipBytes(4);
}
}
byte HP = Buffer.ReadByte();
OutputStream.WriteLine("HP% is {0}\r\n", HP);
AddExplorerSpawn(SpawnID, Name);
}
public override VisualTransaction[] GetTransactions(IPSession session)
{
List <MSNSessionMessage> messages = new List <MSNSessionMessage>();
Dictionary <UInt32, MSNP2PMessage> messageFromId = new Dictionary <UInt32, MSNP2PMessage>();
foreach (TransactionNode node in session.Nodes)
{
if (node.Name.StartsWith("MSN"))
{
TransactionNode chunk = node.FindChild("MSNP2PMessageChunk");
if (chunk != null)
{
MSNP2PMessage msg;
TransactionNode headers = chunk.FindChild("Headers");
UInt32 msgID = (UInt32)headers.Fields["MessageID"];
UInt32 chunkSize = (UInt32)headers.Fields["ChunkSize"];
if (messageFromId.ContainsKey(msgID))
{
msg = messageFromId[msgID];
}
else
{
PacketDirection direction =
headers.GetSlicesForFieldPath("SessionID")[0].Packet.Direction;
UInt32 sessionID = (UInt32)headers.Fields["SessionID"];
UInt32 flags = (UInt32)headers.Fields["Flags"];
UInt64 dataOffset = (UInt64)headers.Fields["DataOffset"];
UInt64 dataSize = (UInt64)headers.Fields["DataSize"];
UInt32 ackedMsgID = (UInt32)headers.Fields["AckedMsgID"];
UInt32 prevAckedMsgID = (UInt32)headers.Fields["PrevAckedMsgID"];
UInt64 ackedDataSize = (UInt64)headers.Fields["AckedDataSize"];
msg = new MSNP2PMessage(chunk.Index, direction, chunk.StartTime,
msgID, sessionID, flags, dataOffset, dataSize, ackedMsgID,
prevAckedMsgID, ackedDataSize);
messages.Add(msg);
messageFromId[msgID] = msg;
}
int maxPreview = 4096;
if (msg.Flags == 0x20)
{
maxPreview = 131072;
}
if (chunkSize > 0 && msg.Transferred < (ulong)maxPreview)
{
TransactionNode content = chunk.FindChild("Content");
//string fieldName = (msg.SessionID != 0) ? "Raw" : "MSNSLP";
byte[] bytes = (byte[])content.Fields[content.FieldNames[0]];
int n = bytes.Length;
int max = maxPreview - (int)msg.Transferred;
if (n > max)
{
n = max;
}
msg.PreviewData.Write(bytes, 0, bytes.Length);
}
msg.EndTime = chunk.EndTime;
msg.Transferred += chunkSize;
}
else
{
TransactionNode bodyNode = node.FindChild("Payload");
if (bodyNode != null && bodyNode.Fields.ContainsKey("MSNSLP"))
{
MSNSLPMessage msg = new MSNSLPMessage(bodyNode.Index,
bodyNode.GetSlicesForFieldPath("MSNSLP")[0].Packet.Direction,
bodyNode.StartTime, (string)bodyNode["MSNSLP"]);
messages.Add(msg);
}
}
}
}
return(messages.ToArray());
}
public FragDatInfo(PacketDirection packetDirection, int referenceIndex, byte[] data)
{
PacketDirection = packetDirection;
ReferenceIndex = referenceIndex;
Data = data;
}
public MSNSessionMessage(int index, PacketDirection direction, DateTime startTime)
: base(index, direction, startTime)
{
}
public void ExploreZoneEntry(StreamWriter OutputStream, ByteStream Buffer, PacketDirection Direction)
{
if (Direction != PacketDirection.ServerToClient)
{
return;
}
string FirstName = Buffer.ReadString(false);
OutputStream.WriteLine("Name = {0}", FirstName);
UInt32 SpawnID = Buffer.ReadUInt32();
OutputStream.WriteLine("SpawnID = {0}", SpawnID);
byte Level = Buffer.ReadByte();
OutputStream.WriteLine("Level = {0}", Level);
Buffer.SkipBytes(4);
byte IsNPC = Buffer.ReadByte();
OutputStream.WriteLine("IsNPC = {0}", IsNPC);
UInt32 Bitfield = Buffer.ReadUInt32();
OutputStream.WriteLine("Name: {0}, Bitfield: {1}", FirstName, Convert.ToString(Bitfield, 2));
byte OtherData = Buffer.ReadByte();
OutputStream.WriteLine("OtherData = {0}", OtherData);
Buffer.SkipBytes(8);
if ((OtherData & 1) > 0)
{
OutputStream.WriteLine("OD: {0}", Buffer.ReadString(false));
OutputStream.WriteLine("OD: {0}", Buffer.ReadString(false));
OutputStream.WriteLine("OD: {0}", Buffer.ReadString(false));
Buffer.SkipBytes(53);
}
if ((OtherData & 4) > 0)
{
OutputStream.WriteLine("Aura: {0}", Buffer.ReadString(false));
OutputStream.WriteLine("Aura: {0}", Buffer.ReadString(false));
Buffer.SkipBytes(54);
}
byte Properties = Buffer.ReadByte();
OutputStream.WriteLine("Properties = {0}, Offset now {1}", Properties, Buffer.GetPosition());
UInt32 BodyType = 0;
if (Properties > 0)
{
BodyType = Buffer.ReadUInt32();
}
OutputStream.WriteLine("Bodytype = {0}", BodyType);
if (Properties != 1)
{
OutputStream.WriteLine("XXXX Properties is {0}", Properties);
}
for (int i = 1; i < Properties; ++i)
{
OutputStream.WriteLine(" Prop: {0}", Buffer.ReadUInt32());
}
OutputStream.WriteLine("Position is now {0}", Buffer.GetPosition());
byte HP = Buffer.ReadByte();
byte HairColor = Buffer.ReadByte();
byte BeardColor = Buffer.ReadByte();
byte Eye1 = Buffer.ReadByte();
byte Eye2 = Buffer.ReadByte();
byte HairStyle = Buffer.ReadByte();
byte BeardStyle = Buffer.ReadByte();
OutputStream.WriteLine("Beardstyle is {0}", BeardStyle);
Buffer.SkipBytes(12); // Drakkin stuff
byte EquipChest2 = Buffer.ReadByte();
Buffer.SkipBytes(2);
byte Helm = Buffer.ReadByte();
float Size = Buffer.ReadSingle();
byte Face = Buffer.ReadByte();
float WalkSpeed = Buffer.ReadSingle();
float RunSpeed = Buffer.ReadSingle();
UInt32 Race = Buffer.ReadUInt32();
OutputStream.WriteLine("Size: {0}, Face: {1}, Walkspeed: {2}, RunSpeed: {3}, Race: {4}", Size, Face, WalkSpeed, RunSpeed, Race);
Buffer.SkipBytes(18);
Buffer.ReadString(false);
Buffer.SkipBytes(35);
if ((IsNPC == 0) || NPCType.IsPlayableRace(Race))
{
for (int ColourSlot = 0; ColourSlot < 9; ++ColourSlot)
{
OutputStream.WriteLine("Color {0} is {1}", ColourSlot, Buffer.ReadUInt32());
}
for (int i = 0; i < 9; ++i)
{
UInt32 Equip3 = Buffer.ReadUInt32();
UInt32 Equipx = Buffer.ReadUInt32();
UInt32 Equip2 = Buffer.ReadUInt32();
UInt32 Equip1 = Buffer.ReadUInt32();
UInt32 Equip0 = Buffer.ReadUInt32();
OutputStream.WriteLine("Equip slot {0}: 0,1,2,x,3 is {1}, {2}, {3}, {4}, {5}", i,
Equip0, Equip1, Equip2, Equipx, Equip3);
}
}
else
{
// Non playable race
// Melee Texture 1 is 20 bytes in
// Melee Texture 1 is 40 bytes in
// This whole segment is 28 + 24 + 8 = 60
// Skip 20, Read m1, skip 16, read m2, skip 16
/*
* OutputStream.WriteLine("None playable race, offset now {0}", Buffer.GetPosition());
* Buffer.SkipBytes(28);
*
* UInt32 MeleeTexture1 = Buffer.ReadUInt32();
* Buffer.SkipBytes(12);
* UInt32 MeleeTexture2 = Buffer.ReadUInt32();
* Buffer.SkipBytes(12);
*/
OutputStream.WriteLine("None playable race, offset now {0}", Buffer.GetPosition());
Buffer.SkipBytes(20);
UInt32 MeleeTexture1 = Buffer.ReadUInt32();
Buffer.SkipBytes(16);
UInt32 MeleeTexture2 = Buffer.ReadUInt32();
Buffer.SkipBytes(16);
}
OutputStream.WriteLine("Position starts at offset {0}", Buffer.GetPosition());
UInt32 Position1 = Buffer.ReadUInt32();
UInt32 Position2 = Buffer.ReadUInt32();
UInt32 Position3 = Buffer.ReadUInt32();
UInt32 Position4 = Buffer.ReadUInt32();
UInt32 Position5 = Buffer.ReadUInt32();
float YPos = Utils.EQ19ToFloat((Int32)((Position4 >> 13) & 0x7FFFF));
float ZPos = Utils.EQ19ToFloat((Int32)(Position5 >> 10) & 0x7FFFF);
float XPos = Utils.EQ19ToFloat((Int32)(Position2 >> 10) & 0x7FFFF);
//float Heading = Utils.EQ19ToFloat((Int32)(Position1 >> 13) & 0x3FF);
//float Heading = Utils.EQ19ToFloat((Int32)(Position2) & 0x3FF);
float Heading = Utils.EQ19ToFloat((Int32)(Position3) & 0x3FF);
//for(int i = 0; i < 32; ++i)
// OutputStream.WriteLine("Pos3 << {0} = {1}", i, Utils.EQ19ToFloat((Int32)(Position3 >> i) & 0x3FF));
OutputStream.WriteLine("(X,Y,Z) = {0}, {1}, {2}, Heading = {3}", XPos, YPos, ZPos, Heading);
if ((OtherData & 16) > 1)
{
OutputStream.WriteLine("Title: {0}", Buffer.ReadString(false));
}
if ((OtherData & 32) > 1)
{
OutputStream.WriteLine("Suffix: {0}", Buffer.ReadString(false));
}
Buffer.SkipBytes(8);
byte IsMerc = Buffer.ReadByte();
OutputStream.WriteLine("IsMerc: {0}", IsMerc);
Buffer.SkipBytes(54);
OutputStream.WriteLine("Buffer Length: {0}, Current Position: {1}", Buffer.Length(), Buffer.GetPosition());
if (Buffer.Length() != Buffer.GetPosition())
{
OutputStream.WriteLine("PARSE ERROR");
}
OutputStream.WriteLine("");
}
public EQApplicationPacket(System.Net.IPAddress srcIp, System.Net.IPAddress dstIp, ushort srcPort, ushort dstPort, int OpCode, int BufferSize, byte[] Source, int Offset, PacketDirection Direction, DateTime PacketTime)
{
this.OpCode = OpCode;
this.Direction = Direction;
this.PacketTime = PacketTime;
if (BufferSize < 0)
{
//Log("OPCode " + OpCode.ToString("x") + ", Buffer Size " + BufferSize + " Buffer Size < 0 !");
return;
}
Buffer = new byte[BufferSize];
Array.Copy(Source, Offset, Buffer, 0, BufferSize);
}
public void ProcessAppPacket(System.Net.IPAddress srcIp, System.Net.IPAddress dstIp, ushort srcPort, ushort dstPort, int InOpCode, int BufferSize, byte[] Source, int Offset, PacketDirection Direction, DateTime PacketTime)
{
EQApplicationPacket app = new EQApplicationPacket(srcIp, dstIp, srcPort, dstPort, InOpCode, BufferSize, Source, Offset, Direction, PacketTime);
if (!Identified)
{
IdentificationStatus TempStatus = Identifier(InOpCode, BufferSize, Direction);
if (!PermaLocked && (TempStatus > IdentificationStatus.No))
{
Log("-- Permalocking to this stream.");
PermaLocked = true;
}
Identified = (TempStatus == IdentificationStatus.Yes);
}
AddPacket(app);
}
public virtual void ExploreCastSpell(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
throw new NotImplementedException();
}
public static string LogPacket(IPacket packet, PacketDirection direction)
{
var memory = new MemoryStream();
var stream = new StreamWriter(memory);
var type = packet.GetType();
var fields = type.GetFields();
// Log time, direction, name
stream.Write(DateTime.Now.ToString("{hh:mm:ss.fff} "));
if (direction == PacketDirection.Serverbound)
{
stream.Write("[CLIENT->SERVER] ");
}
else
{
stream.Write("[SERVER->CLIENT] ");
}
stream.Write(FormatPacketName(type.Name));
stream.WriteLine();
// Log fields
foreach (var field in fields)
{
var name = field.Name;
if (field.Name == "PacketId")
{
continue;
}
name = AddSpaces(name);
var fValue = field.GetValue(packet);
if (!(fValue is Array))
{
stream.Write(string.Format(" {0} ({1})", name, field.FieldType.Name));
}
else
{
var array = fValue as Array;
stream.Write(string.Format(" {0} ({1}[{2}])", name,
array.GetType().GetElementType().Name, array.Length));
}
if (fValue is byte[])
{
stream.Write(": " + DumpArray(fValue as byte[]) + "\n");
}
else if (fValue is Array)
{
stream.Write(": ");
var array = fValue as Array;
foreach (var item in array)
{
stream.Write(string.Format("{0}, ", item.ToString()));
}
stream.WriteLine();
}
else if (fValue is string)
{
stream.Write(": \"" + fValue + "\"\n");
}
else
{
stream.Write(": " + fValue + "\n");
}
}
stream.WriteLine();
stream.Flush();
return(Encoding.UTF8.GetString(memory.GetBuffer().Take((int)memory.Length).ToArray()));
}
private void TryParseAriesFrame(IoBuffer buffer, PacketDirection direction)
{
buffer.Rewind();
if (buffer.Remaining < 12)
{
return;
}
buffer.Order = ByteOrder.LittleEndian;
uint packetType = buffer.GetUInt32();
uint timestamp = buffer.GetUInt32();
uint payloadSize = buffer.GetUInt32();
if (buffer.Remaining < payloadSize)
{
buffer.Skip(-12);
return;
}
while (payloadSize > 0)
{
if (packetType == 0)
{
/** Voltron packet **/
buffer.Order = ByteOrder.BigEndian;
ushort voltronType = buffer.GetUInt16();
uint voltronPayloadSize = buffer.GetUInt32() - 6;
byte[] data = new byte[(int)voltronPayloadSize];
buffer.Get(data, 0, (int)voltronPayloadSize);
PacketLogger.OnPacket(new Packet
{
Data = data,
Type = PacketType.VOLTRON,
SubType = voltronType,
Direction = direction
});
payloadSize -= voltronPayloadSize + 6;
}
else
{
byte[] data = new byte[(int)payloadSize];
buffer.Get(data, 0, (int)payloadSize);
PacketLogger.OnPacket(new Packet
{
Data = data,
Type = PacketType.ARIES,
SubType = packetType,
Direction = direction
});
payloadSize = 0;
}
}
buffer.Rewind();
}
public PacketHandlerAttribute(PacketHeader methodId, string name, int size = VariableSize, PacketDirection direction = PacketDirection.In)
{
this.MethodId = (ushort)methodId;
this.Name = name;
this.Size = size;
this.Direction = direction;
}
//See SpawnShell.cpp int32_t SpawnShell::fillSpawnStruct(spawnStruct *spawn, const uint8_t *data, size_t len, bool checkLen)?
public override void ExploreZoneEntry(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
if (direction != PacketDirection.ServerToClient)
{
return;
}
try
{
string FirstName = buffer.ReadString(false);
outputStream.WriteLine("Name = {0}", FirstName);
UInt32 SpawnID = buffer.ReadUInt32();
outputStream.WriteLine("SpawnID = {0}", SpawnID);
byte Level = buffer.ReadByte();
outputStream.WriteLine("Level = {0}", Level);
buffer.SkipBytes(4);
byte IsNPC = buffer.ReadByte();
outputStream.WriteLine("IsNPC = {0}", IsNPC);
UInt32 Bitfield = buffer.ReadUInt32();
outputStream.WriteLine("Name: {0}, Bitfield: {1}", FirstName, Convert.ToString(Bitfield, 2));
byte OtherData = buffer.ReadByte();
outputStream.WriteLine("OtherData = {0}", OtherData);
buffer.SkipBytes(8);
if ((OtherData & 1) > 0)
{
outputStream.WriteLine("OD: {0}", buffer.ReadString(false));
outputStream.WriteLine("OD: {0}", buffer.ReadString(false));
outputStream.WriteLine("OD: {0}", buffer.ReadString(false));
buffer.SkipBytes(53);
}
if ((OtherData & 4) > 0)
{
outputStream.WriteLine("Aura: {0}", buffer.ReadString(false));
outputStream.WriteLine("Aura: {0}", buffer.ReadString(false));
buffer.SkipBytes(54);
}
byte Properties = buffer.ReadByte();
outputStream.WriteLine("Properties = {0}, Offset now {1}", Properties, buffer.GetPosition());
UInt32 BodyType = 0;
if (Properties > 0)
{
BodyType = buffer.ReadUInt32();
}
outputStream.WriteLine("Bodytype = {0}", BodyType);
if (Properties != 1)
{
outputStream.WriteLine("XXXX Properties is {0}", Properties);
}
for (int i = 1; i < Properties; ++i)
{
outputStream.WriteLine(" Prop: {0}", buffer.ReadUInt32());
}
outputStream.WriteLine("Position is now {0}", buffer.GetPosition());
byte HP = buffer.ReadByte();
byte HairColor = buffer.ReadByte();
byte BeardColor = buffer.ReadByte();
byte Eye1 = buffer.ReadByte();
byte Eye2 = buffer.ReadByte();
byte HairStyle = buffer.ReadByte();
byte BeardStyle = buffer.ReadByte();
outputStream.WriteLine("Beardstyle is {0}", BeardStyle);
buffer.SkipBytes(12); // Drakkin stuff
byte EquipChest2 = buffer.ReadByte();
buffer.SkipBytes(2);
byte Helm = buffer.ReadByte();
float Size = buffer.ReadSingle();
byte Face = buffer.ReadByte();
float WalkSpeed = buffer.ReadSingle();
float RunSpeed = buffer.ReadSingle();
UInt32 Race = buffer.ReadUInt32();
outputStream.WriteLine("Size: {0}, Face: {1}, Walkspeed: {2}, RunSpeed: {3}, Race: {4}", Size, Face,
WalkSpeed, RunSpeed, Race);
//MooftaL above here is correct, below is incorrect time to get from seq...
outputStream.WriteLine("Holding = {0}", buffer.ReadByte());
outputStream.WriteLine("Deity = {0}", buffer.ReadUInt32());
outputStream.WriteLine("GuildID = {0}", buffer.ReadUInt32());
outputStream.WriteLine("Guildstatus = {0}", buffer.ReadUInt32());
outputStream.WriteLine("Classs? = {0}", buffer.ReadUInt32());
buffer.SkipBytes(1);
outputStream.WriteLine("State = {0}", buffer.ReadByte());
outputStream.WriteLine("Light = {0}", buffer.ReadByte());
buffer.SkipBytes(1);
outputStream.WriteLine("LastName = {0}", buffer.ReadString(false));
buffer.SkipBytes(6);
outputStream.WriteLine("PetOwnerId = {0}", buffer.ReadUInt32());
if (IsNPC == 1)
{
buffer.SkipBytes(37);
}
else
{
buffer.SkipBytes(25);
}
if (IsNPC == 0 || NPCType.IsPlayableRace(Race))
{
//for (int ColourSlot = 0; ColourSlot < 9; ++ColourSlot)
// outputStream.WriteLine("Color {0} is {1}", ColourSlot, buffer.ReadUInt32());
buffer.SkipBytes(36);
for (int i = 0; i < 9; ++i)
{
UInt32 Equip3 = buffer.ReadUInt32();
UInt32 Equipx = buffer.ReadUInt32();
UInt32 Equip2 = buffer.ReadUInt32();
UInt32 Equip1 = buffer.ReadUInt32();
UInt32 Equip0 = buffer.ReadUInt32();
outputStream.WriteLine("Equip slot {0}: 0,1,2,x,3 is {1}, {2}, {3}, {4}, {5}", i,
Equip0, Equip1, Equip2, Equipx, Equip3);
}
}
else
{
//Moofta at this point this section is 100% untested
// Non playable race
// Melee Texture 1 is 20 bytes in
// Melee Texture 1 is 40 bytes in
// This whole segment is 28 + 24 + 8 = 60
// Skip 20, Read m1, skip 16, read m2, skip 16
/*
* OutputStream.WriteLine("None playable race, offset now {0}", Buffer.GetPosition());
* Buffer.SkipBytes(28);
*
* UInt32 MeleeTexture1 = Buffer.ReadUInt32();
* Buffer.SkipBytes(12);
* UInt32 MeleeTexture2 = Buffer.ReadUInt32();
* Buffer.SkipBytes(12);
*/
outputStream.WriteLine("None playable race, offset now {0}", buffer.GetPosition());
buffer.SkipBytes(20);
UInt32 MeleeTexture1 = buffer.ReadUInt32();
buffer.SkipBytes(16);
UInt32 MeleeTexture2 = buffer.ReadUInt32();
buffer.SkipBytes(16);
}
outputStream.WriteLine("Position starts at offset {0}", buffer.GetPosition());
/*
*
* union
* {
* struct
* {
* unsigned pitch:12;
* signed deltaX:13; // change in x
* unsigned padding01:7;
* signed z:19; // z coord (3rd loc value)
* signed deltaHeading:10; // change in heading
* unsigned padding02:3;
* signed x:19; // x coord (1st loc value)
* signed deltaZ:13; // change in z
* unsigned heading:12; // heading
* signed deltaY:13; // change in y
* unsigned padding03:7;
* signed animation:10; // velocity
* signed y:19; // y coord (2nd loc value)
* unsigned padding04:3;
* };
* int32_t posData[5];
* };*/
UInt32 Position1 = buffer.ReadUInt32();
outputStream.WriteLine("Position1 untreated {0}", Position1);
UInt32 Position2 = buffer.ReadUInt32();
outputStream.WriteLine("Position2 untreated {0}", Position2);
UInt32 Position3 = buffer.ReadUInt32();
outputStream.WriteLine("Position3 untreated {0}", Position3); //verified as X position
UInt32 Position4 = buffer.ReadUInt32();
outputStream.WriteLine("Position4 untreated {0}", Position4);
UInt32 Position5 = buffer.ReadUInt32(); //verified as Y position
float XPos = Utils.EQ19ToFloat((Int32)(Position3) & 0x7FFFF); //Verified
float YPos = Utils.EQ19ToFloat((Int32)(Position5 >> 10) & 0x7FFFF); //Verified
float ZPos = Utils.EQ19ToFloat((Int32)((Position2) & 0x7FFFF)); //thanks Demonstar55
//heading is definitely NOT Position3
float Heading = Utils.EQ19ToFloat((Int32)(Position4) & 0xFFF); //can't verify
//for(var i = 0; i < 32; ++i)
// OutputStream.WriteLine("Pos3 << {0} = {1}", i, Utils.EQ19ToFloat((Int32)(Position3 >> i) & 0x3FF));
outputStream.WriteLine("(X,Y,Z) = {0}, {1}, {2}, Heading = {3}", XPos, YPos, ZPos, Heading);
if ((OtherData & 16) > 1)
{
outputStream.WriteLine("Title: {0}", buffer.ReadString(false));
}
if ((OtherData & 32) > 1)
{
outputStream.WriteLine("Suffix: {0}", buffer.ReadString(false));
}
buffer.SkipBytes(8);
byte IsMerc = buffer.ReadByte();
outputStream.WriteLine("IsMerc: {0}", IsMerc);
buffer.SkipBytes(54);
outputStream.WriteLine("Buffer Length: {0}, Current Position: {1}", buffer.Length(),
buffer.GetPosition());
if (buffer.Length() != buffer.GetPosition())
{
outputStream.WriteLine("PARSE ERROR");
}
outputStream.WriteLine("");
}
catch (Exception)
{
}
}
public virtual void ExploreMercenaryDataResponse(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
throw new NotImplementedException();
}
public MSNSLPMessage(int index, PacketDirection direction, DateTime startTime, string slpData)
: base(index, direction, startTime)
{
BodyText = slpData;
}
public virtual void ExploreOpenNewTasksWindow(StreamWriter outputStream, ByteStream buffer, PacketDirection direction)
{
throw new NotImplementedException();
}
public uint GetIssacValue(PacketDirection direction)
{
return(direction == PacketDirection.Client ? Network.ConnectionData.IssacClient.GetOffset() : Network.ConnectionData.IssacServer.GetOffset());
}
