/// <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;
}
}
}
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);
}
}
/// <summary>
/// Write a NUL terminated string to the stream with a specified encoding
/// </summary>
/// <param name="str">The string to write</param>
/// <param name="encoding">The encoding to use</param>
public void WriteNulTerminatedString(string str, BinaryStringEncoding encoding)
{
WriteNulTerminatedString(str, GeneralUtils.GetEncodingFromType(encoding));
}
/// <summary>
/// Write a terminated string to the stream
/// </summary>
/// <param name="str">The string to write</param>
/// <param name="encoding">The encoding to use</param>
/// <param name="terminator">The terminator</param>
public void WriteTerminatedString(string str, BinaryStringEncoding encoding, char terminator)
{
WriteTerminatedString(str, GeneralUtils.GetEncodingFromType(encoding), terminator);
}
/// <summary>
/// Write a line to the stream using a specified encoding and LF line ending
/// </summary>
/// <param name="line">The line to write</param>
/// <param name="encoding">The encoding to use</param>
public void WriteLine(string line, BinaryStringEncoding encoding)
{
WriteLine(line, GeneralUtils.GetEncodingFromType(encoding));
}
/// <summary>
/// Write a character with a specified encoding
/// </summary>
/// <param name="ch">The character</param>
/// <param name="encoding">The encoding</param>
public void WriteChar(char ch, BinaryStringEncoding encoding)
{
WriteChar(ch, GeneralUtils.GetEncodingFromType(encoding));
}
/// <summary>
/// Read an unsigned integer from the stream with a specified endian
/// </summary>
/// <param name="littleEndian">True for little endian, false for big endian</param>
/// <returns>The read value</returns>
public uint ReadUInt32(bool littleEndian)
{
byte[] data = ReadBytes(4);
return(BitConverter.ToUInt32(GeneralUtils.SwapBytes(data, littleEndian), 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());
}
/// <summary>
/// Write an unsigned 64bit integer with a specified endian
/// </summary>
/// <param name="l">The integer to write</param>
/// <param name="littleEndian">True for little endian, otherwise big endian</param>
public void WriteUInt64(ulong l, bool littleEndian)
{
WriteBytes(GeneralUtils.SwapBytes(BitConverter.GetBytes(l), littleEndian));
}
/// <summary>
/// Write an unsigned 32bit integer with a specified endian
/// </summary>
/// <param name="i">The integer to write</param>
/// <param name="littleEndian">True for little endian, otherwise big endian</param>
public void WriteUInt32(uint i, bool littleEndian)
{
WriteBytes(GeneralUtils.SwapBytes(BitConverter.GetBytes(i), littleEndian));
}
/// <summary>
/// Write a 16bit integer to the stream
/// </summary>
/// <param name="s">The integer to write</param>
/// <param name="littleEndian">True for little endian, otherwise big endian</param>
public void WriteUInt16(ushort s, bool littleEndian)
{
WriteBytes(GeneralUtils.SwapBytes(BitConverter.GetBytes(s), littleEndian));
}
/// <summary>
/// Read a double from the stream with a specified endian
/// </summary>
/// <param name="littleEndian">True for little endian, false for big endian</param>
/// <returns>The double</returns>
public double ReadDouble(bool littleEndian)
{
byte[] data = ReadBytes(8);
return(BitConverter.ToDouble(GeneralUtils.SwapBytes(data, littleEndian), 0));
}
/// <summary>
/// Read a float from the stream with a specified endian
/// </summary>
/// <param name="littleEndian">True for little endian, false for big endian</param>
/// <returns>The float</returns>
public float ReadFloat(bool littleEndian)
{
byte[] data = ReadBytes(4);
return(BitConverter.ToSingle(GeneralUtils.SwapBytes(data, littleEndian), 0));
}
/// <summary>
/// Read a long from the stream with a specified endian
/// </summary>
/// <param name="littleEndian">True for little endian, false for big endian</param>
/// <returns>The read value</returns>
public long ReadInt64(bool littleEndian)
{
byte[] data = ReadBytes(8);
return(BitConverter.ToInt64(GeneralUtils.SwapBytes(data, littleEndian), 0));
}
/// <summary>
/// Localized constructor, passes a localizable string and the type this is applied to
/// </summary>
/// <param name="localizableCategory">The localizable category name</param>
/// <param name="assignedType">The type of resources (normally Properties.Resources)</param>
public LocalizedCategoryAttribute(string localizableCategory, Type assignedType)
: base(new ResourceManager(assignedType).GetString(localizableCategory, GeneralUtils.GetCurrentCulture()))
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="localizedDescription">The localized string name</param>
/// <param name="assignedType">The type of resources (normally Properties.Resources)</param>
public LocalizedDescriptionAttribute(string localizedDescription, Type assignedType)
: base(new ResourceManager(assignedType).GetString(localizedDescription, GeneralUtils.GetCurrentCulture()))
{
}
/// <summary>
/// Write a float with a specified endian
/// </summary>
/// <param name="f">The float to write</param>
/// <param name="littleEndian">True for little endian, otherwise big endian</param>
public void WriteFloat(float f, bool littleEndian)
{
WriteBytes(GeneralUtils.SwapBytes(BitConverter.GetBytes(f), littleEndian));
}
/// <summary>
/// Write a double with a specified endian
/// </summary>
/// <param name="d">The double to write</param>
/// <param name="littleEndian">True for little endian, otherwise big endian</param>
public void WriteDouble(double d, bool littleEndian)
{
WriteBytes(GeneralUtils.SwapBytes(BitConverter.GetBytes(d), littleEndian));
}
/// <summary>
/// Read an unsigned short from the stream with a specified endian
/// </summary>
/// <param name="littleEndian">True for little endian, false for big endian</param>
/// <returns>The read value</returns>
public ushort ReadUInt16(bool littleEndian)
{
byte[] data = ReadBytes(2);
return(BitConverter.ToUInt16(GeneralUtils.SwapBytes(data, littleEndian), 0));
}
