/// <summary>
/// Add a packet to this send queue.
/// </summary>
/// <param name="packet">The packet to add</param>
/// <returns>True if success, else false</returns>
public bool Add(Kavprot.Packets.RawPacket packet)
{
var data = packet.Data;
var timeval = packet.Timeval;
var header = new PcapHeader(timeval.Seconds, timeval.MicroSeconds,
(uint)data.Length, (uint)data.Length);
return(this.AddInternal(data, header));
}
/// <summary>
/// Writes a packet to the pcap dump file associated with this device.
/// </summary>
/// <param name="p">The packet to write</param>
public void Dump(Kavprot.Packets.RawPacket p)
{
var data = p.Data;
var timeval = p.Timeval;
var header = new PcapHeader(timeval.Seconds, timeval.MicroSeconds,
(uint)data.Length, (uint)data.Length);
Dump(data, header);
}
/// <summary>
/// Notify the OnPacketArrival delegates about a newly captured packet
/// </summary>
/// <param name="p">
/// A <see cref="Kavprot.Packets.RawPacket"/>
/// </param>
protected void SendPacketArrivalEvent(Kavprot.Packets.RawPacket p)
{
var handler = OnPacketArrival;
if (handler != null)
{
//Invoke the packet arrival event
handler(this, new CaptureEventArgs(p, this));
}
}
/// <summary>
/// Notify the OnPacketArrival delegates about a newly captured packet
/// </summary>
/// <param name="p">
/// A <see cref="Kavprot.Packets.RawPacket"/>
/// </param>
new protected virtual void SendPacketArrivalEvent(Kavprot.Packets.RawPacket p)
{
if (Mode == CaptureMode.Packets)
{
base.SendPacketArrivalEvent(p);
}
else if (Mode == CaptureMode.Statistics)
{
var handler = OnPcapStatistics;
if (handler != null)
{
//Invoke the pcap statistics event
handler(this, new StatisticsModeEventArgs(p, this));
}
}
}
/// <summary>
/// Convert an unmanaged packet into a managed Kavprot.Packets.RawPacket
/// </summary>
/// <param name="header">
/// A <see cref="IntPtr"/>
/// </param>
/// <param name="data">
/// A <see cref="IntPtr"/>
/// </param>
/// <returns>
/// A <see cref="Kavprot.Packets.RawPacket"/>
/// </returns>
protected virtual Kavprot.Packets.RawPacket MarshalRawPacket(IntPtr /* pcap_pkthdr* */ header, IntPtr data)
{
Kavprot.Packets.RawPacket p;
// marshal the header
var pcapHeader = new PcapHeader(header);
var pkt_data = new byte[pcapHeader.CaptureLength];
Marshal.Copy(data, pkt_data, 0, (int)pcapHeader.CaptureLength);
p = new Kavprot.Packets.RawPacket(LinkType,
new Kavprot.Packets.PosixTimeval(pcapHeader.Seconds,
pcapHeader.MicroSeconds),
pkt_data);
return(p);
}
/// <summary>
/// Gets the next packet captured on this device
/// </summary>
/// <param name="p">
/// A <see cref="Kavprot.Packets.RawPacket"/>
/// </param>
/// <returns>
/// A <see cref="System.Int32"/> that contains the result code
/// </returns>
public virtual int GetNextPacket(out Kavprot.Packets.RawPacket p)
{
//Pointer to a packet info struct
IntPtr header = IntPtr.Zero;
//Pointer to a packet struct
IntPtr data = IntPtr.Zero;
int res = 0;
// using an invalid PcapHandle can result in an unmanaged segfault
// so check for that here
ThrowIfNotOpen("Device must be opened via Open() prior to use");
// If a user is calling GetNextPacket() when the background capture loop
// is also calling into libpcap then bad things can happen
//
// The bad behavior I (Chris M.) saw was that the background capture would keep running
// but no more packets were captured. Took two days to debug and regular users
// may hit the issue more often so check and report the issue here
if (Started)
{
throw new InvalidOperationDuringBackgroundCaptureException("GetNextPacket() invalid during background capture");
}
//Get a packet from winpcap
res = LibPcapSafeNativeMethods.pcap_next_ex(PcapHandle, ref header, ref data);
p = null;
if (res > 0)
{
//Marshal the packet
if ((header != IntPtr.Zero) && (data != IntPtr.Zero))
{
p = MarshalRawPacket(header, data);
}
}
return(res);
}
/// <summary>
/// Marshal a chunk of captured packets into a packet list
/// </summary>
/// <param name="packetsBuffer"></param>
/// <param name="bufferEnd"></param>
/// <param name="packets"></param>
protected virtual void MarshalPackets(IntPtr packetsBuffer, IntPtr bufferEnd,
out List <Kavprot.Packets.RawPacket> packets)
{
Kavprot.Packets.RawPacket p;
var linkType = LinkType;
packets = new List <Kavprot.Packets.RawPacket>();
IntPtr bufferPointer = packetsBuffer;
while (bufferPointer.ToInt64() < bufferEnd.ToInt64())
{
// marshal the header
var header = new AirPcapPacketHeader(bufferPointer);
// advance the pointer to the packet data and marshal that data
// into a managed buffer
bufferPointer = new IntPtr(bufferPointer.ToInt64() + header.Hdrlen);
var pkt_data = new byte[header.Caplen];
Marshal.Copy(bufferPointer, pkt_data, 0, (int)header.Caplen);
p = new Kavprot.Packets.RawPacket(linkType,
new Kavprot.Packets.PosixTimeval(header.TsSec,
header.TsUsec),
pkt_data);
packets.Add(p);
// advance the pointer by the size of the data
// and round up to the next word offset since each frame header is on a word boundry
int alignment = 4;
var pointer = bufferPointer.ToInt64() + header.Caplen;
pointer = AirPcapDevice.RoundUp(pointer, alignment);
bufferPointer = new IntPtr(pointer);
}
}
internal StatisticsModePacket(Kavprot.Packets.RawPacket p)
{
this.Timeval = p.Timeval;
this.m_pktData = p.Data;
}
/// <summary>
/// Constructor for a statistics mode event
/// </summary>
/// <param name="packet">
/// A <see cref="Kavprot.Packets.RawPacket"/>
/// </param>
/// <param name="device">
/// A <see cref="PcapDevice"/>
/// </param>
public StatisticsModeEventArgs(Kavprot.Packets.RawPacket packet, PcapDevice device)
: base(packet, device)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="packet">
/// A <see cref="Kavprot.Packets.RawPacket"/>
/// </param>
/// <param name="device">
/// A <see cref="ICaptureDevice"/>
/// </param>
public CaptureEventArgs(Kavprot.Packets.RawPacket packet, ICaptureDevice device)
{
this.packet = packet;
this.device = device;
}
