Example #1
0
        public static string ConvertPacketToTreeString(IEnumerable ps)
        {
            using (TextWriter writer = new StringWriter())
            {
                int count = 0;

                foreach (object o in ps)
                {
                    LogPacket p = o as LogPacket;
                    DataFrame f = o as DataFrame;

                    if (p != null)
                    {
                        writer.WriteLine(GetHeader(p));
                        WriteNodeToTreeString(writer, "", p.Frame.Root);
                    }
                    else if (f != null)
                    {
                        writer.WriteLine("Packet {0}", count);
                        WriteNodeToTreeString(writer, "", f.Root);
                    }
                    count++;
                }

                return(writer.ToString());
            }
        }
Example #2
0
        public static string ConvertPacketToString(IEnumerable ps)
        {
            using (TextWriter writer = new StringWriter())
            {
                int count = 0;

                foreach (object o in ps)
                {
                    LogPacket p = o as LogPacket;
                    DataFrame f = o as DataFrame;

                    if (p != null)
                    {
                        writer.Write(ConvertPacketToString(p));
                    }
                    else if (f != null)
                    {
                        writer.WriteLine("Packet {0}", count);
                        writer.Write(ConvertPacketToString(f));
                    }
                    count++;
                }

                return(writer.ToString());
            }
        }
Example #3
0
 public static string ConvertPacketToString(LogPacket p)
 {
     using (TextWriter writer = new StringWriter())
     {
         writer.WriteLine(GetHeader(p));
         writer.WriteLine(ConvertPacketToString(p.Frame));
         return(writer.ToString());
     }
 }
Example #4
0
        public static string ConvertPacketToTreeString(LogPacket p)
        {
            using (TextWriter writer = new StringWriter())
            {
                writer.WriteLine(GetHeader(p));
                WriteNodeToTreeString(writer, "", p.Frame.Root);

                return(writer.ToString());
            }
        }
Example #5
0
 /// <summary>
 /// Add a packet to the buffer to write
 /// </summary>
 /// <param name="packet">The packet to write</param>
 public void AddPacket(LogPacket packet)
 {
     lock (_packets)
     {
         _packets[_currPos++] = packet;
         if (_currPos == MAX_PACKETS)
         {
             Flush();
         }
     }
 }
Example #6
0
        /// <summary>
        /// Convert a packet to a hex string format
        /// </summary>
        /// <param name="p">The packet to convert</param>
        /// <returns>The converted string</returns>
        public static string ConvertBinaryPacketToString(LogPacket p)
        {
            using (TextWriter writer = new StringWriter())
            {
                writer.WriteLine(GetHeader(p));
                writer.WriteLine(GeneralUtils.BuildHexDump(16, p.Frame.ToArray()));
                writer.WriteLine();

                return(writer.ToString());
            }
        }
Example #7
0
        private static void ConvertPacketsToHtml(TextWriter textWriter, IEnumerable ps, bool forcebin)
        {
            XmlWriterSettings settings = new XmlWriterSettings();

            settings.Indent             = true;
            settings.OmitXmlDeclaration = true;

            using (XmlWriter writer = XmlWriter.Create(textWriter, settings))
            {
                int count = 0;

                writer.WriteStartElement("html");
                writer.WriteStartElement("head");
                writer.WriteElementString("title", "Packet Log");
                writer.WriteEndElement();
                writer.WriteStartElement("body");

                foreach (object o in ps)
                {
                    LogPacket  p = o as LogPacket;
                    DataFrame  f = o as DataFrame;
                    ColorValue c = ColorValue.White;
                    if (p != null)
                    {
                        writer.WriteElementString("h2", String.Format("Time {0} - Tag '{1}' - Network '{2}'",
                                                                      p.Timestamp.ToString(), p.Tag, p.Network));
                        f = p.Frame;
                        c = p.Color;
                    }
                    else
                    {
                        writer.WriteElementString("h2", String.Format("Packet {0}", count));
                    }
                    count++;

                    if (f.IsBasic || forcebin)
                    {
                        WriteBinaryPacketAsHtml(writer, f, c);
                    }
                    else if (f.IsDataString)
                    {
                        WriteTextPacketAsHtml(writer, f, c);
                    }
                    else
                    {
                        WriteTreePacketAsHtml(writer, f, c);
                    }
                }

                writer.WriteEndElement();
                writer.WriteEndElement();
            }
        }
