public static BpfProgram Create(PcapHandle pcapHandle, string filter, int optimize = 1, uint netmask = 0) { var bpfProgram = TryCreate(pcapHandle, filter, optimize, netmask); if (bpfProgram == null) { throw new PcapException(PcapDevice.GetLastError(pcapHandle)); } return(bpfProgram); }
protected unsafe int ManagedTransmit(PcapDevice device, bool synchronized) { if (CurrentLength == 0) { return(0); } var position = 0; var hdrSize = PcapHeader.MemorySize; var sw = new Stopwatch(); fixed(byte *buf = buffer) { var bufPtr = new IntPtr(buf); var firstTimestamp = TimeSpan.FromTicks(PcapHeader.FromPointer(bufPtr).Date.Ticks); while (position < CurrentLength) { // Extract packet from buffer var header = PcapHeader.FromPointer(bufPtr + position); var pktSize = (int)header.CaptureLength; var p = new ReadOnlySpan <byte>(buffer, position + hdrSize, pktSize); if (synchronized) { var timestamp = TimeSpan.FromTicks(header.Date.Ticks); var remainingTime = timestamp.Subtract(firstTimestamp); while (sw.Elapsed < remainingTime) { // Wait for packet time System.Threading.Thread.Sleep((int)remainingTime.TotalMilliseconds / 2); } } // Send the packet int res; unsafe { fixed(byte *p_packet = p) { res = LibPcapSafeNativeMethods.pcap_sendpacket(device.PcapHandle, new IntPtr(p_packet), p.Length); } } // Start Stopwatch after sending first packet sw.Start(); if (res < 0) { break; } position += hdrSize + pktSize; } } return(position); }
protected unsafe int NativeTransmit(PcapDevice device, bool synchronized) { int sync = synchronized ? 1 : 0; fixed(byte *buf = buffer) { var pcap_queue = new pcap_send_queue { maxlen = (uint)buffer.Length, len = (uint)CurrentLength, ptrBuff = new IntPtr(buf) }; return(LibPcapSafeNativeMethods.pcap_sendqueue_transmit(device.PcapHandle, ref pcap_queue, sync)); } }
/// <summary> /// Send a queue of raw packets to the network. /// </summary> /// <param name="device"> /// The device on which to send the queue /// A <see cref="PcapDevice"/> /// </param> /// <param name="synchronized"> /// Should the timestamps be respected /// </param> /// <returns> /// A <see cref="int"/> /// </returns> public int Transmit(PcapDevice device, bool synchronized) { if (buffer == null) { throw new ObjectDisposedException(nameof(SendQueue)); } if (!device.Opened) { throw new DeviceNotReadyException("Can't transmit queue, the pcap device is closed"); } if (IsHardwareAccelerated) { return(NativeTransmit(device, synchronized)); } return(ManagedTransmit(device, synchronized)); }
protected unsafe int NativeTransmit(PcapDevice device, SendQueueTransmitModes transmitMode) { if (CurrentLength == 0) { // Npcap does not properly check for 0 packets queue // See https://github.com/nmap/npcap/issues/287 return(0); } int sync = (transmitMode == SendQueueTransmitModes.Synchronized) ? 1 : 0; fixed(byte *buf = buffer) { var pcap_queue = new pcap_send_queue { maxlen = (uint)buffer.Length, len = (uint)CurrentLength, ptrBuff = new IntPtr(buf) }; return(LibPcapSafeNativeMethods.pcap_sendqueue_transmit(device.PcapHandle, ref pcap_queue, sync)); } }
/// <summary> /// Constructor for a statistics mode event /// </summary> /// <param name="packet"> /// A <see cref="RawCapture"/> /// </param> /// <param name="device"> /// A <see cref="PcapDevice"/> /// </param> public StatisticsModeEventArgs(RawCapture packet, PcapDevice device) : base(packet, device) { }
/// <summary> /// Send a queue of raw packets to the network. /// </summary> /// <param name="device"> /// The device on which to send the queue /// A <see cref="PcapDevice"/> /// </param> /// <param name="synchronized"> /// Should the timestamps be respected /// </param> /// <returns> /// The number of bytes sent as an <see cref="int"/> /// </returns> public int Transmit(PcapDevice device, bool synchronized) { return(Transmit(device, (synchronized == true) ? SendQueueTransmitModes.Synchronized : SendQueueTransmitModes.Normal)); }