/// <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(byte[] p, PcapHeader h) { if (!Opened) { throw new PcapDeviceNotReadyException("Cannot dump packet, device is not opened"); } if (!DumpOpened) { throw new PcapDeviceNotReadyException("Cannot dump packet, dump file is not opened"); } //Marshal packet IntPtr pktPtr; pktPtr = Marshal.AllocHGlobal(p.Length); Marshal.Copy(p, 0, pktPtr, p.Length); //Marshal header IntPtr hdrPtr = h.MarshalToIntPtr(); SafeNativeMethods.pcap_dump(m_pcapDumpHandle, hdrPtr, pktPtr); Marshal.FreeHGlobal(pktPtr); Marshal.FreeHGlobal(hdrPtr); }
/// <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(byte[] p, PcapHeader h) { if (!Opened) { throw new PcapDeviceNotReadyException("Cannot dump packet, device is not opened"); } if (!DumpOpened) { throw new PcapDeviceNotReadyException("Cannot dump packet, dump file is not opened"); } //Marshal packet IntPtr pktPtr; pktPtr = Marshal.AllocHGlobal(p.Length); Marshal.Copy(p, 0, pktPtr, p.Length); //Marshal header IntPtr hdrPtr; hdrPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PcapUnmanagedStructures.pcap_pkthdr))); Marshal.StructureToPtr(h.m_pcap_pkthdr, hdrPtr, true); SafeNativeMethods.pcap_dump(m_pcapDumpHandle, hdrPtr, pktPtr); Marshal.FreeHGlobal(pktPtr); Marshal.FreeHGlobal(hdrPtr); }
/// <summary> /// Add a packet to this send queue. The PcapHeader defines the packet length. /// </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 AddInternal(byte[] packet, PcapHeader pcapHdr) { if (m_queue == IntPtr.Zero) { throw new PcapException("Can't add packet, this queue is disposed"); } // the header defines the size to send if (pcapHdr.CaptureLength > packet.Length) { string error = string.Format("pcapHdr.CaptureLength of {0} > packet.Length {1}", pcapHdr.CaptureLength, packet.Length); throw new System.InvalidOperationException(error); } //Marshal packet IntPtr pktPtr; pktPtr = Marshal.AllocHGlobal(packet.Length); Marshal.Copy(packet, 0, pktPtr, packet.Length); //Marshal header IntPtr hdrPtr = pcapHdr.MarshalToIntPtr(); int res = SafeNativeMethods.pcap_sendqueue_queue(m_queue, hdrPtr, pktPtr); Marshal.FreeHGlobal(pktPtr); Marshal.FreeHGlobal(hdrPtr); return(res != -1); }
/// <summary> /// Add a packet to this send queue. /// </summary> /// <param name="packet">The packet bytes to add</param> /// <returns>True if success, else false</returns> public bool Add(byte[] packet) { PcapHeader hdr = new PcapHeader(); hdr.CaptureLength = (uint)packet.Length; return(this.AddInternal(packet, hdr)); }
/// <summary> /// Add a packet to this send queue. /// </summary> /// <param name="packet">The packet to add</param> /// <param name="seconds">The 'seconds' part of the packet's timestamp</param> /// <param name="microseconds">The 'microseconds' part of the packet's timestamp</param> /// <returns>True if success, else false</returns> public bool Add(byte[] packet, int seconds, int microseconds) { PcapHeader header = new PcapHeader((ulong)seconds, (ulong)microseconds, (uint)packet.Length, (uint)packet.Length); return(this.Add(packet, header)); }
protected virtual RawPacket MarshalRawPacket(IntPtr /* pcap_pkthdr* */ header, IntPtr data) { RawPacket p; // marshal the header PcapHeader pcapHeader = new PcapHeader(header); byte[] pkt_data = new byte[pcapHeader.CaptureLength]; Marshal.Copy(data, pkt_data, 0, (int)pcapHeader.CaptureLength); p = new RawPacket(PcapDataLink, new Packets.Util.Timeval(pcapHeader.Seconds, pcapHeader.MicroSeconds), pkt_data); return(p); }
protected virtual Packet MarshalPacket(IntPtr header, IntPtr data) { Packet p; // marshal the header PcapHeader pcapHeader = new PcapHeader(header); byte[] pkt_data = new byte[pcapHeader.CaptureLength]; Marshal.Copy(data, pkt_data, 0, (int)pcapHeader.CaptureLength); p = Packets.PacketFactory.dataToPacket(PcapDataLink, pkt_data, new Packets.Util.Timeval(pcapHeader.Seconds, pcapHeader.MicroSeconds)); p.pcapHeader = pcapHeader; return(p); }
/// <summary> /// Add a packet to this send queue. /// </summary> /// <param name="packet">The packet bytes to add</param> /// <returns>True if success, else false</returns> public bool Add(byte[] packet) { PcapHeader hdr = new PcapHeader(); hdr.CaptureLength = (uint)packet.Length; return this.AddInternal(packet, hdr); }
internal PcapStatisticsModePacket(Packets.Packet p) { this.m_pktHdr = p.PcapHeader; this.m_pktData = p.Bytes; }
/// <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(byte[] p, PcapHeader h) { if(!Opened) throw new PcapDeviceNotReadyException("Cannot dump packet, device is not opened"); if(!DumpOpened) throw new PcapDeviceNotReadyException("Cannot dump packet, dump file is not opened"); //Marshal packet IntPtr pktPtr; pktPtr = Marshal.AllocHGlobal(p.Length); Marshal.Copy(p, 0, pktPtr, p.Length); //Marshal header IntPtr hdrPtr; hdrPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PcapUnmanagedStructures.pcap_pkthdr))); Marshal.StructureToPtr(h.m_pcap_pkthdr, hdrPtr, true); SafeNativeMethods.pcap_dump(m_pcapDumpHandle, hdrPtr, pktPtr); Marshal.FreeHGlobal(pktPtr); Marshal.FreeHGlobal(hdrPtr); }
/// <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, PcapHeader pcapHdr) { return(this.AddInternal(packet, pcapHdr)); }
protected virtual RawPacket MarshalRawPacket(IntPtr /* pcap_pkthdr* */ header, IntPtr data) { RawPacket p; // marshal the header PcapHeader pcapHeader = new PcapHeader(header); byte[] pkt_data = new byte[pcapHeader.CaptureLength]; Marshal.Copy(data, pkt_data, 0, (int)pcapHeader.CaptureLength); p = new RawPacket(PcapDataLink, new Packets.Util.Timeval(pcapHeader.Seconds, pcapHeader.MicroSeconds), pkt_data); return p; }
protected virtual Packet MarshalPacket(IntPtr header, IntPtr data) { Packet p; // marshal the header PcapHeader pcapHeader = new PcapHeader(header); byte[] pkt_data = new byte[pcapHeader.CaptureLength]; Marshal.Copy(data, pkt_data, 0, (int)pcapHeader.CaptureLength); p = Packets.PacketFactory.dataToPacket(PcapDataLink, pkt_data, new Packets.Util.Timeval(pcapHeader.Seconds, pcapHeader.MicroSeconds)); p.pcapHeader = pcapHeader; return p; }
/// <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(byte[] p, PcapHeader h) { if (!Opened) throw new PcapDeviceNotReadyException("Cannot dump packet, device is not opened"); if (!DumpOpened) throw new PcapDeviceNotReadyException("Cannot dump packet, dump file is not opened"); //Marshal packet IntPtr pktPtr; pktPtr = Marshal.AllocHGlobal(p.Length); Marshal.Copy(p, 0, pktPtr, p.Length); //Marshal header IntPtr hdrPtr = h.MarshalToIntPtr(); SafeNativeMethods.pcap_dump(m_pcapDumpHandle, hdrPtr, pktPtr); Marshal.FreeHGlobal(pktPtr); Marshal.FreeHGlobal(hdrPtr); }
/// <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; }
/// <summary> /// Add a packet to this send queue. /// </summary> /// <param name="packet">The packet to add</param> /// <param name="seconds">The 'seconds' part of the packet's timestamp</param> /// <param name="microseconds">The 'microseconds' part of the packet's timestamp</param> /// <returns>True if success, else false</returns> public bool Add(byte[] packet, int seconds, int microseconds) { PcapHeader header = new PcapHeader((ulong)seconds, (ulong)microseconds, (uint)packet.Length, (uint)packet.Length); return this.Add(packet, header); }
/// <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, PcapHeader pcapHdr) { return this.AddInternal(packet, pcapHdr); }
/// <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, PcapHeader pcapHdr ) { return this.Add( packet, pcapHdr.m_pcap_pkthdr); }
/// <summary> /// Add a packet to this send queue. The PcapHeader defines the packet length. /// </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 AddInternal(byte[] packet, PcapHeader pcapHdr) { if (m_queue == IntPtr.Zero) { throw new PcapException("Can't add packet, this queue is disposed"); } // the header defines the size to send if (pcapHdr.CaptureLength > packet.Length) { string error = string.Format("pcapHdr.CaptureLength of {0} > packet.Length {1}", pcapHdr.CaptureLength, packet.Length); throw new System.InvalidOperationException(error); } //Marshal packet IntPtr pktPtr; pktPtr = Marshal.AllocHGlobal(packet.Length); Marshal.Copy(packet, 0, pktPtr, packet.Length); //Marshal header IntPtr hdrPtr = pcapHdr.MarshalToIntPtr(); int res = SafeNativeMethods.pcap_sendqueue_queue(m_queue, hdrPtr, pktPtr); Marshal.FreeHGlobal(pktPtr); Marshal.FreeHGlobal(hdrPtr); return (res != -1); }
/// <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, PcapHeader pcapHdr) { return(this.Add(packet, pcapHdr.m_pcap_pkthdr)); }