Example #8
0
        private static LogPacket ReadPacket(DateTime packetTime, Guid netId, byte[] data)
        {
            MemoryStream stm    = new MemoryStream(data);
            DataReader   reader = new DataReader(stm);
            LogPacket    ret    = null;

            try
            {
                EthernetPacket eth = ReadEthernetPacket(reader);
                if (eth.PacketType == EthernetPacket.ETHERNET_TYPE_IPv4)
                {
                    IpPacket ip = ReadIpv4Packet(reader);

                    if (ip.IpType == IpPacket.IP_TYPE_TCP)
                    {
                        TcpPacket tcp = ReadTcpPacket(reader, ip.DataLength);

                        if (tcp.Data.Length > 0)
                        {
                            ret = new LogPacket("TCP", netId, Guid.NewGuid(), String.Format("{0}:{1} => {2}:{3}",
                                                                                            ip.SrcAddress, tcp.SrcPort, ip.DestAddress, tcp.DestPort), new DataFrame(tcp.Data),
                                                new ColorValue(0xFF, 0xFF, 0xFF, 0xFF), packetTime);
                        }
                    }
                    else if (ip.IpType == IpPacket.IP_TYPE_UDP)
                    {
                        UdpPacket udp = ReadUdpPacket(reader);

                        ret = new LogPacket("UDP", netId, Guid.NewGuid(), String.Format("{0}:{1} => {2}:{3}",
                                                                                        ip.SrcAddress, udp.SrcPort, ip.DestAddress, udp.DestPort), new DataFrame(udp.Data),
                                            new ColorValue(0xFF, 0xFF, 0xFF, 0xFF), packetTime);
                    }
                    else
                    {
                        // Do nothing
                    }
                }
            }
            catch (EndOfStreamException)
            {
                ret = null;
            }
            catch (ArgumentException)
            {
            }

            return(ret);
        }
Example #9
0
 /// <summary>
 /// Reads the packets from file.
 /// </summary>
 /// <returns>The packets from file.</returns>
 /// <param name="filename">The filename</param>
 public static IEnumerable <LogPacket> ReadPacketsFromFile(string filename)
 {
     using (var stream = File.OpenRead(filename))
     {
         List <LogPacket> packets = new List <LogPacket>();
         try
         {
             while (true)
             {
                 packets.Add(LogPacket.ReadFromStream(stream));
             }
         }
         catch (EndOfStreamException)
         {
         }
         return(packets);
     }
 }
Example #10
0
        /// <summary>
        /// Flush the current buffer to the stream
        /// </summary>
        public void Flush()
        {
            lock (_packets)
            {
                if (_currPos > 0)
                {
                    LogPacket[] arr = _packets;

                    if (_currPos < MAX_PACKETS)
                    {
                        arr = new LogPacket[_currPos];
                        Array.Copy(_packets, 0, arr, 0, _currPos);
                    }

                    GeneralUtils.SerializeLogPackets(arr, _stm);

                    Array.Clear(_packets, 0, _packets.Length);
                    _currPos = 0;
                }
            }
        }
Example #11
0
        public static List <LogPacket> EnumerableToPackets(IEnumerable ps)
        {
            List <LogPacket> packets = new List <LogPacket>();

            foreach (object o in ps)
            {
                LogPacket p = o as LogPacket;
                if (p == null)
                {
                    DataFrame f = o as DataFrame;
                    if (f == null)
                    {
                        continue;
                    }
                    p = new LogPacket("Unknown", Guid.Empty, "Unknown", f, ColorValue.White);
                }
                packets.Add(p);
            }

            return(packets);
        }
