public static void registerHandler(Opcodes opcode, NetworkMessageCallback cb)
{
Handler handler = new Handler();
handler.callback = cb;
_handlers[opcode] = handler;
}
public OperatorToken(string name, int precedence, Opcodes correspondingOpcode, RequiredState hasLeftHandSide)
: base(name, true)
{
_precedence = precedence;
_correspondingOpcode = correspondingOpcode;
_hasLeftHandSide = hasLeftHandSide;
}
public IncomingMessageAttribute(Opcodes[] opcodes)
{
this.Opcodes = new List<Opcodes>();
foreach(var opcode in opcodes)
{
this.Opcodes.Add(opcode);
}
}
public PacketWriter(Opcodes opcode)
: base()
{
Header = new ClientHeader(opcode, this);
memoryStream = new MemoryStream();
base.OutStream = memoryStream;
}
public MessageAttribute(Opcodes[] opcodes, Consumers consumer = Consumers.None)
{
this.Opcodes = new List<Opcodes>();
this.Consumer = consumer;
foreach (var opcode in opcodes)
{
this.Opcodes.Add(opcode);
}
}
public static bool InvokeHandler(PacketReader reader, WorldManager manager, Opcodes opcode)
{
if (OpcodeHandlers.ContainsKey(opcode))
{
OpcodeHandlers[opcode].Invoke(ref reader, ref manager);
return true;
}
else
return false;
}
public Frame(Opcodes opcode, byte[] payload, bool isFin)
{
this.isFin = isFin;
this.opcode = opcode;
this.unmaskedPayload = payload;
if (this.unmaskedPayload != null)
this.payloadLength = (ulong)this.unmaskedPayload.Length;
// Server frames are never masked
this.isMasked = false;
}
public Frame(Opcodes opcode, byte[] payload, bool isFin)
{
IsFin = isFin;
Opcode = opcode;
UnmaskedPayload = payload;
if (UnmaskedPayload != null)
PayloadLength = (ulong)UnmaskedPayload.Length;
// Server frames are never masked
IsMasked = false;
}
protected LogEntry(int eventId, Keywords keyword, Opcodes opcode, Tasks task, Levels level, EventSource eventSource, int version, string message, Payload payload, DateTime created)
{
Id = Guid.NewGuid();
EventId = eventId;
Keyword = keyword;
Opcode = opcode;
Task = task;
Level = level;
EventSource = eventSource;
Version = version;
Message = message;
Payload = payload;
Created = created;
}
protected void WritePacketHeader(Opcodes opcode, bool isWorldPacket = true)
{
// Packet header (0.5.3.3368): Size: 2 bytes + Cmd: 2 bytes
// Packet header after SMSG_AUTH_CHALLENGE (0.5.3.3368): Size: 2 bytes + Cmd: 4 bytes
WriteUInt8(0);
WriteUInt8(0);
WriteUInt8((byte)((uint)opcode % 0x100));
WriteUInt8((byte)((uint)opcode / 0x100));
if (isWorldPacket)
{
WriteUInt8(0);
WriteUInt8(0);
}
}
public TransportLayer(ServersManager<Connection> serversManager1, Opcodes? websocketResponseFrame)
{
ChangeSettings(websocketResponseFrame);
serversManager = serversManager1;
serversManager.ServerAdded += ServersManager_ServerAdded;
serversManager.ServerRemoved += ServersManager_ServerRemoved;
serversManager.ServerInfo += ServersManager_ServerInfo;
serversManager.NewConnection += ServersManager_NewConnection;
serversManager.EndConnection += ServersManager_EndConnection;
serversManager.Received += ServersManager_Received;
serversManager.Sent += ServersManager_Sent;
serversManager.BeforeSend += ServersManager_BeforeSend;
ajax = new AjaxWebsocket();
ajax.SendAsync = SendAsyncAjax;
}
protected ErrorLogEntry(Guid id, Guid accountId, int eventId, Keywords keyword, Opcodes opcode, Tasks task, Levels level,
EventSource eventSource, int version, string message, string exceptionType, string exceptionMessage, string stackTrace, Payload payload, DateTime created)
{
Id = id;
AccountId = accountId;
EventId = eventId;
Keyword = keyword;
Opcode = opcode;
Task = task;
Level = level;
EventSource = eventSource;
Version = version;
Message = message;
ExceptionType = exceptionType;
ExceptionMessage = exceptionMessage;
StackTrace = stackTrace;
Payload = payload;
Created = created;
}
public OpRec(Opcodes opcode, string fmt)
{
this.opcode = opcode;
this.fmt = fmt;
}
public Packets.PacketClass BuildPartyMemberStats(ref WS_PlayerData.CharacterObject objCharacter, uint flag)
{
Opcodes opCode = Opcodes.SMSG_PARTY_MEMBER_STATS;
if (flag == 1015 || flag == 524279)
{
opCode = Opcodes.SMSG_PARTY_MEMBER_STATS_FULL;
if (objCharacter.ManaType != 0)
{
flag |= 8u;
}
}
Packets.PacketClass packet = new Packets.PacketClass(opCode);
packet.AddPackGUID(objCharacter.GUID);
packet.AddUInt32(flag);
if ((flag & (true ? 1u : 0u)) != 0)
{
byte memberFlags = 1;
if (objCharacter.isPvP)
{
memberFlags = (byte)(memberFlags | 2);
}
if (objCharacter.DEAD)
{
memberFlags = (byte)(memberFlags | 0x10);
}
packet.AddInt8(memberFlags);
}
checked
{
if ((flag & 2u) != 0)
{
packet.AddUInt16((ushort)objCharacter.Life.Current);
}
if ((flag & 4u) != 0)
{
packet.AddUInt16((ushort)objCharacter.Life.Maximum);
}
if ((flag & 8u) != 0)
{
packet.AddInt8((byte)objCharacter.ManaType);
}
if ((flag & 0x10u) != 0)
{
if (objCharacter.ManaType == ManaTypes.TYPE_RAGE)
{
packet.AddUInt16((ushort)objCharacter.Rage.Current);
}
else if (objCharacter.ManaType == ManaTypes.TYPE_ENERGY)
{
packet.AddUInt16((ushort)objCharacter.Energy.Current);
}
else
{
packet.AddUInt16((ushort)objCharacter.Mana.Current);
}
}
if ((flag & 0x20u) != 0)
{
if (objCharacter.ManaType == ManaTypes.TYPE_RAGE)
{
packet.AddUInt16((ushort)objCharacter.Rage.Maximum);
}
else if (objCharacter.ManaType == ManaTypes.TYPE_ENERGY)
{
packet.AddUInt16((ushort)objCharacter.Energy.Maximum);
}
else
{
packet.AddUInt16((ushort)objCharacter.Mana.Maximum);
}
}
if ((flag & 0x40u) != 0)
{
packet.AddUInt16(objCharacter.Level);
}
if ((flag & 0x80u) != 0)
{
packet.AddUInt16((ushort)objCharacter.ZoneID);
}
if ((flag & 0x100u) != 0)
{
packet.AddInt16((short)objCharacter.positionX);
packet.AddInt16((short)objCharacter.positionY);
}
if ((flag & 0x200u) != 0)
{
ulong auraMask2 = 0uL;
int auraPos2 = packet.Data.Length;
packet.AddUInt64(0uL);
int num = WorldServiceLocator._Global_Constants.MAX_AURA_EFFECTs_VISIBLE - 1;
for (int j = 0; j <= num; j++)
{
if (objCharacter.ActiveSpells[j] != null)
{
unchecked
{
auraMask2 |= (ulong)(1L << checked ((int)(ulong)j));
}
packet.AddUInt16((ushort)objCharacter.ActiveSpells[j].SpellID);
packet.AddInt8(1);
}
}
packet.AddUInt64(auraMask2, auraPos2);
}
if ((flag & 0x400u) != 0)
{
if (objCharacter.Pet != null)
{
packet.AddUInt64(objCharacter.Pet.GUID);
}
else
{
packet.AddInt64(0L);
}
}
if ((flag & 0x800u) != 0)
{
if (objCharacter.Pet != null)
{
packet.AddString(objCharacter.Pet.PetName);
}
else
{
packet.AddString("");
}
}
if ((flag & 0x1000u) != 0)
{
if (objCharacter.Pet != null)
{
packet.AddUInt16((ushort)objCharacter.Pet.Model);
}
else
{
packet.AddInt16(0);
}
}
if ((flag & 0x2000u) != 0)
{
if (objCharacter.Pet != null)
{
packet.AddUInt16((ushort)objCharacter.Pet.Life.Current);
}
else
{
packet.AddInt16(0);
}
}
if ((flag & 0x4000u) != 0)
{
if (objCharacter.Pet != null)
{
packet.AddUInt16((ushort)objCharacter.Pet.Life.Maximum);
}
else
{
packet.AddInt16(0);
}
}
if ((flag & 0x8000u) != 0)
{
if (objCharacter.Pet != null)
{
packet.AddInt8(2);
}
else
{
packet.AddInt8(0);
}
}
if ((flag & 0x10000u) != 0)
{
if (objCharacter.Pet != null)
{
packet.AddUInt16((ushort)objCharacter.Pet.Mana.Current);
}
else
{
packet.AddInt16(0);
}
}
if ((flag & 0x20000u) != 0)
{
if (objCharacter.Pet != null)
{
packet.AddUInt16((ushort)objCharacter.Pet.Mana.Maximum);
}
else
{
packet.AddInt16(0);
}
}
if ((flag & 0x40000u) != 0)
{
if (objCharacter.Pet != null)
{
ulong auraMask = 0uL;
int auraPos = packet.Data.Length;
packet.AddUInt64(0uL);
int num2 = WorldServiceLocator._Global_Constants.MAX_AURA_EFFECTs_VISIBLE - 1;
for (int i = 0; i <= num2; i++)
{
if (objCharacter.Pet.ActiveSpells[i] != null)
{
unchecked
{
auraMask |= (ulong)(1L << checked ((int)(ulong)i));
}
packet.AddUInt16((ushort)objCharacter.Pet.ActiveSpells[i].SpellID);
packet.AddInt8(1);
}
}
packet.AddUInt64(auraMask, auraPos);
}
else
{
packet.AddInt64(0L);
}
}
return(packet);
}
}
private void ProcessFileImpl()
{
if (_compression != FileCompression.None)
{
_tempName = Decompress();
}
switch (_dumpFormat)
{
case DumpFormatType.StatisticsPreParse:
{
var packets = ReadPackets();
if (packets.Count == 0)
{
break;
}
var firstPacket = packets.First();
var lastPacket = packets.Last();
// CSV format
// ReSharper disable once UseStringInterpolation
Trace.WriteLine(string.Format("{0};{1};{2};{3};{4};{5};{6};{7};{8}",
FileName, // - sniff file name
firstPacket.Time, // - time of first packet
lastPacket.Time, // - time of last packet
(lastPacket.Time - firstPacket.Time).TotalSeconds, // - sniff duration (seconds)
packets.Count, // - packet count
packets.AsParallel().Sum(packet => packet.Length), // - total packets size (bytes)
packets.AsParallel().Average(packet => packet.Length), // - average packet size (bytes)
packets.AsParallel().Min(packet => packet.Length), // - smaller packet size (bytes)
packets.AsParallel().Max(packet => packet.Length))); // - larger packet size (bytes)
break;
}
case DumpFormatType.SniffDataOnly:
case DumpFormatType.SqlOnly:
case DumpFormatType.Text:
case DumpFormatType.HexOnly:
{
var outFileName = Path.ChangeExtension(FileName, null) + "_parsed.txt";
if (Utilities.FileIsInUse(outFileName) && Settings.DumpFormat != DumpFormatType.SqlOnly)
{
// If our dump format requires a .txt to be created,
// check if we can write to that .txt before starting parsing
Trace.WriteLine($"Save file {outFileName} is in use, parsing will not be done.");
break;
}
Store.Store.SQLEnabledFlags = Settings.SQLOutputFlag;
File.Delete(outFileName);
_stats.SetStartTime(DateTime.Now);
var threadCount = Settings.Threads;
if (threadCount == 0)
{
threadCount = Environment.ProcessorCount;
}
ThreadPool.SetMinThreads(threadCount + 2, 4);
var written = false;
using (var writer = (Settings.DumpFormatWithText() ? new StreamWriter(outFileName, true) : null))
{
var firstRead = true;
var firstWrite = true;
var reader = _compression != FileCompression.None ? new Reader(_tempName, _sniffType) : new Reader(FileName, _sniffType);
var pwp = new ParallelWorkProcessor <Packet>(() => // read
{
if (!reader.PacketReader.CanRead())
{
return(Tuple.Create <Packet, bool>(null, true));
}
Packet packet;
var b = reader.TryRead(out packet);
if (firstRead)
{
Trace.WriteLine(
$"{_logPrefix}: Parsing {Utilities.BytesToString(reader.PacketReader.GetTotalSize())} of packets. Detected version {ClientVersion.VersionString}");
firstRead = false;
}
return(Tuple.Create(packet, b));
}, packet => // parse
{
// Parse the packet, adding text to Writer and stuff to the stores
if (packet.Direction == Direction.BNClientToServer ||
packet.Direction == Direction.BNServerToClient)
{
BattlenetHandler.ParseBattlenet(packet);
}
else
{
Handler.Parse(packet);
}
// Update statistics
_stats.AddByStatus(packet.Status);
return(packet);
},
packet => // write
{
ShowPercentProgress("Processing...", reader.PacketReader.GetCurrentSize(), reader.PacketReader.GetTotalSize());
if (!packet.Status.HasAnyFlag(Settings.OutputFlag) || !packet.WriteToFile)
{
packet.ClosePacket();
return;
}
written = true;
if (firstWrite)
{
// ReSharper disable AccessToDisposedClosure
writer?.WriteLine(GetHeader(FileName));
// ReSharper restore AccessToDisposedClosure
firstWrite = false;
}
// get packet header if necessary
if (Settings.LogPacketErrors)
{
switch (packet.Status)
{
case ParsedStatus.WithErrors:
_withErrorHeaders.Add(packet.GetHeader());
break;
case ParsedStatus.NotParsed:
_skippedHeaders.Add(packet.GetHeader());
break;
case ParsedStatus.NoStructure:
_noStructureHeaders.Add(packet.GetHeader());
break;
}
}
// ReSharper disable AccessToDisposedClosure
if (writer != null)
{
// Write to file
writer.WriteLine(packet.Writer);
writer.Flush();
}
// ReSharper restore AccessToDisposedClosure
// Close Writer, Stream - Dispose
packet.ClosePacket();
}, threadCount);
pwp.WaitForFinished(Timeout.Infinite);
reader.PacketReader.Dispose();
_stats.SetEndTime(DateTime.Now);
}
if (written)
{
Trace.WriteLine($"{_logPrefix}: Saved file to '{outFileName}'");
}
else
{
Trace.WriteLine($"{_logPrefix}: No file produced");
File.Delete(outFileName);
}
Trace.WriteLine($"{_logPrefix}: {_stats}");
if (Settings.SQLOutputFlag != 0 || HotfixSettings.Instance.ShouldLog())
{
WriteSQLs();
}
if (Settings.LogPacketErrors)
{
WritePacketErrors();
}
GC.Collect(); // Force a GC collect after parsing a file. It seems to help.
break;
}
case DumpFormatType.Pkt:
{
var packets = ReadPackets();
if (packets.Count == 0)
{
break;
}
if (Settings.FilterPacketsNum < 0)
{
var packetsPerSplit = Math.Abs(Settings.FilterPacketsNum);
var totalPackets = packets.Count;
var numberOfSplits = (int)Math.Ceiling((double)totalPackets / packetsPerSplit);
for (var i = 0; i < numberOfSplits; ++i)
{
var fileNamePart = FileName + "_part_" + (i + 1) + ".pkt";
var packetsPart = packets.Take(packetsPerSplit).ToList();
packets.RemoveRange(0, packetsPart.Count);
BinaryDump(fileNamePart, packetsPart);
}
}
else
{
var fileNameExcerpt = Path.ChangeExtension(FileName, null) + "_excerpt.pkt";
BinaryDump(fileNameExcerpt, packets);
}
break;
}
case DumpFormatType.PktSplit:
{
var packets = ReadPackets();
if (packets.Count == 0)
{
break;
}
SplitBinaryDump(packets);
break;
}
case DumpFormatType.PktDirectionSplit:
{
var packets = ReadPackets();
if (packets.Count == 0)
{
break;
}
DirectionSplitBinaryDump(packets);
break;
}
case DumpFormatType.PktSessionSplit:
{
var packets = ReadPackets();
if (packets.Count == 0)
{
break;
}
SessionSplitBinaryDump(packets);
break;
}
case DumpFormatType.CompressSniff:
{
if (_compression != FileCompression.None)
{
Trace.WriteLine($"Skipped compressing file {FileName}");
break;
}
Compress();
break;
}
case DumpFormatType.SniffVersionSplit:
{
var reader = _compression != FileCompression.None ? new Reader(_tempName, _sniffType) : new Reader(FileName, _sniffType);
if (ClientVersion.IsUndefined() && reader.PacketReader.CanRead())
{
Packet packet;
reader.TryRead(out packet);
packet.ClosePacket();
}
reader.PacketReader.Dispose();
var version = ClientVersion.IsUndefined() ? "unknown" : ClientVersion.VersionString;
var realFileName = GetCompressedFileName();
var destPath = Path.Combine(Path.GetDirectoryName(realFileName), version,
Path.GetFileName(realFileName));
var destDir = Path.GetDirectoryName(destPath);
if (!Directory.Exists(destDir))
{
Directory.CreateDirectory(destDir);
}
File.Move(realFileName, destPath);
Trace.WriteLine("Moved " + realFileName + " to " + destPath);
break;
}
case DumpFormatType.ConnectionIndexes:
{
var packets = ReadPackets();
if (packets.Count == 0)
{
break;
}
using (var writer = new StreamWriter(Path.ChangeExtension(FileName, null) + "_connidx.txt"))
{
if (ClientVersion.Build <= ClientVersionBuild.V6_0_3_19342)
{
writer.WriteLine("# Warning: versions before 6.1 might not have proper ConnectionIndex values.");
}
IEnumerable <IGrouping <Tuple <int, Direction>, Packet> > groupsOpcode = packets
.GroupBy(packet => Tuple.Create(packet.Opcode, packet.Direction))
.OrderBy(grouping => grouping.Key.Item2);
foreach (var groupOpcode in groupsOpcode)
{
var groups = groupOpcode
.GroupBy(packet => packet.ConnectionIndex)
.OrderBy(grouping => grouping.Key)
.ToList();
writer.Write("{0} {1,-50}: ", groupOpcode.Key.Item2, Opcodes.GetOpcodeName(groupOpcode.Key.Item1, groupOpcode.Key.Item2));
for (var i = 0; i < groups.Count; i++)
{
var idx = groups[i].Key;
writer.Write("{0} ({1}{2})", idx, (idx & 1) != 0 ? "INSTANCE" : "REALM", (idx & 2) != 0 ? "_NEW" : "");
if (i != groups.Count - 1)
{
writer.Write(", ");
}
}
writer.WriteLine();
}
}
break;
}
case DumpFormatType.Fusion:
{
var packets = ReadPackets();
if (packets.Count == 0)
{
break;
}
FusionDump(packets);
break;
}
default:
{
Trace.WriteLine($"{_logPrefix}: Dump format is none, nothing will be processed.");
break;
}
}
}
void Emit(Opcodes opcode, params object[] args)
{
_gcode.Add(opcode);
_gcode.AddRange(args);
}
public static void ReadQueryHeader(ref Packet packet)
{
var entry = packet.ReadInt32("Entry");
var guid = packet.ReadGuid("GUID");
if (packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_CREATURE_QUERY, Direction.ClientToServer) || packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_GAMEOBJECT_QUERY, Direction.ClientToServer))
{
if (guid.HasEntry() && (entry != guid.GetEntry()))
{
packet.AddValue("Error", "Entry does not match calculated GUID entry");
}
}
}
public static void HandleSpellStart(Packet packet)
{
bool isSpellGo = (packet.Opcode | 0x20000) == Opcodes.GetOpcode(Opcode.SMSG_SPELL_GO);
packet.ReadPackedGuid128("Caster Guid");
packet.ReadPackedGuid128("CasterUnit Guid");
packet.ReadByte("CastID");
packet.ReadUInt32("SpellID");
packet.ReadUInt32("CastFlags");
packet.ReadUInt32("CastTime");
var int52 = packet.ReadUInt32("HitTargets");
var int68 = packet.ReadUInt32("MissTargets");
var int84 = packet.ReadUInt32("MissStatus");
// SpellTargetData
packet.ResetBitReader();
packet.ReadEnum <TargetFlag>("Flags", 21);
var bit72 = packet.ReadBit("HasSrcLocation");
var bit112 = packet.ReadBit("HasDstLocation");
var bit124 = packet.ReadBit("HasOrientation");
var bits128 = packet.ReadBits(7);
packet.ReadPackedGuid128("Unit Guid");
packet.ReadPackedGuid128("Item Guid");
if (bit72)
{
packet.ReadPackedGuid128("SrcLocation Guid");
packet.ReadVector3("SrcLocation");
}
if (bit112)
{
packet.ReadPackedGuid128("DstLocation Guid");
packet.ReadVector3("DstLocation");
}
if (bit124)
{
packet.ReadSingle("Orientation");
}
packet.ReadWoWString("Name", bits128);
var int360 = packet.ReadUInt32("SpellPowerData");
// MissileTrajectoryResult
packet.ReadUInt32("TravelTime");
packet.ReadSingle("Pitch");
// SpellAmmo
packet.ReadUInt32("DisplayID");
packet.ReadByte("InventoryType");
packet.ReadByte("DestLocSpellCastIndex");
var int428 = packet.ReadUInt32("TargetPoints");
// CreatureImmunities
packet.ReadUInt32("School");
packet.ReadUInt32("Value");
// SpellHealPrediction
packet.ReadUInt32("Points");
packet.ReadByte("Type");
packet.ReadPackedGuid128("BeaconGUID");
// HitTargets
for (var i = 0; i < int52; ++i)
{
packet.ReadPackedGuid128("HitTarget Guid", i);
}
// MissTargets
for (var i = 0; i < int68; ++i)
{
packet.ReadPackedGuid128("MissTarget Guid", i);
}
// MissStatus
for (var i = 0; i < int84; ++i)
{
packet.ResetBitReader();
if (packet.ReadBits("Reason", 4, i) == 11)
{
packet.ReadBits("ReflectStatus", 4, i);
}
}
// SpellPowerData
for (var i = 0; i < int360; ++i)
{
packet.ReadInt32("Cost", i);
packet.ReadEnum <PowerType>("Type", TypeCode.Byte, i);
}
// TargetPoints
for (var i = 0; i < int428; ++i)
{
packet.ReadPackedGuid128("Transport Guid");
packet.ReadVector3("Location");
}
packet.ResetBitReader();
packet.ReadBits("CastFlagsEx", 18);
var bit396 = packet.ReadBit("HasRuneData");
var bit424 = packet.ReadBit("HasProjectileVisual");
// RuneData
if (bit396)
{
packet.ReadByte("Start");
packet.ReadByte("Count");
packet.ResetBitReader();
var bits1 = packet.ReadBits("CooldownCount", 3);
for (var i = 0; i < bits1; ++i)
{
packet.ReadByte("Cooldowns", i);
}
}
// ProjectileVisual
if (bit424)
{
for (var i = 0; i < 2; ++i)
{
packet.ReadInt32("Id", i);
}
}
if (isSpellGo)
{
packet.ResetBitReader();
var bit52 = packet.ReadBit("SpellCastLogData");
if (bit52)
{
ReadSpellCastLogData(ref packet);
}
}
}
public void Out(Opcodes opcode)
{
Logger.WriteLine(5, "{0,-4}: {1}", _mstream.Position, opcode);
_out.Write((byte)opcode);
}
public static bool InvokeHandler(IPacketReader reader, IWorldManager manager, Opcodes opcode)
{
if (OpcodeHandlers.ContainsKey(opcode))
{
OpcodeHandlers[opcode].Invoke(ref reader, ref manager);
return(true);
}
else
{
return(false);
}
}
public static void DefineOpcodeHandler(Opcodes opcode, HandlePacket handler)
{
OpcodeHandlers[opcode] = handler;
}
override public bool pkt_proc(byte[] buf)
{
byte[] data;
if (blkno == 0)
{
Opcodes op = (Opcodes)buf[1];
if (op == Opcodes.Read)
{
pkt_rrq pkt = new pkt_rrq();
if (!pkt.parse(buf))
{
return(false);
}
update_param(pkt.timeout * 1000 / Math.Max(idic["maxretry"], 1), pkt.blksize);
if (!File.Exists(sdic["cwd"] + pkt.filename))
{
pktbuf = new pkt_err(Errcodes.FileNotFound, pkt.filename).pack();
uc.Send(pktbuf, pktbuf.Length, r);
filename = pkt.filename; // set filename for log
return(false);
}
read_file(pkt.filename);
if (pkt.has_opt())
{
pkt.op = Opcodes.OAck;
pktbuf = pkt.pack(); // wait for ack blkno=0
}
else
{
data = q.consume(); //while ((data = q.consume()) == null) ; // may be infinite wait for a new msg here?
pktbuf = new pkt_data(++blkno, data).pack();
}
}
else // ack
{
pkt_ack pkt = new pkt_ack();
if (!pkt.parse(buf))
{
return(false);
}
if (pkt.blkno != (blkno & 0xffff))
{
return(true); // ignore expired ack?
}
data = q.consume(); //while ((data = q.consume()) == null) ; // may be infinite wait for a new msg here?
pktbuf = new pkt_data(++blkno, data).pack();
}
}
else
{
pkt_ack pkt = new pkt_ack();
if (!pkt.parse(buf))
{
return(false);
}
if (pkt.blkno != (blkno & 0xffff))
{
return(true); // ignore expired ack?
}
if (blkno == maxblkno && blkno > 0) // over
{
return(false);
}
if ((data = q.consume()) == null)
{
data = new byte[0]; // srv send last empty block; client write last block
}
pktbuf = new pkt_data(++blkno, data).pack();
}
curretry = 0; // reset retry cnt
return(uc.Send(pktbuf, pktbuf.Length, r) == pktbuf.Length);
}
private Pdp11Instruction NonDoubleOperandInstruction(ushort opcode)
{
switch ((opcode >> 8))
{
case 0x01:
case 0x02:
case 0x03:
case 0x04:
case 0x05:
case 0x06:
case 0x07:
case 0x80:
case 0x81:
case 0x82:
case 0x83:
case 0x84:
case 0x85:
case 0x86:
case 0x87:
return(BranchInstruction(opcode));
}
var dataWidth = DataWidthFromSizeBit(opcode & 0x8000u);
var op = DecodeOperand(opcode);
Opcodes oc = Opcodes.illegal;
switch ((opcode >> 6) & 0x3FF)
{
case 0x000:
switch (opcode & 0x3F)
{
case 0x00: op = null; oc = Opcodes.halt; break;
case 0x01: op = null; oc = Opcodes.wait; break;
case 0x02: op = null; oc = Opcodes.rti; break;
case 0x03: op = null; oc = Opcodes.bpt; break;
case 0x04: op = null; oc = Opcodes.iot; break;
case 0x05: op = null; oc = Opcodes.reset; break;
case 0x06: op = null; oc = Opcodes.rtt; break;
case 0x07: op = null; oc = Opcodes.illegal; break;
}
break;
case 0x001: oc = Opcodes.jmp; break;
case 0x002:
switch (opcode & 0x38)
{
case 0: op = DecodeOperand(opcode & 7); oc = Opcodes.rts; break;
case 3: op = Imm3(opcode); oc = Opcodes.spl; break;
case 4:
case 5:
case 6:
case 7:
throw new NotImplementedException("Cond codes");
}
break;
case 0x003:
oc = Opcodes.swab;
dataWidth = PrimitiveType.Byte;
break;
case 0x020:
case 0x021:
case 0x022:
case 0x023:
case 0x024:
case 0x025:
case 0x026:
case 0x027:
return(new Pdp11Instruction {
Opcode = Opcodes.jsr, op1 = Reg(opcode >> 6), op2 = op
});
case 0x220:
case 0x221:
case 0x222:
case 0x223:
oc = Opcodes.emt; op = null; break;
case 0x224:
case 0x225:
case 0x226:
case 0x227:
oc = Opcodes.trap; op = null; break;
case 0x028:
case 0x228:
oc = dataWidth.Size == 1 ? Opcodes.clrb : Opcodes.clr;
break;
case 0x029:
case 0x229:
oc = Opcodes.com;
break;
case 0x02A:
case 0x22A:
oc = Opcodes.inc;
break;
case 0x02B:
case 0x22B:
oc = Opcodes.dec;
break;
case 0x02C:
case 0x22C:
oc = Opcodes.neg;
break;
case 0x02D:
case 0x22D:
oc = Opcodes.adc;
break;
case 0x02E:
case 0x22E:
oc = Opcodes.sbc;
break;
case 0x02F:
case 0x22F:
oc = Opcodes.tst;
break;
case 0x030:
case 0x230:
oc = Opcodes.ror;
break;
case 0x031:
case 0x231:
oc = Opcodes.rol;
break;
case 0x032:
case 0x232:
oc = Opcodes.asr;
break;
case 0x033:
case 0x233:
oc = Opcodes.asl;
break;
case 0x034:
oc = Opcodes.mark;
break;
case 0x234:
oc = Opcodes.mtps;
break;
case 0x035:
oc = Opcodes.mfpi;
break;
case 0x235:
oc = Opcodes.mfpd;
break;
case 0x036:
oc = Opcodes.mtpi;
break;
case 0x236:
oc = Opcodes.mtpd;
break;
case 0x037:
oc = Opcodes.sxt;
break;
case 0x237:
oc = Opcodes.mfps;
break;
}
return(new Pdp11Instruction
{
Opcode = oc,
DataWidth = dataWidth,
op1 = op,
});
}
public FormatOpRec(string fmt, Opcodes op)
{
this.fmt = fmt;
this.opcode = op;
}
// Output an opcode to load by name
public void OutName(Opcodes opcode, string name)
{
Out(opcode);
_out.Write(name);
}
public IncomingMessageAttribute(Opcodes opcode)
{
this.Opcodes = new List<Opcodes> {opcode};
}
public static IEnumerable <Packet> Read(string fileName)
{
var extension = Path.GetExtension(fileName);
if (extension == null)
{
throw new IOException("Invalid file type");
}
IPacketReader reader;
switch (extension.ToLower())
{
case ".bin":
reader = new BinaryPacketReader(SniffType.Bin, fileName, Encoding.ASCII);
break;
case ".pkt":
reader = new BinaryPacketReader(SniffType.Pkt, fileName, Encoding.ASCII);
break;
case ".fabi":
reader = new FabiPacketReader(SniffType.Fabi, fileName, Encoding.ASCII);
break;
default:
throw new IOException(String.Format("Invalid file type {0}", extension.ToLower()));
}
var packets = new LinkedList <Packet>();
try
{
var packetNum = 0;
while (reader.CanRead())
{
var packet = reader.Read(packetNum, fileName);
if (packet == null)
{
continue;
}
if (packetNum == 0)
{
// determine build version based on date of first packet if not specified otherwise
if (ClientVersion.IsUndefined())
{
ClientVersion.SetVersion(packet.Time);
}
}
if (packetNum++ < Settings.FilterPacketNumLow)
{
continue;
}
// check for filters
var opcodeName = Opcodes.GetOpcodeName(packet.Opcode);
var add = true;
if (Settings.Filters.Length > 0)
{
add = opcodeName.MatchesFilters(Settings.Filters);
}
// check for ignore filters
if (add && Settings.IgnoreFilters.Length > 0)
{
add = !opcodeName.MatchesFilters(Settings.IgnoreFilters);
}
if (add)
{
packets.AddLast(packet);
if (Settings.FilterPacketsNum > 0 && packets.Count == Settings.FilterPacketsNum)
{
break;
}
}
if (Settings.FilterPacketNumHigh > 0 && packetNum > Settings.FilterPacketNumHigh)
{
break;
}
}
}
catch (Exception ex)
{
Trace.WriteLine(ex.Data);
Trace.WriteLine(ex.GetType());
Trace.WriteLine(ex.Message);
Trace.WriteLine(ex.StackTrace);
}
finally
{
reader.Dispose();
}
return(packets);
}
public static ErrorLogEntry CreateClean(Guid id, Guid accountId, int eventId, Keywords keyword, Opcodes opcode,
Tasks task, Levels level, string eventSource, int version, string message, string exceptionType, string exceptionMessage, string staceTrace,
Payload payload, DateTime created)
{
return new ErrorLogEntry(id, accountId, eventId, keyword, opcode, task, level, JsonSerializer.DeserializeObject<EventSource>(eventSource), version, message, exceptionType, exceptionMessage, staceTrace, payload, created);
}
public void SendNotify(Guid appId, Opcodes notifyCode)
{
IEnumerable<ClientCommunicator> clientCommunicators = appId != Guid.Empty ? GetAppSubscribers(appId) : _clients;
clientCommunicators.ToList().ForEach(c => c.SendData(new Packet(Guid.NewGuid(), notifyCode, string.Empty)));
}
public static ErrorLogEntry CreateNew(int eventId, Keywords keyword, Opcodes opcode,
Tasks task, Levels level, string eventSource, int version, string message, string exceptionType, string exceptionMessage, Payload payload, string stackTrace)
{
return new ErrorLogEntry(eventId, keyword, opcode, task, level, JsonSerializer.DeserializeObject<EventSource>(eventSource), version, message, exceptionType, exceptionMessage, stackTrace, payload, DateTime.UtcNow);
}
protected void AddTrackedOutPacket(uint dwIP, byte byOpcode)
{
// this tracklist tacks _outgoing_ request packets, to make sure incoming answer packets were requested
// only track packets which we actually check for later
if (!IsTrackedOutListRequestPacket(byOpcode))
{
return;
}
TrackPackets_Struct sTrack = new TrackPackets_Struct {
dwIP = dwIP, dwInserted = (uint)Environment.TickCount, byOpcode = byOpcode
};
listTrackedRequests.Insert(0, sTrack);
while (listTrackedRequests.Count > 0)
{
if (Environment.TickCount - listTrackedRequests[listTrackedRequests.Count - 1].dwInserted > Opcodes.SEC2MS(180))
{
listTrackedRequests.RemoveAt(listTrackedRequests.Count - 1);
}
else
{
break;
}
}
}
public ManipulationOperation(int ri, int rj, Opcodes name) : base(ri, rj, name)
{
}
public static void ReadQueryHeader(ref Packet packet)
{
var entry = packet.ReadInt32("Entry");
var guid = packet.ReadGuid("GUID");
if (packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_CREATURE_QUERY) || packet.Opcode == Opcodes.GetOpcode(Opcode.CMSG_GAMEOBJECT_QUERY))
{
if (guid.HasEntry() && (entry != guid.GetEntry()))
{
packet.WriteLine("Entry does not match calculated GUID entry");
}
}
}
public StackOperation(int ri, Opcodes name) : base(ri, 0, name)
{
}
public static void HandleCombatLogMultiple(Packet packet)
{
var count = packet.ReadInt32("Count");
var unk1 = packet.ReadInt32();
for (var i = 0; i < count; i++)
{
var unk2 = packet.ReadInt32();
packet.AddValue("Unknown", unk1 - unk2, i);
var opcode = Opcodes.GetOpcode(packet.ReadInt32(), Direction.ServerToClient);
packet.AddValue("Opcode", opcode);
switch (opcode)
{
case Opcode.SMSG_SPELLHEALLOG:
{
ReadSpellHealLog(ref packet, i);
break;
}
case Opcode.SMSG_SPELLENERGIZELOG:
{
ReadSpellEnergizeLog(ref packet, i);
break;
}
case Opcode.SMSG_PERIODICAURALOG:
{
ReadPeriodicAuraLog(ref packet, i); // sub_5EEE10
break;
}
case Opcode.SMSG_SPELLLOGEXECUTE:
{
ReadSpellLogExecute(ref packet, i);
break;
}
case Opcode.SMSG_SPELLNONMELEEDAMAGELOG:
{
ReadSpellNonMeleeDamageLog(ref packet, i);
break;
}
case Opcode.SMSG_SPELLLOGMISS:
{
ReadSpellMissLog(ref packet, i);
break;
}
case Opcode.SMSG_SPELLSTEALLOG:
case Opcode.SMSG_SPELLDISPELLOG:
case Opcode.SMSG_SPELLBREAKLOG:
{
ReadSpellRemoveLog(ref packet, i);
break;
}
default:
throw new InvalidDataException("Unknown Spell Log Type/Opcode: " + opcode);
}
}
}
public OperatorToken(string name, int precedence, Opcodes correspondingOpcode)
: this(name, precedence, correspondingOpcode, RequiredState.Required)
{ }
public static void ReadPlayerMovementInfo(ref Packet packet, params MovementStatusElements[] movementStatusElements)
{
var guid = new byte[8];
var transportGUID = new byte[8];
var pos = new Vector4();
var transportPos = new Vector4();
bool hasMovementFlags = false;
bool hasMovementFlags2 = false;
bool hasTimestamp = false;
bool hasOrientation = false;
bool hasTransportData = false;
bool hasTransportTime2 = false;
bool hasTransportTime3 = false;
bool hasPitch = false;
bool hasFallData = false;
bool hasFallDirection = false;
bool hasSplineElevation = false;
bool hasUnkTime = false;
bool hasUnkBitA = false;
uint count = 0;
foreach (var movementInfo in movementStatusElements)
{
switch (movementInfo)
{
case MovementStatusElements.MSEHasGuidByte0:
guid[0] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte1:
guid[1] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte2:
guid[2] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte3:
guid[3] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte4:
guid[4] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte5:
guid[5] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte6:
guid[6] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasGuidByte7:
guid[7] = packet.ReadBit();
break;
case MovementStatusElements.MSEHasTransportGuidByte0:
if (hasTransportData)
{
transportGUID[0] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte1:
if (hasTransportData)
{
transportGUID[1] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte2:
if (hasTransportData)
{
transportGUID[2] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte3:
if (hasTransportData)
{
transportGUID[3] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte4:
if (hasTransportData)
{
transportGUID[4] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte5:
if (hasTransportData)
{
transportGUID[5] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte6:
if (hasTransportData)
{
transportGUID[6] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportGuidByte7:
if (hasTransportData)
{
transportGUID[7] = packet.ReadBit();
}
break;
case MovementStatusElements.MSEGuidByte0:
packet.ReadXORByte(guid, 0);
break;
case MovementStatusElements.MSEGuidByte1:
packet.ReadXORByte(guid, 1);
break;
case MovementStatusElements.MSEGuidByte2:
packet.ReadXORByte(guid, 2);
break;
case MovementStatusElements.MSEGuidByte3:
packet.ReadXORByte(guid, 3);
break;
case MovementStatusElements.MSEGuidByte4:
packet.ReadXORByte(guid, 4);
break;
case MovementStatusElements.MSEGuidByte5:
packet.ReadXORByte(guid, 5);
break;
case MovementStatusElements.MSEGuidByte6:
packet.ReadXORByte(guid, 6);
break;
case MovementStatusElements.MSEGuidByte7:
packet.ReadXORByte(guid, 7);
break;
case MovementStatusElements.MSETransportGuidByte0:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 0);
}
break;
case MovementStatusElements.MSETransportGuidByte1:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 1);
}
break;
case MovementStatusElements.MSETransportGuidByte2:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 2);
}
break;
case MovementStatusElements.MSETransportGuidByte3:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 3);
}
break;
case MovementStatusElements.MSETransportGuidByte4:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 4);
}
break;
case MovementStatusElements.MSETransportGuidByte5:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 5);
}
break;
case MovementStatusElements.MSETransportGuidByte6:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 6);
}
break;
case MovementStatusElements.MSETransportGuidByte7:
if (hasTransportData)
{
packet.ReadXORByte(transportGUID, 7);
}
break;
case MovementStatusElements.MSEHasMovementFlags:
hasMovementFlags = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasMovementFlags2:
hasMovementFlags2 = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasTimestamp:
hasTimestamp = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasOrientation:
hasOrientation = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasTransportData:
hasTransportData = packet.ReadBit();
break;
case MovementStatusElements.MSEHasTransportTime2:
if (hasTransportData)
{
hasTransportTime2 = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasTransportTime3:
if (hasTransportData)
{
hasTransportTime3 = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasPitch:
hasPitch = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasFallData:
hasFallData = packet.ReadBit();
break;
case MovementStatusElements.MSEHasFallDirection:
if (hasFallData)
{
hasFallDirection = packet.ReadBit();
}
break;
case MovementStatusElements.MSEHasSplineElevation:
hasSplineElevation = !packet.ReadBit();
break;
case MovementStatusElements.MSEHasSpline:
packet.ReadBit("hasSpline");
break;
case MovementStatusElements.MSECounterCount:
count = packet.ReadBits(22);
break;
case MovementStatusElements.MSECount:
packet.ReadInt32("Counter");
break;
case MovementStatusElements.MSECounter:
for (var i = 0; i < count; i++)
{
packet.ReadInt32("Unk Int", i);
}
break;
case MovementStatusElements.MSEMovementFlags:
if (hasMovementFlags)
{
packet.ReadEnum <MovementFlag>("Movement Flags", 30);
}
break;
case MovementStatusElements.MSEMovementFlags2:
if (hasMovementFlags2)
{
packet.ReadEnum <MovementFlagExtra>("Extra Movement Flags", 13);
}
break;
case MovementStatusElements.MSETimestamp:
if (hasTimestamp)
{
packet.ReadInt32("Timestamp");
}
break;
case MovementStatusElements.MSEPositionX:
pos.X = packet.ReadSingle();
break;
case MovementStatusElements.MSEPositionY:
pos.Y = packet.ReadSingle();
break;
case MovementStatusElements.MSEPositionZ:
pos.Z = packet.ReadSingle();
break;
case MovementStatusElements.MSEOrientation:
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_MOVE_TELEPORT))
{
pos.O = packet.ReadSingle();
}
else
{
if (hasOrientation)
{
pos.O = packet.ReadSingle();
}
}
break;
case MovementStatusElements.MSETransportPositionX:
if (hasTransportData)
{
transportPos.X = packet.ReadSingle();
}
break;
case MovementStatusElements.MSETransportPositionY:
if (hasTransportData)
{
transportPos.Y = packet.ReadSingle();
}
break;
case MovementStatusElements.MSETransportPositionZ:
if (hasTransportData)
{
transportPos.Z = packet.ReadSingle();
}
break;
case MovementStatusElements.MSETransportOrientation:
if (hasTransportData)
{
transportPos.O = packet.ReadSingle();
}
break;
case MovementStatusElements.MSETransportSeat:
if (hasTransportData)
{
packet.ReadByte("Seat");
}
break;
case MovementStatusElements.MSETransportTime:
if (hasTransportData)
{
packet.ReadInt32("Transport Time");
}
break;
case MovementStatusElements.MSETransportTime2:
if (hasTransportData && hasTransportTime2)
{
packet.ReadInt32("Transport Time 2");
}
break;
case MovementStatusElements.MSETransportTime3:
if (hasTransportData && hasTransportTime3)
{
packet.ReadInt32("Transport Time 3");
}
break;
case MovementStatusElements.MSEPitch:
if (hasPitch)
{
packet.ReadSingle("Pitch");
}
break;
case MovementStatusElements.MSEFallTime:
if (hasFallData)
{
packet.ReadInt32("Fall time");
}
break;
case MovementStatusElements.MSEFallVerticalSpeed:
if (hasFallData)
{
packet.ReadSingle("Vertical Speed");
}
break;
case MovementStatusElements.MSEFallCosAngle:
if (hasFallData && hasFallDirection)
{
packet.ReadSingle("Fall Angle");
}
break;
case MovementStatusElements.MSEFallSinAngle:
if (hasFallData && hasFallDirection)
{
packet.ReadSingle("Fall Sin");
}
break;
case MovementStatusElements.MSEFallHorizontalSpeed:
if (hasFallData && hasFallDirection)
{
packet.ReadSingle("Horizontal Speed");
}
break;
case MovementStatusElements.MSESplineElevation:
if (hasSplineElevation)
{
packet.ReadSingle("Spline elevation");
}
break;
case MovementStatusElements.MSEHasUnkTime:
hasUnkTime = !packet.ReadBit();
break;
case MovementStatusElements.MSEUnkTime:
if (hasUnkTime)
{
packet.ReadInt32("Unk Time");
}
break;
case MovementStatusElements.MSEZeroBit:
case MovementStatusElements.MSEOneBit:
packet.ReadBit();
break;
case MovementStatusElements.MSEHasUnkBitA:
hasUnkBitA = packet.ReadBit();
break;
case MovementStatusElements.MSEUnkBitABit:
if (hasUnkBitA)
{
packet.ReadBit("UnkBitABit");
}
break;
case MovementStatusElements.MSEUnkBitAByte:
if (hasUnkBitA)
{
packet.ReadByte("MSEUnkBitAByte");
}
break;
}
}
if (hasTransportData)
{
packet.WriteGuid("Transport Guid", transportGUID);
packet.AddValue("Transport Position", transportPos);
}
if (pos.X != 0 && pos.Y != 0 && pos.Z != 0)
{
packet.AddValue("Position", pos);
}
packet.WriteGuid("Guid", guid);
}
public MessageAttribute(Opcodes opcode, Consumers consumer = Consumers.None)
{
this.Opcodes = new List<Opcodes> {opcode};
this.Consumer = consumer;
}
public static void ReadLfgRewardBlock(ref Packet packet, object index)
{
packet.ReadBoolean("First Completion", index);
if (packet.Opcode == Opcodes.GetOpcode(Opcode.SMSG_LFG_PLAYER_REWARD))
{
packet.ReadInt32("Strangers", index);
}
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_2_2_14545))
{
packet.ReadInt32("currencyQuantity", index);
packet.ReadInt32("Unk 2", index);
packet.ReadInt32("currencyID", index);
packet.ReadInt32("tier1Quantity", index);
packet.ReadInt32("tier1Limit", index);
packet.ReadInt32("overallQuantity", index);
packet.ReadInt32("overallLimit", index);
packet.ReadInt32("periodPurseQuantity", index);
packet.ReadInt32("periodPurseLimit", index);
packet.ReadInt32("purseQuantity", index);
packet.ReadInt32("purseLimit", index);
packet.ReadInt32("Unk 4", index);
packet.ReadInt32("completedEncounters", index);
packet.ReadByte("Call to Arms eligible", index);
// LFG_SLOT_INFO_LOOT related
for (var i = 0; i < 3; ++i)
{
var unk1 = packet.ReadEnum <LfgRoleFlag>("Call to Arms Role", TypeCode.Int32, index, i);
if (unk1 != 0)
{
packet.ReadInt32("Call to Arms Money", index, i);
packet.ReadInt32("Call to Arms XP", index, i);
var unk4 = packet.ReadByte("Call to Arms Item Count", index, i);
for (var j = 0; j < unk4; ++j)
{
packet.ReadEntry <Int32>(StoreNameType.Item, "Call to Arms Item Or Currency Id", index, i, j);
packet.ReadInt32("Call to Arms Item Display ID", index, i, j);
packet.ReadInt32("Call to Arms Item Stack Count", index, i, j);
packet.ReadBoolean("Call to Arms Is Currency", index, i, j);
}
}
}
}
packet.ReadInt32("Base Money", index);
packet.ReadInt32("Base XP", index);
if (ClientVersion.RemovedInVersion(ClientVersionBuild.V4_0_6a_13623))
{
packet.ReadInt32("Variable Money", index);
packet.ReadInt32("Variable XP", index);
}
var numFields = packet.ReadByte("Reward Item Count", index);
for (var i = 0; i < numFields; i++)
{
packet.ReadEntry <Int32>(StoreNameType.Item, "Reward Item Or Currency Id", index, i);
packet.ReadInt32("Reward Item Display ID", index, i);
packet.ReadInt32("Reward Item Stack Count", index, i);
if (ClientVersion.AddedInVersion(ClientVersionBuild.V4_0_6a_13623))
{
packet.ReadBoolean("Is Currency", index, i);
}
}
}
/// <summary>
/// Creates the request packet.
/// </summary>
/// <param name="opCode">The op code.</param>
/// <param name="remoteFile">The remote file.</param>
/// <param name="tftpMode">The TFTP mode.</param>
/// <returns>the ack packet</returns>
private byte[] CreateRequestPacket(Opcodes opCode, string remoteFile, Modes tftpMode)
{
// Create new Byte array to hold Initial
// Read Request Packet
int pos = 0;
string modeAscii = tftpMode.ToString().ToLowerInvariant();
byte[] ret = new byte[modeAscii.Length + remoteFile.Length + 4];
// Set first Opcode of packet to indicate
// if this is a read request or write request
ret[pos++] = 0;
ret[pos++] = (byte)opCode;
// Convert Filename to a char array
pos += Encoding.ASCII.GetBytes(remoteFile, 0, remoteFile.Length, ret, pos);
ret[pos++] = 0;
pos += Encoding.ASCII.GetBytes(modeAscii, 0, modeAscii.Length, ret, pos);
ret[pos] = 0;
return ret;
}
public MethodOperation(int offset, Opcodes name) : base(0, 0, name)
{
MemoryOffest = offset & WORD_MAX;
}
public static void Handle(PacketIn packet)
{
if (!System.Enum.IsDefined(typeof(Opcodes), (byte)packet.Opcode))
{
Client.Popup("Invalid opcode: " + packet.Opcode.ToString("X02"));
return;
}
Opcodes opcodes = (Opcodes)packet.Opcode;
switch (opcodes)
{
case Opcodes.LCR_CHECK:
switch (packet.GetUint8())
{
case 0:
Client.Start();
return;
case 1:
{
Client.Print(packet.GetString());
Client.Close();
return;
}
case 2:
{
Client.UpdateWarData(Encoding.ASCII.GetBytes(packet.GetString()));
return;
}
default:
return;
}
break;
case Opcodes.CL_START:
break;
case Opcodes.LCR_START:
{
byte uint8 = packet.GetUint8();
if (uint8 == 1)
{
Client.Print("Invalid Username/Password");
MainWindow.mainWindow.EnableConnect(true);
return;
}
if (uint8 == 2)
{
Client.Print("Your account has been suspended.");
MainWindow.mainWindow.EnableConnect(true);
return;
}
if (uint8 == 3)
{
Client.Print("Your account is not active.");
MainWindow.mainWindow.EnableConnect(true);
return;
}
if (uint8 > 3)
{
Client.Print("Invalid Response: " + uint8);
MainWindow.mainWindow.EnableConnect(true);
return;
}
Client.Auth = packet.GetString();
Client.Print("");
try
{
MainWindow.KillProcessByName("WAR", false);
MainWindow.mainWindow.EnableConnect(false);
string currentDirectory = System.IO.Directory.GetCurrentDirectory();
System.IO.Directory.SetCurrentDirectory(currentDirectory);
Client.patchExe();
Process process = new Process();
process.StartInfo.FileName = "WAR.exe";
process.StartInfo.Arguments = " --acctname=" + System.Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(Client.User)) + " --sesstoken=" + System.Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(Client.Auth));
process.EnableRaisingEvents = true;
process.Exited += new System.EventHandler(Client.war_Exited);
process.Start();
// Minimize the launcher once the game process is started
MainWindow.mainWindow.ModifyWindowState(System.Windows.WindowState.Minimized);
}
catch (System.UnauthorizedAccessException ex)
{
if (MainWindow.mainWindow.NoErrorMode == false)
{
Client.Popup("Access to WAR.exe is denied. Please obtain access permissions to the Warhammer directory and files and try again: " + Environment.NewLine + ex.ToString());
}
else
{
Client.Print("Error starting game. User lacks file access permissions");
}
// Prompt the user to restart the launcher as admin - this normally fixes this error
if (MainWindow.mainWindow.IsAdministrator() == false)
{
if (System.Windows.MessageBox.Show("Running the launcher as Administrator may resolve this error. Would you like to restart it as Administrator now?", "Restart as Administrator", System.Windows.MessageBoxButton.YesNo) == System.Windows.MessageBoxResult.Yes)
{
MainWindow.mainWindow.RestartAsAdmin();
}
}
else
{
if (System.Windows.MessageBox.Show("Removing the Read-Only attribute from files in the game directory may resolve this error. Would you like to remove this attribute and restart the application now? Note this will also restart the application as Administrator.", "Remove Read-Only Attribute", System.Windows.MessageBoxButton.YesNo) == System.Windows.MessageBoxResult.Yes)
{
// User must have read/write access to the directory for this to be allowed
MainWindow.mainWindow.RemoveReadOnly(new DirectoryInfo(System.IO.Directory.GetCurrentDirectory()));
MainWindow.mainWindow.RestartAsAdmin();
}
}
}
catch (System.Exception ex)
{
if (MainWindow.mainWindow.NoErrorMode == false)
{
Client.Popup("Error starting: " + ex.ToString());
}
else
{
Client.Print("Error starting game");
}
}
break;
}
default:
if (opcodes != Opcodes.LCR_INFO)
{
return;
}
break;
}
}
public OperatorToken(string name) : base(name)
{
_precedence = -1;
_correspondingOpcode = Opcodes.None;
}
public int Parse(byte[] bytes, int offset, int length)
{
int index;
if (state == States.Done)
state = States.Byte0;
for (index = 0; index < length && state != States.Done; index++)
{
byte value = bytes[offset + index];
switch (state)
{
case States.Byte0:
Fin = (value & 0x80) != 0;
Opcode = (Opcodes)(value & 0x0f);
state = States.Byte1;
break;
case States.Byte1:
Mask = (value & 0x80) != 0;
PayloadLengthLong = value & 0x7f;
if (PayloadLengthLong == 126)
state = States.Payload126_0;
else if (PayloadLengthLong == 127)
state = States.Payload127_0;
else
state = Mask ? States.Mask0 : States.Done;
break;
case States.Payload126_0:
PayloadLengthLong = value;
state = States.Payload126_1;
break;
case States.Payload126_1:
PayloadLengthLong <<= 8;
PayloadLengthLong |= value;
state = Mask ? States.Mask0 : States.Done;
break;
case States.Payload127_0:
PayloadLengthLong = value;
state = States.Payload127_1;
break;
case States.Payload127_1:
PayloadLengthLong <<= 8;
PayloadLengthLong |= value;
state = States.Payload127_2;
break;
case States.Payload127_2:
PayloadLengthLong <<= 8;
PayloadLengthLong |= value;
state = States.Payload127_3;
break;
case States.Payload127_3:
PayloadLengthLong <<= 8;
PayloadLengthLong |= value;
state = Mask ? States.Mask0 : States.Done;
break;
case States.Mask0:
MaskingKey0 = value;
state = States.Mask1;
break;
case States.Mask1:
MaskingKey1 = value;
state = States.Mask2;
break;
case States.Mask2:
MaskingKey2 = value;
state = States.Mask3;
break;
case States.Mask3:
MaskingKey3 = value;
state = States.Done;
break;
}
}
return index;
}
public ClientHeader(Opcodes opcode, PacketWriter packet)
{
Opcode = opcode;
Packet = packet;
}
protected void EmitImm(Opcodes op, int Imm)
{
if ((Imm & 127) != Imm)
throw new ArgumentOutOfRangeException("Immidate " + Imm.ToString() + " is out of range");
Emit((byte)((int)op | Imm));
}
public GenericBlobMessage(Opcodes opcode):base(opcode) { }
public ACDTranslateFacingMessage(Opcodes id) : base(id) {}
// versionless
public ParserAttribute(Opcode opcode)
{
Opcode = Opcodes.GetOpcode(opcode);
}
public void Out(Opcodes opcode, TypedValue value)
{
Out(opcode);
_pw.WriteValue(value);
}
private static byte[] PrepareForWebsocket(byte[] message, Opcodes opcode)
{
var wsHeader = new WebSocketHeader()
{
Fin = true,
Opcode = opcode,
PayloadLength = message.Length,
Mask = true,
MaskingKey0 = 0x12,
MaskingKey1 = 0x34,
MaskingKey2 = 0x56,
MaskingKey3 = 0x78,
};
var extra = new byte[wsHeader.GetHeaderLength()];
wsHeader.GenerateHeader(new ArraySegment<byte>(extra));
if (wsHeader.Mask)
wsHeader.MaskData(message, 0, message.Length);
return extra;
}
public PacketWriter(Opcodes opcode) : base(new MemoryStream())
{
Opcode = opcode;
WritePacketHeader();
}
protected void Emit(Opcodes op)
{
Emit((byte)op);
}
protected bool IsOnOutTrackList(uint dwIP, byte byOpcode, bool bDontRemove)
{
#if DEBUG
if (!IsTrackedOutListRequestPacket(byOpcode))
{
Debug.Assert(false); // code error / bug
}
#endif
for (int pos = 0; pos < listTrackedRequests.Count; pos++)
{
var trackedRequest = listTrackedRequests[pos];
if (trackedRequest.dwIP == dwIP && trackedRequest.byOpcode == byOpcode && ((Environment.TickCount - trackedRequest.dwInserted) < Opcodes.SEC2MS(180)))
{
if (!bDontRemove)
{
listTrackedRequests.RemoveAt(pos);
}
return(true);
}
}
return(false);
}
protected void EmitReg(Opcodes op, int Reg)
{
if ((Reg & 15) != Reg)
throw new ArgumentOutOfRangeException("Register " + Reg.ToString() + " is out of range");
Emit((byte)((int)op | Reg));
}
protected bool InTrackListIsAllowedPacket(uint uIP, byte byOpcode, bool bValidSenderkey)
{
// this tracklist tacks _incoming_ request packets and acts as a general flood protection by dropping
// too frequent requests from a single IP, avoiding response floods, processing time DOS attacks and slowing down
// other possible attacks/behavior (scanning indexed files, fake publish floods, etc)
// first figure out if this is a request packet to be tracked and its timelimits
// timelimits are choosed by estimating the max. frequency of such packets on normal operation (+ buffer)
// (those limits are not meant be fine to be used by normal usage, but only supposed to be a flood detection)
uint iAllowedPacketsPerMinute;
byte byDbgOrgOpcode = byOpcode;
switch (byOpcode)
{
case Opcodes.KADEMLIA2_BOOTSTRAP_REQ:
iAllowedPacketsPerMinute = 2;
break;
case Opcodes.KADEMLIA2_HELLO_REQ:
iAllowedPacketsPerMinute = 3;
break;
case Opcodes.KADEMLIA2_REQ:
iAllowedPacketsPerMinute = 10;
break;
case Opcodes.KADEMLIA2_SEARCH_NOTES_REQ:
iAllowedPacketsPerMinute = 3;
break;
case Opcodes.KADEMLIA2_SEARCH_KEY_REQ:
iAllowedPacketsPerMinute = 3;
break;
case Opcodes.KADEMLIA2_SEARCH_SOURCE_REQ:
iAllowedPacketsPerMinute = 3;
break;
case Opcodes.KADEMLIA2_PUBLISH_KEY_REQ:
iAllowedPacketsPerMinute = 3;
break;
case Opcodes.KADEMLIA2_PUBLISH_SOURCE_REQ:
iAllowedPacketsPerMinute = 2;
break;
case Opcodes.KADEMLIA2_PUBLISH_NOTES_REQ:
iAllowedPacketsPerMinute = 2;
break;
case Opcodes.KADEMLIA_FIREWALLED2_REQ:
byOpcode = Opcodes.KADEMLIA_FIREWALLED_REQ;
iAllowedPacketsPerMinute = 2;
break;
case Opcodes.KADEMLIA_FIREWALLED_REQ:
iAllowedPacketsPerMinute = 2;
break;
case Opcodes.KADEMLIA_FINDBUDDY_REQ:
iAllowedPacketsPerMinute = 2;
break;
case Opcodes.KADEMLIA_CALLBACK_REQ:
iAllowedPacketsPerMinute = 1;
break;
case Opcodes.KADEMLIA2_PING:
iAllowedPacketsPerMinute = 2;
break;
default:
// not any request packets, so its a response packet - no further checks on this point
return(true);
}
uint iSecondsPerPacket = 60 / iAllowedPacketsPerMinute;
uint dwCurrentTick = (uint)Environment.TickCount;
// time for cleaning up?
if (dwCurrentTick - dwLastTrackInCleanup > Opcodes.MIN2MS(12))
{
InTrackListCleanup();
}
// check for existing entries
TrackPacketsIn_Struct pTrackEntry;
if (!m_mapTrackPacketsIn.ContainsKey(uIP))
{
pTrackEntry = new TrackPacketsIn_Struct();
pTrackEntry.m_uIP = uIP;
m_mapTrackPacketsIn[uIP] = pTrackEntry;
m_liTrackPacketsIn.Insert(0, pTrackEntry);
}
else
{
pTrackEntry = m_mapTrackPacketsIn[uIP];
}
// search specific request tracks
for (int i = 0; i < pTrackEntry.m_aTrackedRequests.Count; i++)
{
if (pTrackEntry.m_aTrackedRequests[i].m_byOpcode == byOpcode)
{
// already tracked requests with theis opcode, remove already expired request counts
TrackPacketsIn_Struct.TrackedRequestIn_Struct rCurTrackedRequest = pTrackEntry.m_aTrackedRequests[i];
if (rCurTrackedRequest.m_nCount > 0 && dwCurrentTick - rCurTrackedRequest.m_dwFirstAdded > Opcodes.SEC2MS(iSecondsPerPacket))
{
uint nRemoveCount = (dwCurrentTick - rCurTrackedRequest.m_dwFirstAdded) / Opcodes.SEC2MS(iSecondsPerPacket);
if (nRemoveCount > rCurTrackedRequest.m_nCount)
{
rCurTrackedRequest.m_nCount = 0;
rCurTrackedRequest.m_dwFirstAdded = dwCurrentTick; // for the packet we just process
}
else
{
rCurTrackedRequest.m_nCount -= nRemoveCount;
rCurTrackedRequest.m_dwFirstAdded += Opcodes.SEC2MS(iSecondsPerPacket) * nRemoveCount;
}
}
// we increase the counter in any case, even if we drop the packet later
rCurTrackedRequest.m_nCount++;
// remember only for easier cleanup
pTrackEntry.m_dwLastExpire = Math.Max(pTrackEntry.m_dwLastExpire, rCurTrackedRequest.m_dwFirstAdded + Opcodes.SEC2MS(iSecondsPerPacket) * rCurTrackedRequest.m_nCount);
if (Kademlia.IsRunningInLANMode() && OtherFunctions.IsLANIP((uint)IPAddress.NetworkToHostOrder(uIP))) // no flood detection in LanMode
{
return(true);
}
// now the actualy check if this request is allowed
if (rCurTrackedRequest.m_nCount > iAllowedPacketsPerMinute * 5)
{
// this is so far above the limit that it has to be an intentional flood / misuse in any case
// so we take the next higher punishment and ban the IP
//DebugLogWarning("Kad: Massive request flood detected for opcode 0x%X (0x%X) from IP %s - Banning IP", byOpcode, byDbgOrgOpcode, ipstr(ntohl(uIP)));
//theApp.clientlist.AddBannedClient(IPAddress.NetworkToHostOrder(uIP));
return(false); // drop packet
}
else if (rCurTrackedRequest.m_nCount > iAllowedPacketsPerMinute)
{
// over the limit, drop the packet but do nothing else
if (!rCurTrackedRequest.m_bDbgLogged)
{
rCurTrackedRequest.m_bDbgLogged = true;
//DebugLog("Kad: Request flood detected for opcode 0x%X (0x%X) from IP %s - Droping packets with this opcode", byOpcode, byDbgOrgOpcode, ipstr(ntohl(uIP)));
}
return(false); // drop packet
}
else
{
rCurTrackedRequest.m_bDbgLogged = false;
}
return(true);
}
}
// add a new entry for this request, no checks needed since 1 is always ok
TrackPacketsIn_Struct.TrackedRequestIn_Struct curTrackedRequest;
curTrackedRequest.m_byOpcode = byOpcode;
curTrackedRequest.m_bDbgLogged = false;
curTrackedRequest.m_dwFirstAdded = dwCurrentTick;
curTrackedRequest.m_nCount = 1;
// remember only for easier cleanup
pTrackEntry.m_dwLastExpire = Math.Max(pTrackEntry.m_dwLastExpire, dwCurrentTick + Opcodes.SEC2MS(iSecondsPerPacket));
pTrackEntry.m_aTrackedRequests.Add(curTrackedRequest);
return(true);
}
public uint ActorID; // Actor's DynamicID
public ANNDataMessage(Opcodes id) : base(id) {}
protected void AddLegacyChallenge(UInt128 uContactID, UInt128 uChallengeID, uint uIP, byte byOpcode)
{
TrackChallenge_Struct sTrack = new TrackChallenge_Struct {
uIP = uIP, dwInserted = (uint)Environment.TickCount, byOpcode = byOpcode, uContactID = uContactID, uChallenge = uChallengeID
};
listChallengeRequests.Insert(0, sTrack);
while (listChallengeRequests.Count > 0)
{
if (Environment.TickCount - listChallengeRequests[listChallengeRequests.Count - 1].dwInserted > Opcodes.SEC2MS(180))
{
//DEBUG_ONLY(DebugLog("Challenge timed out, client not verified - %s", ipstr(ntohl(listChallengeRequests.GetTail().uIP))));
listChallengeRequests.RemoveAt(listChallengeRequests.Count - 1);
}
else
{
break;
}
}
}
public Handler getHandler(Opcodes opcode)
{
return _handlers[opcode];
}
protected bool HasActiveLegacyChallenge(uint uIP)
{
foreach (var challengeRequest in listChallengeRequests)
{
if (challengeRequest.uIP == uIP && ((Environment.TickCount - challengeRequest.dwInserted) < Opcodes.SEC2MS(180)))
{
return(true);
}
}
return(false);
}
