Packet32.h
上传用户:gzdtt123
上传日期:2022-01-26
资源大小:88k
文件大小:21k
开发平台:

Visual C++

  1. /*
  2.  * Copyright (c) 1999 - 2003
  3.  * NetGroup, Politecnico di Torino (Italy)
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  *
  10.  * 1. Redistributions of source code must retain the above copyright
  11.  * notice, this list of conditions and the following disclaimer.
  12.  * 2. Redistributions in binary form must reproduce the above copyright
  13.  * notice, this list of conditions and the following disclaimer in the
  14.  * documentation and/or other materials provided with the distribution.
  15.  * 3. Neither the name of the Politecnico di Torino nor the names of its
  16.  * contributors may be used to endorse or promote products derived from
  17.  * this software without specific prior written permission.
  18.  *
  19.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30.  *
  31.  */
  32. /** @ingroup packetapi
  33.  *  @{ 
  34.  */
  35. /** @defgroup packet32h Packet.dll definitions and data structures
  36.  *  Packet32.h contains the data structures and the definitions used by packet.dll.
  37.  *  The file is used both by the Win9x and the WinNTx versions of packet.dll, and can be included
  38.  *  by the applications that use the functions of this library
  39.  *  @{
  40.  */
  41. #ifndef __PACKET32
  42. #define __PACKET32
  43. #include <winsock2.h>
  44. #include "devioctl.h"
  45. #ifdef HAVE_DAG_API
  46. #include <dagc.h>
  47. #endif /* HAVE_DAG_API */
  48. // Working modes
  49. #define PACKET_MODE_CAPT 0x0 ///< Capture mode
  50. #define PACKET_MODE_STAT 0x1 ///< Statistical mode
  51. #define PACKET_MODE_MON 0x2 ///< Monitoring mode
  52. #define PACKET_MODE_DUMP 0x10 ///< Dump mode
  53. #define PACKET_MODE_STAT_DUMP MODE_DUMP | MODE_STAT ///< Statistical dump Mode
  54. // ioctls
  55. #define FILE_DEVICE_PROTOCOL        0x8000
  56. #define IOCTL_PROTOCOL_STATISTICS   CTL_CODE(FILE_DEVICE_PROTOCOL, 2 , METHOD_BUFFERED, FILE_ANY_ACCESS)
  57. #define IOCTL_PROTOCOL_RESET        CTL_CODE(FILE_DEVICE_PROTOCOL, 3 , METHOD_BUFFERED, FILE_ANY_ACCESS)
  58. #define IOCTL_PROTOCOL_READ         CTL_CODE(FILE_DEVICE_PROTOCOL, 4 , METHOD_BUFFERED, FILE_ANY_ACCESS)
  59. #define IOCTL_PROTOCOL_WRITE        CTL_CODE(FILE_DEVICE_PROTOCOL, 5 , METHOD_BUFFERED, FILE_ANY_ACCESS)
  60. #define IOCTL_PROTOCOL_MACNAME      CTL_CODE(FILE_DEVICE_PROTOCOL, 6 , METHOD_BUFFERED, FILE_ANY_ACCESS)
  61. #define IOCTL_OPEN                  CTL_CODE(FILE_DEVICE_PROTOCOL, 7 , METHOD_BUFFERED, FILE_ANY_ACCESS)
  62. #define IOCTL_CLOSE                 CTL_CODE(FILE_DEVICE_PROTOCOL, 8 , METHOD_BUFFERED, FILE_ANY_ACCESS)
  63. #define  pBIOCSETBUFFERSIZE 9592 ///< IOCTL code: set kernel buffer size.
  64. #define  pBIOCSETF 9030 ///< IOCTL code: set packet filtering program.
  65. #define  pBIOCGSTATS 9031 ///< IOCTL code: get the capture stats.
  66. #define  pBIOCSRTIMEOUT 7416 ///< IOCTL code: set the read timeout.
  67. #define  pBIOCSMODE 7412 ///< IOCTL code: set working mode.
  68. #define  pBIOCSWRITEREP 7413 ///< IOCTL code: set number of physical repetions of every packet written by the app.
  69. #define  pBIOCSMINTOCOPY 7414 ///< IOCTL code: set minimum amount of data in the kernel buffer that unlocks a read call.
  70. #define  pBIOCSETOID 2147483648 ///< IOCTL code: set an OID value.
  71. #define  pBIOCQUERYOID 2147483652 ///< IOCTL code: get an OID value.
  72. #define  pATTACHPROCESS 7117 ///< IOCTL code: attach a process to the driver. Used in Win9x only.
  73. #define  pDETACHPROCESS 7118 ///< IOCTL code: detach a process from the driver. Used in Win9x only.
  74. #define  pBIOCSETDUMPFILENAME 9029 ///< IOCTL code: set the name of a the file used by kernel dump mode.
  75. #define  pBIOCEVNAME 7415 ///< IOCTL code: get the name of the event that the driver signals when some data is present in the buffer.
  76. #define  pBIOCSENDPACKETSNOSYNC 9032 ///< IOCTL code: Send a buffer containing multiple packets to the network, ignoring the timestamps associated with the packets.
  77. #define  pBIOCSENDPACKETSSYNC 9033 ///< IOCTL code: Send a buffer containing multiple packets to the network, respecting the timestamps associated with the packets.
  78. #define  pBIOCSETDUMPLIMITS 9034 ///< IOCTL code: Set the dump file limits. See the PacketSetDumpLimits() function.
  79. #define  pBIOCISDUMPENDED 7411 ///< IOCTL code: Get the status of the kernel dump process. See the PacketIsDumpEnded() function.
  80. #define  pBIOCSTIMEZONE 7471 ///< IOCTL code: set time zone. Used in Win9x only.
  81. /// Alignment macro. Defines the alignment size.
  82. #define Packet_ALIGNMENT sizeof(int)
  83. /// Alignment macro. Rounds up to the next even multiple of Packet_ALIGNMENT. 
  84. #define Packet_WORDALIGN(x) (((x)+(Packet_ALIGNMENT-1))&~(Packet_ALIGNMENT-1))
  85. #define NdisMediumNull -1 // Custom linktype: NDIS doesn't provide an equivalent
  86. #define NdisMediumCHDLC -2 // Custom linktype: NDIS doesn't provide an equivalent
  87. #define NdisMediumPPPSerial -3 // Custom linktype: NDIS doesn't provide an equivalent
  88. /*!
  89.   brief Network type structure.
  90.   This structure is used by the PacketGetNetType() function to return information on the current adapter's type and speed.
  91. */
  92. typedef struct NetType
  93. {
  94. UINT LinkType; ///< The MAC of the current network adapter (see function PacketGetNetType() for more information)
  95. ULONGLONG LinkSpeed; ///< The speed of the network in bits per second
  96. }NetType;
  97. //some definitions stolen from libpcap
  98. #ifndef BPF_MAJOR_VERSION
  99. /*!
  100.   brief A BPF pseudo-assembly program.
  101.   The program will be injected in the kernel by the PacketSetBPF() function and applied to every incoming packet. 
  102. */
  103. struct bpf_program 
  104. {
  105. UINT bf_len; ///< Indicates the number of instructions of the program, i.e. the number of struct bpf_insn that will follow.
  106. struct bpf_insn *bf_insns; ///< A pointer to the first instruction of the program.
  107. };
  108. /*!
  109.   brief A single BPF pseudo-instruction.
  110.   bpf_insn contains a single instruction for the BPF register-machine. It is used to send a filter program to the driver.
  111. */
  112. struct bpf_insn 
  113. {
  114. USHORT code; ///< Instruction type and addressing mode.
  115. UCHAR  jt; ///< Jump if true
  116. UCHAR  jf; ///< Jump if false
  117. int k; ///< Generic field used for various purposes.
  118. };
  119. /*!
  120.   brief Structure that contains a couple of statistics values on the current capture.
  121.   It is used by packet.dll to return statistics about a capture session.
  122. */
  123. struct bpf_stat 
  124. {
  125. UINT bs_recv; ///< Number of packets that the driver received from the network adapter 
  126. ///< from the beginning of the current capture. This value includes the packets 
  127. ///< lost by the driver.
  128. UINT bs_drop; ///< number of packets that the driver lost from the beginning of a capture. 
  129. ///< Basically, a packet is lost when the the buffer of the driver is full. 
  130. ///< In this situation the packet cannot be stored and the driver rejects it.
  131. UINT ps_ifdrop; ///< drops by interface. XXX not yet supported
  132. UINT bs_capt; ///< number of packets that pass the filter, find place in the kernel buffer and
  133. ///< thus reach the application.
  134. };
  135. /*!
  136.   brief Packet header.
  137.   This structure defines the header associated with every packet delivered to the application.
  138. */
  139. struct bpf_hdr 
  140. {
  141. struct timeval bh_tstamp; ///< The timestamp associated with the captured packet. 
  142. ///< It is stored in a TimeVal structure.
  143. UINT bh_caplen; ///< Length of captured portion. The captured portion <b>can be different</b>
  144. ///< from the original packet, because it is possible (with a proper filter)
  145. ///< to instruct the driver to capture only a portion of the packets.
  146. UINT bh_datalen; ///< Original length of packet
  147. USHORT bh_hdrlen; ///< Length of bpf header (this struct plus alignment padding). In some cases,
  148. ///< a padding could be added between the end of this structure and the packet
  149. ///< data for performance reasons. This filed can be used to retrieve the actual data 
  150. ///< of the packet.
  151. };
  152. /*!
  153.   brief Dump packet header.
  154.   This structure defines the header associated with the packets in a buffer to be used with PacketSendPackets().
  155.   It is simpler than the bpf_hdr, because it corresponds to the header associated by WinPcap and libpcap to a
  156.   packet in a dump file. This makes straightforward sending WinPcap dump files to the network.
  157. */
  158. struct dump_bpf_hdr{
  159.     struct timeval ts; ///< Time stamp of the packet
  160.     UINT caplen; ///< Length of captured portion. The captured portion can smaller than the 
  161. ///< the original packet, because it is possible (with a proper filter) to 
  162. ///< instruct the driver to capture only a portion of the packets. 
  163.     UINT len; ///< Length of the original packet (off wire).
  164. };
  165. #endif
  166. #define        DOSNAMEPREFIX   TEXT("Packet_") ///< Prefix added to the adapters device names to create the WinPcap devices
  167. #define        MAX_LINK_NAME_LENGTH 64 //< Maximum length of the devices symbolic links
  168. #define        NMAX_PACKET 65535
  169. /*!
  170.   brief Addresses of a network adapter.
  171.   This structure is used by the PacketGetNetInfoEx() function to return the IP addresses associated with 
  172.   an adapter.
  173. */
  174. typedef struct npf_if_addr {
  175. struct sockaddr_storage IPAddress; ///< IP address.
  176. struct sockaddr_storage SubnetMask; ///< Netmask for that address.
  177. struct sockaddr_storage Broadcast; ///< Broadcast address.
  178. }npf_if_addr;
  179. #define ADAPTER_NAME_LENGTH 256 + 12 ///<  Maximum length for the name of an adapter. The value is the same used by the IP Helper API.
  180. #define ADAPTER_DESC_LENGTH 128 ///<  Maximum length for the description of an adapter. The value is the same used by the IP Helper API.
  181. #define MAX_MAC_ADDR_LENGTH 8 ///<  Maximum length for the link layer address of an adapter. The value is the same used by the IP Helper API.
  182. #define MAX_NETWORK_ADDRESSES 16 ///<  Maximum length for the link layer address of an adapter. The value is the same used by the IP Helper API.
  183. typedef struct WAN_ADAPTER_INT WAN_ADAPTER; ///< Describes an opened wan (dialup, VPN...) network adapter using the NetMon API
  184. typedef WAN_ADAPTER *PWAN_ADAPTER; ///< Describes an opened wan (dialup, VPN...) network adapter using the NetMon API
  185. #define INFO_FLAG_NDIS_ADAPTER 0 ///< Flag for ADAPTER_INFO: this is a traditional ndis adapter
  186. #define INFO_FLAG_NDISWAN_ADAPTER 1 ///< Flag for ADAPTER_INFO: this is a NdisWan adapter
  187. #define INFO_FLAG_DAG_CARD 2 ///< Flag for ADAPTER_INFO: this is a DAG card
  188. #define INFO_FLAG_DAG_FILE 6 ///< Flag for ADAPTER_INFO: this is a DAG file
  189. #define INFO_FLAG_DONT_EXPORT 8 ///< Flag for ADAPTER_INFO: when this flag is set, the adapter will not be listed or openend by winpcap. This allows to prevent exporting broken network adapters, like for example FireWire ones.
  190. /*!
  191.   brief Contains comprehensive information about a network adapter.
  192.   This structure is filled with all the accessory information that the user can need about an adapter installed
  193.   on his system.
  194. */
  195. typedef struct _ADAPTER_INFO  
  196. {
  197. struct _ADAPTER_INFO *Next; ///< Pointer to the next adapter in the list.
  198. CHAR Name[ADAPTER_NAME_LENGTH + 1]; ///< Name of the device representing the adapter.
  199. CHAR Description[ADAPTER_DESC_LENGTH + 1]; ///< Human understandable description of the adapter
  200. UINT MacAddressLen; ///< Length of the link layer address.
  201. UCHAR MacAddress[MAX_MAC_ADDR_LENGTH]; ///< Link layer address.
  202. NetType LinkLayer; ///< Physical characteristics of this adapter. This NetType structure contains the link type and the speed of the adapter.
  203. INT NNetworkAddresses; ///< Number of network layer addresses of this adapter.
  204. npf_if_addr *NetworkAddresses; ///< Pointer to an array of npf_if_addr, each of which specifies a network address of this adapter.
  205. UINT Flags; ///< Adapter's flags. Tell if this adapter must be treated in a different way, using the Netmon API or the dagc API.
  206. }
  207. ADAPTER_INFO, *PADAPTER_INFO;
  208. /*!
  209.   brief Describes an opened network adapter.
  210.   This structure is the most important for the functioning of packet.dll, but the great part of its fields
  211.   should be ignored by the user, since the library offers functions that avoid to cope with low-level parameters
  212. */
  213. typedef struct _ADAPTER  { 
  214. HANDLE hFile; ///< internal Handle to an open instance of the NPF driver.
  215. CHAR  SymbolicLink[MAX_LINK_NAME_LENGTH]; ///< internal A string containing the name of the network adapter currently opened.
  216. int NumWrites; ///< internal Number of times a packets written on this adapter will be repeated 
  217. ///< on the wire.
  218. HANDLE ReadEvent; ///< A notification event associated with the read calls on the adapter.
  219. ///< It can be passed to standard Win32 functions (like WaitForSingleObject
  220. ///< or WaitForMultipleObjects) to wait until the driver's buffer contains some 
  221. ///< data. It is particularly useful in GUI applications that need to wait 
  222. ///< concurrently on several events. In Windows NT/2000 the PacketSetMinToCopy()
  223. ///< function can be used to define the minimum amount of data in the kernel buffer
  224. ///< that will cause the event to be signalled. 
  225. UINT ReadTimeOut; ///< internal The amount of time after which a read on the driver will be released and 
  226. ///< ReadEvent will be signaled, also if no packets were captured
  227. CHAR Name[ADAPTER_NAME_LENGTH];
  228. PWAN_ADAPTER pWanAdapter;
  229. UINT Flags; ///< Adapter's flags. Tell if this adapter must be treated in a different way, using the Netmon API or the dagc API.
  230. #ifdef HAVE_DAG_API
  231. dagc_t *pDagCard; ///< Pointer to the dagc API adapter descriptor for this adapter
  232. PCHAR DagBuffer; ///< Pointer to the buffer with the packets that is received from the DAG card
  233. struct timeval DagReadTimeout; ///< Read timeout. The dagc API requires a timeval structure
  234. unsigned DagFcsLen; ///< Length of the frame check sequence attached to any packet by the card. Obtained from the registry
  235. DWORD DagFastProcess; ///< True if the user requests fast capture processing on this card. Higher level applications can use this value to provide a faster but possibly unprecise capture (for example, libpcap doesn't convert the timestamps).
  236. #endif // HAVE_DAG_API
  237. }  ADAPTER, *LPADAPTER;
  238. /*!
  239.   brief Structure that contains a group of packets coming from the driver.
  240.   This structure defines the header associated with every packet delivered to the application.
  241. */
  242. typedef struct _PACKET {  
  243. HANDLE       hEvent; ///< deprecated Still present for compatibility with old applications.
  244. OVERLAPPED   OverLapped; ///< deprecated Still present for compatibility with old applications.
  245. PVOID        Buffer; ///< Buffer with containing the packets. See the PacketReceivePacket() for
  246. ///< details about the organization of the data in this buffer
  247. UINT         Length; ///< Length of the buffer
  248. DWORD        ulBytesReceived; ///< Number of valid bytes present in the buffer, i.e. amount of data
  249. ///< received by the last call to PacketReceivePacket()
  250. BOOLEAN      bIoComplete; ///< deprecated Still present for compatibility with old applications.
  251. }  PACKET, *LPPACKET;
  252. /*!
  253.   brief Structure containing an OID request.
  254.   It is used by the PacketRequest() function to send an OID to the interface card driver. 
  255.   It can be used, for example, to retrieve the status of the error counters on the adapter, its MAC address, 
  256.   the list of the multicast groups defined on it, and so on.
  257. */
  258. struct _PACKET_OID_DATA {
  259.     ULONG Oid; ///< OID code. See the Microsoft DDK documentation or the file ntddndis.h
  260. ///< for a complete list of valid codes.
  261.     ULONG Length; ///< Length of the data field
  262.     UCHAR Data[1]; ///< variable-lenght field that contains the information passed to or received 
  263. ///< from the adapter.
  264. }; 
  265. typedef struct _PACKET_OID_DATA PACKET_OID_DATA, *PPACKET_OID_DATA;
  266. #if _DBG
  267. #define ODS(_x) OutputDebugString(TEXT(_x))
  268. #define ODSEx(_x, _y)
  269. #else
  270. #ifdef _DEBUG_TO_FILE
  271. /*! 
  272.   brief Macro to print a debug string. The behavior differs depending on the debug level
  273. */
  274. #define ODS(_x) { 
  275. FILE *f; 
  276. f = fopen("winpcap_debug.txt", "a"); 
  277. fprintf(f, "%s", _x); 
  278. fclose(f); 
  279. }
  280. /*! 
  281.   brief Macro to print debug data with the printf convention. The behavior differs depending on 
  282.   the debug level
  283. */
  284. #define ODSEx(_x, _y) { 
  285. FILE *f; 
  286. f = fopen("winpcap_debug.txt", "a"); 
  287. fprintf(f, _x, _y); 
  288. fclose(f); 
  289. }
  290. LONG PacketDumpRegistryKey(PCHAR KeyName, PCHAR FileName);
  291. #else
  292. #define ODS(_x)
  293. #define ODSEx(_x, _y)
  294. #endif
  295. #endif
  296. /* We load dinamically the dag library in order link it only when it's present on the system */
  297. #ifdef HAVE_DAG_API
  298. typedef dagc_t* (*dagc_open_handler)(const char *source, unsigned flags, char *ebuf); ///< prototype used to dynamically load the dag dll
  299. typedef void (*dagc_close_handler)(dagc_t *dagcfd); ///< prototype used to dynamically load the dag dll
  300. typedef int (*dagc_getlinktype_handler)(dagc_t *dagcfd); ///< prototype used to dynamically load the dag dll
  301. typedef int (*dagc_getlinkspeed_handler)(dagc_t *dagcfd); ///< prototype used to dynamically load the dag dll
  302. typedef int (*dagc_setsnaplen_handler)(dagc_t *dagcfd, unsigned snaplen); ///< prototype used to dynamically load the dag dll
  303. typedef unsigned (*dagc_getfcslen_handler)(dagc_t *dagcfd); ///< prototype used to dynamically load the dag dll
  304. typedef int (*dagc_receive_handler)(dagc_t *dagcfd, u_char **buffer, u_int *bufsize); ///< prototype used to dynamically load the dag dll
  305. typedef int (*dagc_stats_handler)(dagc_t *dagcfd, dagc_stats_t *ps); ///< prototype used to dynamically load the dag dll
  306. typedef int (*dagc_wait_handler)(dagc_t *dagcfd, struct timeval *timeout); ///< prototype used to dynamically load the dag dll
  307. typedef int (*dagc_finddevs_handler)(dagc_if_t **alldevsp, char *ebuf); ///< prototype used to dynamically load the dag dll
  308. typedef int (*dagc_freedevs_handler)(dagc_if_t *alldevsp); ///< prototype used to dynamically load the dag dll
  309. #endif // HAVE_DAG_API
  310. #ifdef __cplusplus
  311. extern "C" {
  312. #endif
  313. /**
  314.  *  @}
  315.  */
  316. // The following is used to check the adapter name in PacketOpenAdapterNPF and prevent 
  317. // opening of firewire adapters 
  318. #define FIREWIRE_SUBSTR L"1394"
  319. void PacketPopulateAdaptersInfoList();
  320. PWCHAR SChar2WChar(PCHAR string);
  321. PCHAR WChar2SChar(PWCHAR string);
  322. BOOL PacketGetFileVersion(LPTSTR FileName, PCHAR VersionBuff, UINT VersionBuffLen);
  323. PADAPTER_INFO PacketFindAdInfo(PCHAR AdapterName);
  324. BOOLEAN PacketUpdateAdInfo(PCHAR AdapterName);
  325. BOOLEAN IsFireWire(TCHAR *AdapterDesc);
  326. //---------------------------------------------------------------------------
  327. // EXPORTED FUNCTIONS
  328. //---------------------------------------------------------------------------
  329. PCHAR PacketGetVersion();
  330. PCHAR PacketGetDriverVersion();
  331. BOOLEAN PacketSetMinToCopy(LPADAPTER AdapterObject,int nbytes);
  332. BOOLEAN PacketSetNumWrites(LPADAPTER AdapterObject,int nwrites);
  333. BOOLEAN PacketSetMode(LPADAPTER AdapterObject,int mode);
  334. BOOLEAN PacketSetReadTimeout(LPADAPTER AdapterObject,int timeout);
  335. BOOLEAN PacketSetBpf(LPADAPTER AdapterObject,struct bpf_program *fp);
  336. INT PacketSetSnapLen(LPADAPTER AdapterObject,int snaplen);
  337. BOOLEAN PacketGetStats(LPADAPTER AdapterObject,struct bpf_stat *s);
  338. BOOLEAN PacketGetStatsEx(LPADAPTER AdapterObject,struct bpf_stat *s);
  339. BOOLEAN PacketSetBuff(LPADAPTER AdapterObject,int dim);
  340. BOOLEAN PacketGetNetType (LPADAPTER AdapterObject,NetType *type);
  341. LPADAPTER PacketOpenAdapter(PCHAR AdapterName);
  342. BOOLEAN PacketSendPacket(LPADAPTER AdapterObject,LPPACKET pPacket,BOOLEAN Sync);
  343. INT PacketSendPackets(LPADAPTER AdapterObject,PVOID PacketBuff,ULONG Size, BOOLEAN Sync);
  344. LPPACKET PacketAllocatePacket(void);
  345. VOID PacketInitPacket(LPPACKET lpPacket,PVOID  Buffer,UINT  Length);
  346. VOID PacketFreePacket(LPPACKET lpPacket);
  347. BOOLEAN PacketReceivePacket(LPADAPTER AdapterObject,LPPACKET lpPacket,BOOLEAN Sync);
  348. BOOLEAN PacketSetHwFilter(LPADAPTER AdapterObject,ULONG Filter);
  349. BOOLEAN PacketGetAdapterNames(PTSTR pStr,PULONG  BufferSize);
  350. BOOLEAN PacketGetNetInfoEx(PCHAR AdapterName, npf_if_addr* buffer, PLONG NEntries);
  351. BOOLEAN PacketRequest(LPADAPTER  AdapterObject,BOOLEAN Set,PPACKET_OID_DATA  OidData);
  352. HANDLE PacketGetReadEvent(LPADAPTER AdapterObject);
  353. BOOLEAN PacketSetDumpName(LPADAPTER AdapterObject, void *name, int len);
  354. BOOLEAN PacketSetDumpLimits(LPADAPTER AdapterObject, UINT maxfilesize, UINT maxnpacks);
  355. BOOLEAN PacketIsDumpEnded(LPADAPTER AdapterObject, BOOLEAN sync);
  356. BOOL PacketStopDriver();
  357. VOID PacketCloseAdapter(LPADAPTER lpAdapter);
  358. #ifdef __cplusplus
  359. }
  360. #endif 
  361. #endif //__PACKET32