Example #12
0
        public static void SavePackets(string filename, IEnumerable ps)
        {
            List <LogPacket> packets = new List <LogPacket>();

            foreach (object o in ps)
            {
                LogPacket p = o as LogPacket;
                if (p == null)
                {
                    DataFrame f = o as DataFrame;
                    if (f == null)
                    {
                        continue;
                    }
                    p = new LogPacket("Unknown", Guid.Empty, "Unknown", f, ColorValue.White);
                }
                packets.Add(p);
            }

            using (FileStream stm = File.Open(filename, FileMode.Create))
            {
                GeneralUtils.SerializeLogPackets(packets.ToArray(), stm);
            }
        }
Example #13
0
 public static string ConvertPacketsToHtml(LogPacket p)
 {
     return(ConvertPacketsToHtml(new LogPacket[] { p }));
 }
Example #14
0
        /// <summary>
        /// Load a list of packets from a PCAP (really basic mode)
        /// </summary>
        /// <param name="fileName">The file to read from</param>l
        /// <param name="raw">Whether to import the raw data or parse for TCP/UDP data</param>
        /// <returns>The array of LogPackets</returns>
        public static LogPacket[] Load(string fileName, bool raw)
        {
            List <LogPacket> packets = new List <LogPacket>();

            using (Stream stm = File.OpenRead(fileName))
            {
                DataReader reader       = new DataReader(stm);
                bool       littleEndian = true;

                uint magic = reader.ReadUInt32(littleEndian);

                if (magic == 0xa1b2c3d4)
                {
                    // OK
                }
                else if (magic == 0xd4c3b2a1)
                {
                    littleEndian = false;
                }
                else
                {
                    throw new ArgumentException(Resources.PcapReader_InvalidMagic);
                }

                reader.ReadUInt16(littleEndian); // Major
                reader.ReadUInt16(littleEndian); // Minor
                reader.ReadInt32(littleEndian);  // Zone
                reader.ReadUInt32(littleEndian); // Sig figures
                reader.ReadUInt32(littleEndian); // Snap length
                uint netType = reader.ReadUInt32(littleEndian);

                if (!raw && netType != 1)
                {
                    throw new ArgumentException(Resources.PcapReader_OnlyEthernet);
                }

                try
                {
                    Guid netId = Guid.NewGuid();
                    while (reader.DataLeft > 0)
                    {
                        int      secs        = reader.ReadInt32(littleEndian);
                        int      usecs       = reader.ReadInt32(littleEndian);
                        DateTime captureTime = GeneralUtils.FromUnixTime(secs).AddMilliseconds(usecs / 10);
                        int      caplen      = reader.ReadInt32(littleEndian);
                        int      origlen     = reader.ReadInt32(littleEndian);
                        byte[]   data        = reader.ReadBytes(caplen);

                        if (raw)
                        {
                            packets.Add(new LogPacket("PCAP Raw", netId, Guid.NewGuid(), "Unknown",
                                                      new DataFrame(data), new ColorValue(0xFF, 0xFF, 0xFF, 0xFF),
                                                      captureTime));
                        }
                        else
                        {
                            LogPacket p = ReadPacket(captureTime, netId, data);

                            if (p != null)
                            {
                                packets.Add(p);
                            }
                        }
                    }
                }
                catch (EndOfStreamException)
                {
                }
            }

            return(packets.ToArray());
        }
Example #15
0
 /// <summary>
 /// Dump a text packet to stdout
 /// </summary>
 /// <param name="packet">The packet to dump</param>
 public static void DumpTextPacket(LogPacket packet)
 {
     Console.Out.WriteLine(ConvertTextPacketToString(packet));
 }
Example #16
0
 private static string GetHeader(LogPacket p)
 {
     return(String.Format("Time {0} - Tag '{1}' - Network '{2}'",
                          p.Timestamp.ToString(), p.Tag, p.Network));
 }
Example #17
0
 public static string ConvertPacketToTreeString(LogPacket p)
 {
     return(ConvertPacketToTreeString(new LogPacket[] { p }));
 }