internal PcapInterface(PcapUnmanagedStructures.pcap_if pcapIf) {
Name = pcapIf.Name;
Description = pcapIf.Description;
Flags = pcapIf.Flags;
// retrieve addresses
Addresses = new List<PcapAddress>();
IntPtr address = pcapIf.Addresses;
while (address != IntPtr.Zero) {
//A sockaddr struct
PcapUnmanagedStructures.pcap_addr addr;
//Marshal memory pointer into a struct
addr = (PcapUnmanagedStructures.pcap_addr)Marshal.PtrToStructure(address,
typeof(PcapUnmanagedStructures.pcap_addr));
PcapAddress newAddress = new PcapAddress(addr);
Addresses.Add(newAddress);
// is this a hardware address?
// if so we should set our internal m_macAddress member variable
if ((newAddress.Addr != null) &&
(newAddress.Addr.type == Sockaddr.AddressTypes.HARDWARE)) {
if (m_macAddress == null) {
m_macAddress = newAddress;
} else {
throw new System.InvalidOperationException("found multiple hardware addresses, existing addr "
+ MacAddress.ToString() + ", new address " + newAddress.Addr.hardwareAddress.ToString());
}
}
address = addr.Next; // move to the next address
}
}
internal PcapAddress(PcapUnmanagedStructures.pcap_addr pcap_addr) {
if (pcap_addr.Addr != IntPtr.Zero)
Addr = new Sockaddr(pcap_addr.Addr);
if (pcap_addr.Netmask != IntPtr.Zero)
Netmask = new Sockaddr(pcap_addr.Netmask);
if (pcap_addr.Broadaddr != IntPtr.Zero)
Broadaddr = new Sockaddr(pcap_addr.Broadaddr);
if (pcap_addr.Dstaddr != IntPtr.Zero)
Dstaddr = new Sockaddr(pcap_addr.Dstaddr);
}
/// <summary>
/// Add a packet to this send queue.
/// </summary>
/// <param name="packet">The packet bytes to add</param>
/// <param name="pcapHdr">The pcap header of the packet</param>
/// <returns>True if success, else false</returns>
internal bool Add( byte[] packet, PcapUnmanagedStructures.pcap_pkthdr pcapHdr )
{
if(m_queue==IntPtr.Zero)
{
throw new PcapException("Can't add packet, this queue is disposed");
}
if(pcapHdr.caplen==0)
pcapHdr.caplen = (uint)packet.Length;//set the length in the header field
//Marshal packet
IntPtr pktPtr;
pktPtr = Marshal.AllocHGlobal(packet.Length);
Marshal.Copy(packet, 0, pktPtr, packet.Length);
//Marshal header
IntPtr hdrPtr;
hdrPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PcapUnmanagedStructures.pcap_pkthdr)));
Marshal.StructureToPtr(pcapHdr, hdrPtr, true);
int res = SafeNativeMethods.pcap_sendqueue_queue( m_queue, hdrPtr, pktPtr);
Marshal.FreeHGlobal(pktPtr);
Marshal.FreeHGlobal(hdrPtr);
return (res!=-1);
}
/// <summary>
/// Constructs a new Pcap Statistics strcuture
/// </summary>
/// <param name="pktHdr">Time value as PCAP_PKTHDR</param>
/// <param name="pktData">Statistics values as PCAP_PKTDATA</param>
internal PcapStatistics(PcapUnmanagedStructures.pcap_pkthdr pktHdr, PcapUnmanagedStructures.PCAP_PKTDATA pktData)
{
this.m_pktHdr = pktHdr;
this.m_pktData = pktData.bytes;
}
/// <summary>
/// Constructs a new PcapHeader
/// </summary>
/// <param name="m_pcap_pkthdr">The underlying pcap_pkthdr structure</param>
internal PcapHeader( PcapUnmanagedStructures.pcap_pkthdr m_pcap_pkthdr )
{
this.m_pcap_pkthdr = m_pcap_pkthdr;
}
/// <summary>
/// Constructs a new Pcap Statistics strcuture
/// </summary>
/// <param name="pktHdr">Time value as PCAP_PKTHDR</param>
/// <param name="pktData">Statistics values as PCAP_PKTDATA</param>
internal PcapStatisticsModePacket(PcapHeader pktHdr, PcapUnmanagedStructures.PCAP_PKTDATA pktData)
{
this.m_pktHdr = pktHdr;
this.m_pktData = pktData.bytes;
}
