/// <summary>
 /// Send a queue of raw packets to the network.
 /// </summary>
 /// <param name="p"></param>
 /// <param name="queue"></param>
 /// <param name="sync">determines if the send operation must be synchronized:
 /// if it is non-zero, the packets are sent respecting the timestamps,
 /// otherwise they are sent as fast as possible</param>
 /// <returns>The amount of bytes actually sent.
 /// If it is smaller than the size parameter, an error occurred
 /// during the send. The error can be caused by a driver/adapter
 /// problem or by an inconsistent/bogus send queue.</returns>
 internal static int pcap_sendqueue_transmit(IntPtr /*pcap_t * */ p, ref pcap_send_queue queue, int sync)
 {
     return(UseWindows
         ? Windows.pcap_sendqueue_transmit(p, ref queue, sync)
         : Unix.pcap_sendqueue_transmit(p, ref queue, sync));
 }
 internal static IntPtr /* pcap_t* */ pcap_open_offline(string /*const char* */ fname, StringBuilder /* char* */ errbuf)
 {
     return(UseWindows ? Windows.pcap_open_offline(fname, errbuf) : Unix.pcap_open_offline(fname, errbuf));
 }
 /// <summary>
 /// pcap_set_timeout() sets the packet buffer timeout that will be used on a capture handle when the handle is activated to to_ms, which is in units of milliseconds.
 /// </summary>
 /// <param name="p">A <see cref="IntPtr"/></param>
 /// <param name="to_ms">A <see cref="int"/></param>
 /// <returns>Returns 0 on success or PCAP_ERROR_ACTIVATED if called on a capture handle that has been activated.</returns>
 internal static int pcap_set_timeout(IntPtr /* pcap_t* */ p, int to_ms)
 {
     return(UseWindows ? Windows.pcap_set_timeout(p, to_ms) : Unix.pcap_set_timeout(p, to_ms));
 }
 /// <summary>
 /// Force a pcap_dispatch() or pcap_loop() call to return
 /// </summary>
 /// <param name="p"></param>
 /// <returns></returns>
 internal static int pcap_breakloop(IntPtr /* pcap_t_* */ p)
 {
     return(UseWindows ? Windows.pcap_breakloop(p) : Unix.pcap_breakloop(p));
 }
 /// <summary>
 /// Returns the snapshot length
 /// </summary>
 /// <param name="adapter">
 /// A <see cref="IntPtr"/>
 /// </param>
 /// <returns>
 /// A <see cref="int"/>
 /// </returns>
 internal static int pcap_snapshot(IntPtr /* pcap_t... */ adapter)
 {
     return(UseWindows ? Windows.pcap_snapshot(adapter) : Unix.pcap_snapshot(adapter));
 }
 /// <summary>
 /// pcap_set_snaplen() sets the snapshot length to be used on a capture handle when the handle is activated to snaplen.
 /// </summary>
 /// <param name="p">A <see cref="IntPtr"/></param>
 /// <param name="snaplen">A <see cref="int"/></param>
 /// <returns>Returns 0 on success or PCAP_ERROR_ACTIVATED if called on a capture handle that has been activated.</returns>
 internal static int pcap_set_snaplen(IntPtr /* pcap_t* */ p, int snaplen)
 {
     return(UseWindows ? Windows.pcap_set_snaplen(p, snaplen) : Unix.pcap_set_snaplen(p, snaplen));
 }
 /// <summary>
 /// Compile a packet filter, converting an high level filtering expression (see Filtering expression syntax) in a program that can be interpreted by the kernel-level filtering engine.
 /// </summary>
 internal static int pcap_compile(IntPtr /* pcap_t* */ adaptHandle, IntPtr /*bpf_program **/ fp, string /*char * */ str, int optimize, UInt32 netmask)
 {
     return(UseWindows ? Windows.pcap_compile(adaptHandle, fp, str, optimize, netmask) : Unix.pcap_compile(adaptHandle, fp, str, optimize, netmask));
 }
 /// <summary>
 /// Retrieves a selectable file descriptor
 /// </summary>
 /// <param name="adaptHandle">
 /// A <see cref="IntPtr"/>
 /// </param>
 /// <returns>
 /// A <see cref="int"/>
 /// </returns>
 internal static int pcap_get_selectable_fd(IntPtr /* pcap_t* */ adaptHandle)
 {
     return(UseWindows ? Windows.pcap_get_selectable_fd(adaptHandle) : Unix.pcap_get_selectable_fd(adaptHandle));
 }
 /// <summary>
 /// To avoid callback, this returns one packet at a time
 /// 为了避免回调,每次返回一个包
 /// </summary>
 internal static int pcap_next_ex(IntPtr /* pcap_t* */ adaptHandle, ref IntPtr /* **pkt_header */ header, ref IntPtr data)
 {
     return(UseWindows ? Windows.pcap_next_ex(adaptHandle, ref header, ref data) : Unix.pcap_next_ex(adaptHandle, ref header, ref data));
 }
 /// <summary>
 /// Send a raw packet.<br/>
 /// This function allows to send a raw packet to the network.
 /// The MAC CRC doesn't need to be included, because it is transparently calculated
 ///  and added by the network interface driver.
 /// </summary>
 /// <param name="adaptHandle">the interface that will be used to send the packet</param>
 /// <param name="data">contains the data of the packet to send (including the various protocol headers)</param>
 /// <param name="size">the dimension of the buffer pointed by data</param>
 /// <returns>0 if the packet is succesfully sent, -1 otherwise.</returns>
 internal static int pcap_sendpacket(IntPtr /* pcap_t* */ adaptHandle, IntPtr data, int size)
 {
     return(UseWindows ? Windows.pcap_sendpacket(adaptHandle, data, size) : Unix.pcap_sendpacket(adaptHandle, data, size));
 }
 /// <summary>Open a file to write packets. </summary>
 internal static IntPtr /*pcap_dumper_t * */ pcap_dump_open(IntPtr /*pcap_t * */ adaptHandle, string /*const char * */ fname)
 {
     return(UseWindows ? Windows.pcap_dump_open(adaptHandle, fname) : Unix.pcap_dump_open(adaptHandle, fname));
 }
 internal static int pcap_set_buffer_size(IntPtr /* pcap_t */ adapter, int bufferSizeInBytes)
 {
     return(UseWindows ? Windows.pcap_set_buffer_size(adapter, bufferSizeInBytes) : Unix.pcap_set_buffer_size(adapter, bufferSizeInBytes));
 }
 internal static IntPtr /* pcap_t* */ pcap_open_dead(int linktype, int snaplen)
 {
     return(UseWindows ? Windows.pcap_open_dead(linktype, snaplen) : Unix.pcap_open_dead(linktype, snaplen));
 }
 /// <summary>
 /// Get nonblocking mode, returns allways 0 for savefiles.
 /// </summary>
 internal static int pcap_getnonblock(IntPtr /* pcap_if_t** */ adaptHandle, StringBuilder /* char* */ errbuf)
 {
     return(UseWindows ? Windows.pcap_getnonblock(adaptHandle, errbuf) : Unix.pcap_getnonblock(adaptHandle, errbuf));
 }
 internal static int pcap_setfilter(IntPtr /* pcap_t* */ adaptHandle, IntPtr /*bpf_program **/ fp)
 {
     return(UseWindows ? Windows.pcap_setfilter(adaptHandle, fp) : Unix.pcap_setfilter(adaptHandle, fp));
 }
 /// <summary>
 /// Read packets until cnt packets are processed or an error occurs.
 /// </summary>
 internal static int pcap_dispatch(IntPtr /* pcap_t* */ adaptHandle, int count, pcap_handler callback, IntPtr ptr)
 {
     return(UseWindows ? Windows.pcap_dispatch(adaptHandle, count, callback, ptr) : Unix.pcap_dispatch(adaptHandle, count, callback, ptr));
 }
 /// <summary>
 /// Returns if a given filter applies to an offline packet.
 /// </summary>
 /// <returns></returns>
 internal static bool pcap_offline_filter(IntPtr /*bpf_program **/ prog, IntPtr /* pcap_pkthdr* */ header, IntPtr pkt_data)
 {
     return(UseWindows ? Windows.pcap_offline_filter(prog, header, pkt_data) : Unix.pcap_offline_filter(prog, header, pkt_data));
 }
 /// <summary>
 /// Fills in the pcap_stat structure passed to the function
 /// based on the pcap_t adapter
 /// </summary>
 /// <param name="adapter">
 /// A <see cref="IntPtr"/>
 /// </param>
 /// <param name="stat">
 /// A <see cref="IntPtr"/>
 /// </param>
 /// <returns>
 /// A <see cref="int"/>
 /// </returns>
 internal static int pcap_stats(IntPtr /* pcap_t* */ adapter, IntPtr /* struct pcap_stat* */ stat)
 {
     return(UseWindows ? Windows.pcap_stats(adapter, stat) : Unix.pcap_stats(adapter, stat));
 }
 /// <summary>
 /// return the error text pertaining to the last pcap library error.
 /// </summary>
 internal static IntPtr pcap_geterr(IntPtr /*pcap_t * */ adaptHandle)
 {
     return(UseWindows ? Windows.pcap_geterr(adaptHandle) : Unix.pcap_geterr(adaptHandle));
 }
 /// <summary>
 /// pcap_set_rfmon() sets whether monitor mode should be set on a capture handle when the handle is activated.
 /// If rfmon is non-zero, monitor mode will be set, otherwise it will not be set.
 /// </summary>
 /// <param name="p">A <see cref="IntPtr"/></param>
 /// <param name="rfmon">A <see cref="int"/></param>
 /// <returns>Returns 0 on success or PCAP_ERROR_ACTIVATED if called on a capture handle that has been activated.</returns>
 internal static int pcap_set_rfmon(IntPtr /* pcap_t* */ p, int rfmon)
 {
     return(UseWindows ? Windows.pcap_set_rfmon(p, rfmon) : Unix.pcap_set_rfmon(p, rfmon));
 }
 /// <summary>Returns a pointer to a string giving information about the version of the libpcap library being used; note that it contains more information than just a version number. </summary>
 internal static IntPtr /*const char **/  pcap_lib_version()
 {
     return(UseWindows ? Windows.pcap_lib_version() : Unix.pcap_lib_version());
 }
 /// <summary>
 /// pcap_set_promisc() sets whether promiscuous mode should be set on a capture handle when the handle is activated.
 /// If promisc is non-zero, promiscuous mode will be set, otherwise it will not be set.
 /// </summary>
 /// <param name="p">A <see cref="IntPtr"/></param>
 /// <param name="promisc">A <see cref="int"/></param>
 /// <returns>Returns 0 on success or PCAP_ERROR_ACTIVATED if called on a capture handle that has been activated.</returns>
 internal static int pcap_set_promisc(IntPtr /* pcap_t* */ p, int promisc)
 {
     return(UseWindows ? Windows.pcap_set_promisc(p, promisc) : Unix.pcap_set_promisc(p, promisc));
 }
 /// <summary>return the standard I/O stream of the 'savefile' opened by pcap_dump_open().</summary>
 internal static IntPtr /*FILE **/  pcap_dump_file(IntPtr /*pcap_dumper_t **/ p)
 {
     return(UseWindows ? Windows.pcap_dump_file(p) : Unix.pcap_dump_file(p));
 }
 /// <summary>
 /// pcap_activate() is used to activate a packet capture handle to look at packets on the network, with the options that were set on the handle being in effect.
 /// </summary>
 /// <param name="p">A <see cref="IntPtr"/></param>
 /// <returns>Returns 0 on success without warnings, a non-zero positive value on success with warnings, and a negative value on error. A non-zero return value indicates what warning or error condition occurred.</returns>
 internal static int pcap_activate(IntPtr /* pcap_t* */ p)
 {
     return(UseWindows ? Windows.pcap_activate(p) : Unix.pcap_activate(p));
 }
 /// <summary>Flushes the output buffer to the 'savefile', so that any packets
 /// written with pcap_dump() but not yet written to the 'savefile' will be written.
 /// -1 is returned on error, 0 on success. </summary>
 internal static int pcap_dump_flush(IntPtr /*pcap_dumper_t **/ p)
 {
     return(UseWindows ? Windows.pcap_dump_flush(p) : Unix.pcap_dump_flush(p));
 }
 /// <summary>
 /// Returns the file descriptor number from which captured packets are read,
 /// if a network device was opened with pcap_create() and pcap_activate() or
 /// with pcap_open_live(), or -1, if a ``savefile'' was opened with
 /// pcap_open_offline()
 /// Libpcap specific method
 /// </summary>
 /// <param name="adapter">
 /// A <see cref="IntPtr"/>
 /// </param>
 /// <returns>
 /// A <see cref="int"/>
 /// </returns>
 internal static int pcap_fileno(IntPtr /* pcap_t* p */ adapter)
 {
     return(UseWindows ? Windows.pcap_fileno(adapter) : Unix.pcap_fileno(adapter));
 }
 /// <summary> Return the link layer of an adapter. </summary>
 internal static int pcap_datalink(IntPtr /* pcap_t* */ adaptHandle)
 {
     return(UseWindows ? Windows.pcap_datalink(adaptHandle) : Unix.pcap_datalink(adaptHandle));
 }
 internal static int pcap_findalldevs(ref IntPtr /* pcap_if_t** */ alldevs, StringBuilder /* char* */ errbuf)
 {
     return(UseWindows ? Windows.pcap_findalldevs(ref alldevs, errbuf)
         : Unix.pcap_findalldevs(ref alldevs, errbuf));
 }
 internal static IntPtr /* pcap_t* */ pcap_create(string dev, StringBuilder errbuf)
 {
     return(UseWindows ? Windows.pcap_create(dev, errbuf) : Unix.pcap_create(dev, errbuf));
 }