Exemplo n.º 1
0
 public static void DumpPacket(Account acc, byte[] packetOut)
 {
     using (var packet = PinnedRealmPacketIn.CreateFromOutPacket(packetOut))
     {
         DumpPacket(acc, packet);
     }
 }
Exemplo n.º 2
0
        /// <summary>
        /// Dumps the content of an Update packet to the console
        /// </summary>
        //public static void DumpUpdatePacket(RealmPacketOut packet)
        //{
        //    try
        //    {
        //        ParsedUpdatePacket.Dump(packet.GetPacketPayload(), false, m_updatePacketWriter);
        //        m_updatePacketWriter.Flush();
        //    }
        //    catch (Exception e)
        //    {
        //        OnException("Failed to parse Update-Packet.", e, packet.GetPacketPayload());
        //    }
        //}

        public static void DumpPacket(byte[] packetOut)
        {
            using (var packet = PinnedRealmPacketIn.CreateFromOutPacket(packetOut))
            {
                DumpPacket(null, packet);
            }
        }
Exemplo n.º 3
0
        public static void DumpPacket(RealmPacketIn packet, bool copy, IndentTextWriter writer)
        {
            try
            {
                if (copy)
                {
                    using (PinnedRealmPacketIn pkt = packet.Copy())
                    {
                        PacketAnalyzer.Render(pkt, writer);
                    }
                }
                else
                {
                    PacketAnalyzer.Render(packet, writer);
                }
            }
            catch (Exception e)
            {
                log.ErrorException("Unable to parse/render packet " + packet, e);

                writer.IndentLevel = 0;
                writer.Write(packet.ToHexDump());
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Extracts all Packets out of the given logged and default-formatted lines
        /// </summary>
        public static List <PinnedRealmPacketIn> Extract(string[] log)
        {
            List <PinnedRealmPacketIn> packets = new List <PinnedRealmPacketIn>();

            for (int i = 0; i < log.Length; i++)
            {
                RealmServerOpCode opCode;
                var line = log[i];
                if (line.StartsWith("{"))
                {
                    Match match = Regex.Match(line, @"\(0x(.{4})\)");
                    if (match.Success)
                    {
                        opCode = (RealmServerOpCode)Int32.Parse(match.Groups[1].Value, NumberStyles.HexNumber);
                    }
                    else
                    {
                        match = Regex.Match(line, @"\(([^\)]+)\)");
                        if (match.Success)
                        {
                            opCode = (RealmServerOpCode)Enum.Parse(typeof(RealmServerOpCode), match.Groups[1].Value);
                        }
                        else
                        {
                            Console.WriteLine("Could not parse Packet Header: " + line);
                            continue;
                        }
                    }

                    // skip the column count
                    i += 4;
                    StringBuilder sb = new StringBuilder();
                    while ((line = log[i++]).StartsWith("|") && line.EndsWith("|"))
                    {
                        int first  = line.IndexOf('|') + 1;
                        int second = line.IndexOf('|', first) - 1;
                        var str    = line.Substring(first, second - first);
                        //str = str.TrimEnd(' ');
                        sb.Append(str + " ");
                    }

                    var bytes       = UpdateFieldsUtil.ParseBytes(sb.ToString(), true);
                    var packetBytes = new byte[bytes.Length + RealmPacketIn.HEADER_SIZE];

                    var size = bytes.Length + RealmPacketIn.HEADER_SIZE;

                    packetBytes[0] = (byte)((size >> 8) & 0xFF);
                    packetBytes[1] = (byte)(size & 0xFF);

                    packetBytes[2] = (byte)((int)opCode & 0xFF);
                    packetBytes[3] = (byte)(((int)opCode >> 8) & 0xFF);

                    Array.Copy(bytes, 0, packetBytes, RealmPacketIn.HEADER_SIZE, bytes.Length);

                    var packet = PinnedRealmPacketIn.Create(packetBytes);
                    packet.Initialize();
                    packets.Add(packet);
                }
            }
            return(packets);
        }