games/semicongine: fuhtark_test/include/winapi/netmon.h comparison

comparison fuhtark_test/include/winapi/netmon.h @ 1500:91c8c3b7cbf0

add: futhark tests for generating vulkan api

author	sam <sam@basx.dev>
date	Wed, 26 Nov 2025 21:36:48 +0700
parents
children

comparison

equal deleted inserted replaced

-:1f58458b7ef7
+:91c8c3b7cbf0
+/**
+* This file has no copyright assigned and is placed in the Public Domain.
+* This file is part of the w64 mingw-runtime package.
+* No warranty is given; refer to the file DISCLAIMER within this package.
+*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#endif
+#include "rpc.h"
+#include "rpcndr.h"
+#ifndef __RPCNDR_H_VERSION__
+#error This stub requires an updated version of <rpcndr.h>
+#endif
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif
+#ifndef __netmon_h__
+#define __netmon_h__
+#ifndef __IDelaydC_FWD_DEFINED__
+#define __IDelaydC_FWD_DEFINED__
+typedef struct IDelaydC IDelaydC;
+#endif
+#ifndef __IRTC_FWD_DEFINED__
+#define __IRTC_FWD_DEFINED__
+typedef struct IRTC IRTC;
+#endif
+#ifndef __IStats_FWD_DEFINED__
+#define __IStats_FWD_DEFINED__
+typedef struct IStats IStats;
+#endif
+#include "unknwn.h"
+#ifdef __cplusplus
+extern "C"{
+#endif
+#ifndef __MIDL_user_allocate_free_DEFINED__
+#define __MIDL_user_allocate_free_DEFINED__
+void *__RPC_API MIDL_user_allocate(size_t);
+void __RPC_API MIDL_user_free(void *);
+#endif
+#include <winerror.h>
+#include <winerror.h>
+#pragma pack(1)
+#ifdef I_X86_
+#pragma pack(1)
+#else
+#pragma pack()
+#endif
+typedef BYTE *LPBYTE;
+typedef const void *HBLOB;
+#define MAC_TYPE_UNKNOWN (0)
+#define MAC_TYPE_ETHERNET (1)
+#define MAC_TYPE_TOKENRING (2)
+#define MAC_TYPE_FDDI (3)
+#define MAC_TYPE_ATM (4)
+#define MAC_TYPE_1394 (5)
+#define MACHINE_NAME_LENGTH (16)
+#define USER_NAME_LENGTH (32)
+#define ADAPTER_COMMENT_LENGTH (32)
+#define CONNECTION_FLAGS_WANT_CONVERSATION_STATS (0x1)
+typedef struct _TRANSMITSTATS {
+DWORD TotalFramesSent;
+DWORD TotalBytesSent;
+DWORD TotalTransmitErrors;
+} TRANSMITSTATS;
+typedef TRANSMITSTATS *LPTRANSMITSTATS;
+#define TRANSMITSTATS_SIZE (sizeof(TRANSMITSTATS))
+typedef struct _STATISTICS {
+__MINGW_EXTENSION __int64 TimeElapsed;
+DWORD TotalFramesCaptured;
+DWORD TotalBytesCaptured;
+DWORD TotalFramesFiltered;
+DWORD TotalBytesFiltered;
+DWORD TotalMulticastsFiltered;
+DWORD TotalBroadcastsFiltered;
+DWORD TotalFramesSeen;
+DWORD TotalBytesSeen;
+DWORD TotalMulticastsReceived;
+DWORD TotalBroadcastsReceived;
+DWORD TotalFramesDropped;
+DWORD TotalFramesDroppedFromBuffer;
+DWORD MacFramesReceived;
+DWORD MacCRCErrors;
+__MINGW_EXTENSION __int64 MacBytesReceivedEx;
+DWORD MacFramesDropped_NoBuffers;
+DWORD MacMulticastsReceived;
+DWORD MacBroadcastsReceived;
+DWORD MacFramesDropped_HwError;
+} STATISTICS;
+typedef STATISTICS *LPSTATISTICS;
+#define STATISTICS_SIZE (sizeof(STATISTICS))
+#pragma pack(push,1)
+#define MAX_NAME_SIZE (32)
+#define IP_ADDRESS_SIZE (4)
+#define MAC_ADDRESS_SIZE (6)
+#define IP6_ADDRESS_SIZE (16)
+#define MAX_ADDRESS_SIZE (16)
+#define ADDRESS_TYPE_ETHERNET (0)
+#define ADDRESS_TYPE_IP (1)
+#define ADDRESS_TYPE_IPX (2)
+#define ADDRESS_TYPE_TOKENRING (3)
+#define ADDRESS_TYPE_FDDI (4)
+#define ADDRESS_TYPE_XNS (5)
+#define ADDRESS_TYPE_ANY (6)
+#define ADDRESS_TYPE_ANY_GROUP (7)
+#define ADDRESS_TYPE_FIND_HIGHEST (8)
+#define ADDRESS_TYPE_VINES_IP (9)
+#define ADDRESS_TYPE_LOCAL_ONLY (10)
+#define ADDRESS_TYPE_ATM (11)
+#define ADDRESS_TYPE_1394 (12)
+#define ADDRESS_TYPE_IP6 (13)
+#define ADDRESSTYPE_FLAGS_NORMALIZE (0x1)
+#define ADDRESSTYPE_FLAGS_BIT_REVERSE (0x2)
+typedef struct _VINES_IP_ADDRESS {
+DWORD NetID;
+WORD SubnetID;
+} VINES_IP_ADDRESS;
+typedef VINES_IP_ADDRESS *LPVINES_IP_ADDRESS;
+#define VINES_IP_ADDRESS_SIZE (sizeof(VINES_IP_ADDRESS))
+typedef struct _IPX_ADDR {
+BYTE Subnet[4];
+BYTE Address[6];
+} IPX_ADDR;
+typedef IPX_ADDR *LPIPX_ADDR;
+#define IPX_ADDR_SIZE (sizeof(IPX_ADDR))
+typedef IPX_ADDR XNS_ADDRESS;
+typedef IPX_ADDR *LPXNS_ADDRESS;
+typedef struct _ETHERNET_SRC_ADDRESS {
+BYTE RoutingBit: 1;
+BYTE LocalBit: 1;
+BYTE Byte0: 6;
+BYTE Reserved[5];
+} ETHERNET_SRC_ADDRESS;
+typedef ETHERNET_SRC_ADDRESS *LPETHERNET_SRC_ADDRESS;
+typedef struct _ETHERNET_DST_ADDRESS {
+BYTE GroupBit: 1;
+BYTE AdminBit: 1;
+BYTE Byte0: 6;
+BYTE Reserved[5];
+} ETHERNET_DST_ADDRESS;
+typedef ETHERNET_DST_ADDRESS *LPETHERNET_DST_ADDRESS;
+typedef ETHERNET_SRC_ADDRESS FDDI_SRC_ADDRESS;
+typedef ETHERNET_DST_ADDRESS FDDI_DST_ADDRESS;
+typedef FDDI_SRC_ADDRESS *LPFDDI_SRC_ADDRESS;
+typedef FDDI_DST_ADDRESS *LPFDDI_DST_ADDRESS;
+typedef struct _TOKENRING_SRC_ADDRESS {
+BYTE Byte0: 6;
+BYTE LocalBit: 1;
+BYTE RoutingBit: 1;
+BYTE Byte1;
+BYTE Byte2: 7;
+BYTE Functional: 1;
+BYTE Reserved[3];
+} TOKENRING_SRC_ADDRESS;
+typedef TOKENRING_SRC_ADDRESS *LPTOKENRING_SRC_ADDRESS;
+typedef struct _TOKENRING_DST_ADDRESS {
+BYTE Byte0: 6;
+BYTE AdminBit: 1;
+BYTE GroupBit: 1;
+BYTE Reserved[5];
+} TOKENRING_DST_ADDRESS;
+typedef TOKENRING_DST_ADDRESS *LPTOKENRING_DST_ADDRESS;
+typedef struct _ADDRESS2 {
+DWORD Type;
+__MINGW_EXTENSION union {
+BYTE MACAddress[MAC_ADDRESS_SIZE];
+BYTE IPAddress[IP_ADDRESS_SIZE];
+BYTE IP6Address[IP6_ADDRESS_SIZE];
+BYTE IPXRawAddress[IPX_ADDR_SIZE];
+IPX_ADDR IPXAddress;
+BYTE VinesIPRawAddress[VINES_IP_ADDRESS_SIZE];
+VINES_IP_ADDRESS VinesIPAddress;
+ETHERNET_SRC_ADDRESS EthernetSrcAddress;
+ETHERNET_DST_ADDRESS EthernetDstAddress;
+TOKENRING_SRC_ADDRESS TokenringSrcAddress;
+TOKENRING_DST_ADDRESS TokenringDstAddress;
+FDDI_SRC_ADDRESS FddiSrcAddress;
+FDDI_DST_ADDRESS FddiDstAddress;
+};
+WORD Flags;
+} ADDRESS2;
+typedef ADDRESS2 *LPADDRESS2;
+#define ADDRESS2_SIZE sizeof(ADDRESS2)
+#pragma pack(pop)
+#define ADDRESS_FLAGS_MATCH_DST (0x1)
+#define ADDRESS_FLAGS_MATCH_SRC (0x2)
+#define ADDRESS_FLAGS_EXCLUDE (0x4)
+#define ADDRESS_FLAGS_DST_GROUP_ADDR (0x8)
+#define ADDRESS_FLAGS_MATCH_BOTH (0x3)
+typedef struct _ADDRESSPAIR2 {
+WORD AddressFlags;
+WORD NalReserved;
+ADDRESS2 DstAddress;
+ADDRESS2 SrcAddress;
+} ADDRESSPAIR2;
+typedef ADDRESSPAIR2 *LPADDRESSPAIR2;
+#define ADDRESSPAIR2_SIZE sizeof(ADDRESSPAIR2)
+#define MAX_ADDRESS_PAIRS (8)
+typedef struct _ADDRESSTABLE2 {
+DWORD nAddressPairs;
+DWORD nNonMacAddressPairs;
+ADDRESSPAIR2 AddressPair[MAX_ADDRESS_PAIRS];
+} ADDRESSTABLE2;
+typedef ADDRESSTABLE2 *LPADDRESSTABLE2;
+#define ADDRESSTABLE2_SIZE sizeof(ADDRESSTABLE2)
+#define NETWORKINFO_FLAGS_PMODE_NOT_SUPPORTED (0x1)
+#define NETWORKINFO_FLAGS_REMOTE_NAL (0x4)
+#define NETWORKINFO_FLAGS_REMOTE_NAL_CONNECTED (0x8)
+#define NETWORKINFO_FLAGS_REMOTE_CARD (0x10)
+#define NETWORKINFO_FLAGS_RAS (0x20)
+#define NETWORKINFO_RESERVED_FIELD_SIZE (FIELD_OFFSET(ADDRESS2,IPXAddress) + sizeof(IPX_ADDR))
+typedef struct _NETWORKINFO {
+BYTE PermanentAddr[6];
+BYTE CurrentAddr[6];
+BYTE Reserved[NETWORKINFO_RESERVED_FIELD_SIZE];
+DWORD LinkSpeed;
+DWORD MacType;
+DWORD MaxFrameSize;
+DWORD Flags;
+DWORD TimestampScaleFactor;
+BYTE NodeName[32];
+WINBOOL PModeSupported;
+BYTE Comment[ADAPTER_COMMENT_LENGTH];
+} NETWORKINFO;
+typedef NETWORKINFO *LPNETWORKINFO;
+#define NETWORKINFO_SIZE sizeof(NETWORKINFO)
+#define MINIMUM_FRAME_SIZE (32)
+#define MAX_PATTERN_LENGTH (16)
+#define PATTERN_MATCH_FLAGS_NOT (0x1)
+#define PATTERN_MATCH_FLAGS_RESERVED_1 (0x2)
+#define PATTERN_MATCH_FLAGS_PORT_SPECIFIED (0x8)
+#define OFFSET_BASIS_RELATIVE_TO_FRAME (0)
+#define OFFSET_BASIS_RELATIVE_TO_EFFECTIVE_PROTOCOL (1)
+#define OFFSET_BASIS_RELATIVE_TO_IPX (2)
+#define OFFSET_BASIS_RELATIVE_TO_IP (3)
+#define OFFSET_BASIS_RELATIVE_TO_IP6 (4)
+typedef union __MIDL___MIDL_itf_netmon_0000_0001 {
+BYTE NextHeader;
+BYTE IPPort;
+WORD ByteSwappedIPXPort;
+} GENERIC_PORT;
+typedef struct _PATTERNMATCH {
+DWORD Flags;
+BYTE OffsetBasis;
+GENERIC_PORT Port;
+WORD Offset;
+WORD Length;
+BYTE PatternToMatch[16];
+} PATTERNMATCH;
+typedef PATTERNMATCH *LPPATTERNMATCH;
+#define PATTERNMATCH_SIZE (sizeof(PATTERNMATCH))
+#define MAX_PATTERNS (4)
+typedef struct _ANDEXP {
+DWORD nPatternMatches;
+PATTERNMATCH PatternMatch[4];
+} ANDEXP;
+typedef ANDEXP *LPANDEXP;
+#define ANDEXP_SIZE (sizeof(ANDEXP))
+typedef struct _EXPRESSION {
+DWORD nAndExps;
+ANDEXP AndExp[4];
+} EXPRESSION;
+typedef EXPRESSION *LPEXPRESSION;
+#define EXPRESSION_SIZE (sizeof(EXPRESSION))
+#define TRIGGER_TYPE_PATTERN_MATCH (1)
+#define TRIGGER_TYPE_BUFFER_CONTENT (2)
+#define TRIGGER_TYPE_PATTERN_MATCH_THEN_BUFFER_CONTENT (3)
+#define TRIGGER_TYPE_BUFFER_CONTENT_THEN_PATTERN_MATCH (4)
+#define TRIGGER_FLAGS_FRAME_RELATIVE (0)
+#define TRIGGER_FLAGS_DATA_RELATIVE (0x1)
+#define TRIGGER_ACTION_NOTIFY (0)
+#define TRIGGER_ACTION_STOP (0x2)
+#define TRIGGER_ACTION_PAUSE (0x3)
+#define TRIGGER_BUFFER_FULL_25_PERCENT (0)
+#define TRIGGER_BUFFER_FULL_50_PERCENT (1)
+#define TRIGGER_BUFFER_FULL_75_PERCENT (2)
+#define TRIGGER_BUFFER_FULL_100_PERCENT (3)
+typedef struct _TRIGGER {
+WINBOOL TriggerActive;
+BYTE TriggerType;
+BYTE TriggerAction;
+DWORD TriggerFlags;
+PATTERNMATCH TriggerPatternMatch;
+DWORD TriggerBufferSize;
+DWORD TriggerReserved;
+char TriggerCommandLine[260];
+} TRIGGER;
+typedef TRIGGER *LPTRIGGER;
+#define TRIGGER_SIZE (sizeof(TRIGGER))
+#define CAPTUREFILTER_FLAGS_INCLUDE_ALL_SAPS (0x1)
+#define CAPTUREFILTER_FLAGS_INCLUDE_ALL_ETYPES (0x2)
+#define CAPTUREFILTER_FLAGS_TRIGGER (0x4)
+#define CAPTUREFILTER_FLAGS_LOCAL_ONLY (0x8)
+#define CAPTUREFILTER_FLAGS_DISCARD_COMMENTS (0x10)
+#define CAPTUREFILTER_FLAGS_KEEP_RAW (0x20)
+#define CAPTUREFILTER_FLAGS_INCLUDE_ALL (0x3)
+#define BUFFER_FULL_25_PERCENT (0)
+#define BUFFER_FULL_50_PERCENT (1)
+#define BUFFER_FULL_75_PERCENT (2)
+#define BUFFER_FULL_100_PERCENT (3)
+typedef struct _CAPTUREFILTER {
+DWORD FilterFlags;
+LPBYTE lpSapTable;
+LPWORD lpEtypeTable;
+WORD nSaps;
+WORD nEtypes;
+LPADDRESSTABLE2 AddressTable;
+EXPRESSION FilterExpression;
+TRIGGER Trigger;
+DWORD nFrameBytesToCopy;
+DWORD Reserved;
+} CAPTUREFILTER;
+typedef CAPTUREFILTER *LPCAPTUREFILTER;
+#define CAPTUREFILTER_SIZE sizeof(CAPTUREFILTER)
+typedef struct _FRAME {
+__MINGW_EXTENSION __int64 TimeStamp;
+DWORD FrameLength;
+DWORD nBytesAvail;
+BYTE MacFrame[1];
+} FRAME;
+typedef FRAME *LPFRAME;
+typedef FRAME UNALIGNED *ULPFRAME;
+#define FRAME_SIZE (sizeof(FRAME))
+#define LOW_PROTOCOL_IPX (OFFSET_BASIS_RELATIVE_TO_IPX)
+#define LOW_PROTOCOL_IP (OFFSET_BASIS_RELATIVE_TO_IP)
+#define LOW_PROTOCOL_IP6 (OFFSET_BASIS_RELATIVE_TO_IP6)
+#define LOW_PROTOCOL_UNKNOWN ((BYTE)-1)
+typedef struct _FRAME_DESCRIPTOR {
+LPBYTE FramePointer;
+__MINGW_EXTENSION __int64 TimeStamp;
+DWORD FrameLength;
+DWORD nBytesAvail;
+WORD Etype;
+BYTE Sap;
+BYTE LowProtocol;
+WORD LowProtocolOffset;
+union {
+WORD Reserved;
+BYTE IPPort;
+WORD ByteSwappedIPXPort;
+} HighPort;
+WORD HighProtocolOffset;
+} FRAME_DESCRIPTOR;
+typedef FRAME_DESCRIPTOR *LPFRAME_DESCRIPTOR;
+#define FRAME_DESCRIPTOR_SIZE (sizeof(FRAME_DESCRIPTOR))
+typedef struct _FRAMETABLE {
+DWORD FrameTableLength;
+DWORD StartIndex;
+DWORD EndIndex;
+DWORD FrameCount;
+FRAME_DESCRIPTOR Frames[1];
+} FRAMETABLE;
+typedef FRAMETABLE *LPFRAMETABLE;
+#define STATIONSTATS_FLAGS_INITIALIZED (0x1)
+#define STATIONSTATS_FLAGS_EVENTPOSTED (0x2)
+#define STATIONSTATS_POOL_SIZE (100)
+typedef struct _STATIONSTATS {
+DWORD NextStationStats;
+DWORD SessionPartnerList;
+DWORD Flags;
+BYTE StationAddress[6];
+WORD Pad;
+DWORD TotalPacketsReceived;
+DWORD TotalDirectedPacketsSent;
+DWORD TotalBroadcastPacketsSent;
+DWORD TotalMulticastPacketsSent;
+DWORD TotalBytesReceived;
+DWORD TotalBytesSent;
+} STATIONSTATS;
+typedef STATIONSTATS *LPSTATIONSTATS;
+#define STATIONSTATS_SIZE (sizeof(STATIONSTATS))
+#define SESSION_FLAGS_INITIALIZED (0x1)
+#define SESSION_FLAGS_EVENTPOSTED (0x2)
+#define SESSION_POOL_SIZE (100)
+typedef struct _SESSIONSTATS {
+DWORD NextSession;
+DWORD StationOwner;
+DWORD StationPartner;
+DWORD Flags;
+DWORD TotalPacketsSent;
+} SESSIONSTATS;
+typedef SESSIONSTATS *LPSESSIONSTATS;
+#define SESSIONSTATS_SIZE (sizeof(SESSIONSTATS))
+#pragma pack(push,1)
+typedef struct _STATIONQUERY {
+DWORD Flags;
+BYTE BCDVerMinor;
+BYTE BCDVerMajor;
+DWORD LicenseNumber;
+BYTE MachineName[16];
+BYTE UserName[32];
+BYTE Reserved[32];
+BYTE AdapterAddress[6];
+WCHAR WMachineName[16];
+WCHAR WUserName[32];
+} STATIONQUERY;
+typedef STATIONQUERY *LPSTATIONQUERY;
+#define STATIONQUERY_SIZE (sizeof(STATIONQUERY))
+#pragma pack(pop)
+typedef struct _QUERYTABLE {
+DWORD nStationQueries;
+STATIONQUERY StationQuery[1];
+} QUERYTABLE;
+typedef QUERYTABLE *LPQUERYTABLE;
+#define QUERYTABLE_SIZE (sizeof(QUERYTABLE))
+typedef struct _LINK *LPLINK;
+typedef struct _LINK {
+LPLINK PrevLink;
+LPLINK NextLink;
+} LINK;
+#pragma pack(push,1)
+#define MAX_SECURITY_BREACH_REASON_SIZE (100)
+#define MAX_SIGNATURE_LENGTH (128)
+#define MAX_USER_NAME_LENGTH (256)
+typedef struct _SECURITY_PERMISSION_RESPONSE {
+UINT Version;
+DWORD RandomNumber;
+BYTE MachineName[16];
+BYTE Address[6];
+BYTE UserName[256];
+BYTE Reason[100];
+DWORD SignatureLength;
+BYTE Signature[128];
+} SECURITY_PERMISSION_RESPONSE;
+typedef SECURITY_PERMISSION_RESPONSE *LPSECURITY_PERMISSION_RESPONSE;
+typedef SECURITY_PERMISSION_RESPONSE UNALIGNED *ULPSECURITY_PERMISSION_RESPONSE;
+#define SECURITY_PERMISSION_RESPONSE_SIZE (sizeof(SECURITY_PERMISSION_RESPONSE))
+#pragma pack(pop)
+#define UPDATE_EVENT_TERMINATE_THREAD (0)
+#define UPDATE_EVENT_NETWORK_STATUS (0x1)
+#define UPDATE_EVENT_RTC_INTERVAL_ELAPSED (0x2)
+#define UPDATE_EVENT_RTC_FRAME_TABLE_FULL (0x3)
+#define UPDATE_EVENT_RTC_BUFFER_FULL (0x4)
+#define UPDATE_EVENT_TRIGGER_BUFFER_CONTENT (0x5)
+#define UPDATE_EVENT_TRIGGER_PATTERN_MATCH (0x6)
+#define UPDATE_EVENT_TRIGGER_BUFFER_PATTERN (0x7)
+#define UPDATE_EVENT_TRIGGER_PATTERN_BUFFER (0x8)
+#define UPDATE_EVENT_TRANSMIT_STATUS (0x9)
+#define UPDATE_EVENT_SECURITY_BREACH (0xa)
+#define UPDATE_EVENT_REMOTE_FAILURE (0xb)
+#define UPDATE_ACTION_TERMINATE_THREAD (0)
+#define UPDATE_ACTION_NOTIFY (0x1)
+#define UPDATE_ACTION_STOP_CAPTURE (0x2)
+#define UPDATE_ACTION_PAUSE_CAPTURE (0x3)
+#define UPDATE_ACTION_RTC_BUFFER_SWITCH (0x4)
+__MINGW_EXTENSION typedef struct _UPDATE_EVENT {
+USHORT Event;
+DWORD Action;
+DWORD Status;
+DWORD Value;
+__MINGW_EXTENSION __int64 TimeStamp;
+DWORD_PTR lpUserContext;
+DWORD_PTR lpReserved;
+UINT FramesDropped;
+__MINGW_EXTENSION union {
+DWORD Reserved;
+LPFRAMETABLE lpFrameTable;
+DWORD_PTR lpPacketQueue;
+SECURITY_PERMISSION_RESPONSE SecurityResponse;
+};
+LPSTATISTICS lpFinalStats;
+} UPDATE_EVENT;
+typedef UPDATE_EVENT *PUPDATE_EVENT;
+typedef DWORD (WINAPI *LPNETWORKCALLBACKPROC)(UPDATE_EVENT);
+typedef struct _NETWORKSTATUS {
+DWORD State;
+DWORD Flags;
+} NETWORKSTATUS;
+typedef NETWORKSTATUS *LPNETWORKSTATUS;
+#define NETWORKSTATUS_SIZE (sizeof(NETWORKSTATUS))
+#define NETWORKSTATUS_STATE_VOID (0)
+#define NETWORKSTATUS_STATE_INIT (1)
+#define NETWORKSTATUS_STATE_CAPTURING (2)
+#define NETWORKSTATUS_STATE_PAUSED (3)
+#define NETWORKSTATUS_FLAGS_TRIGGER_PENDING (0x1)
+#define MAKE_WORD(l,h) (((WORD) (l)) | (((WORD) (h)) << 8))
+#define MAKE_LONG(l,h) (((DWORD) (l)) | (((DWORD) (h)) << 16L))
+#define MAKE_SIG(a,b,c,d) MAKE_LONG(MAKE_WORD(a,b),MAKE_WORD(c,d))
+#define MAX_SESSIONS (100)
+#define MAX_STATIONS (100)
+typedef struct _STATISTICSPARAM {
+DWORD StatisticsSize;
+STATISTICS Statistics;
+DWORD StatisticsTableEntries;
+STATIONSTATS StatisticsTable[100];
+DWORD SessionTableEntries;
+SESSIONSTATS SessionTable[100];
+} STATISTICSPARAM;
+typedef STATISTICSPARAM *LPSTATISTICSPARAM;
+#define STATISTICSPARAM_SIZE (sizeof(STATISTICSPARAM))
+#pragma pack(push,1)
+#define CAPTUREFILE_VERSION_MAJOR (2)
+#define CAPTUREFILE_VERSION_MINOR (0)
+#define MakeVersion(Major,Minor) ((DWORD) MAKEWORD(Minor,Major))
+#define GetCurrentVersion() MakeVersion(CAPTUREFILE_VERSION_MAJOR,CAPTUREFILE_VERSION_MINOR)
+#define NETMON_1_0_CAPTUREFILE_SIGNATURE MAKE_IDENTIFIER('R','T','S','S')
+#define NETMON_2_0_CAPTUREFILE_SIGNATURE MAKE_IDENTIFIER('G','M','B','U')
+typedef struct _CAPTUREFILE_HEADER_VALUES {
+DWORD Signature;
+BYTE BCDVerMinor;
+BYTE BCDVerMajor;
+WORD MacType;
+SYSTEMTIME TimeStamp;
+DWORD FrameTableOffset;
+DWORD FrameTableLength;
+DWORD UserDataOffset;
+DWORD UserDataLength;
+DWORD CommentDataOffset;
+DWORD CommentDataLength;
+DWORD StatisticsOffset;
+DWORD StatisticsLength;
+DWORD NetworkInfoOffset;
+DWORD NetworkInfoLength;
+DWORD ConversationStatsOffset;
+DWORD ConversationStatsLength;
+} CAPTUREFILE_HEADER_VALUES;
+typedef CAPTUREFILE_HEADER_VALUES *LPCAPTUREFILE_HEADER_VALUES;
+#define CAPTUREFILE_HEADER_VALUES_SIZE (sizeof(CAPTUREFILE_HEADER_VALUES))
+#pragma pack(pop)
+#pragma pack(push,1)
+typedef struct _CAPTUREFILE_HEADER {
+__MINGW_EXTENSION union {
+CAPTUREFILE_HEADER_VALUES ActualHeader;
+BYTE Buffer[72];
+};
+BYTE Reserved[56];
+} CAPTUREFILE_HEADER;
+typedef CAPTUREFILE_HEADER *LPCAPTUREFILE_HEADER;
+#define CAPTUREFILE_HEADER_SIZE (sizeof(CAPTUREFILE_HEADER))
+#pragma pack(pop)
+#pragma pack(push,1)
+typedef struct _EFRAMEHDR {
+BYTE SrcAddress[6];
+BYTE DstAddress[6];
+WORD Length;
+BYTE DSAP;
+BYTE SSAP;
+BYTE Control;
+BYTE ProtocolID[3];
+WORD EtherType;
+} EFRAMEHDR;
+typedef struct _TRFRAMEHDR {
+BYTE AC;
+BYTE FC;
+BYTE SrcAddress[6];
+BYTE DstAddress[6];
+BYTE DSAP;
+BYTE SSAP;
+BYTE Control;
+BYTE ProtocolID[3];
+WORD EtherType;
+} TRFRAMEHDR;
+#define DEFAULT_TR_AC (0)
+#define DEFAULT_TR_FC (0x40)
+#define DEFAULT_SAP (0xaa)
+#define DEFAULT_CONTROL (0x3)
+#define DEFAULT_ETHERTYPE (0x8419)
+typedef struct _FDDIFRAMEHDR {
+BYTE FC;
+BYTE SrcAddress[6];
+BYTE DstAddress[6];
+BYTE DSAP;
+BYTE SSAP;
+BYTE Control;
+BYTE ProtocolID[3];
+WORD EtherType;
+} FDDIFRAMEHDR;
+#define DEFAULT_FDDI_FC (0x10)
+typedef struct _FDDISTATFRAME {
+__MINGW_EXTENSION __int64 TimeStamp;
+DWORD FrameLength;
+DWORD nBytesAvail;
+FDDIFRAMEHDR FrameHeader;
+BYTE FrameID[4];
+DWORD Flags;
+DWORD FrameType;
+WORD StatsDataLen;
+DWORD StatsVersion;
+STATISTICS Statistics;
+} FDDISTATFRAME;
+typedef FDDISTATFRAME *LPFDDISTATFRAME;
+typedef FDDISTATFRAME UNALIGNED *ULPFDDISTATFRAME;
+#define FDDISTATFRAME_SIZE (sizeof(FDDISTATFRAME))
+typedef struct _ATMFRAMEHDR {
+BYTE SrcAddress[6];
+BYTE DstAddress[6];
+WORD Vpi;
+WORD Vci;
+} ATMFRAMEHDR;
+typedef struct _ATMSTATFRAME {
+__MINGW_EXTENSION __int64 TimeStamp;
+DWORD FrameLength;
+DWORD nBytesAvail;
+ATMFRAMEHDR FrameHeader;
+BYTE FrameID[4];
+DWORD Flags;
+DWORD FrameType;
+WORD StatsDataLen;
+DWORD StatsVersion;
+STATISTICS Statistics;
+} ATMSTATFRAME;
+typedef ATMSTATFRAME *LPATMSTATFRAME;
+typedef ATMSTATFRAME UNALIGNED *ULPATMSTATFRAME;
+#define ATMSTATFRAME_SIZE (sizeof(ATMSTATFRAME))
+typedef struct _TRSTATFRAME {
+__MINGW_EXTENSION __int64 TimeStamp;
+DWORD FrameLength;
+DWORD nBytesAvail;
+TRFRAMEHDR FrameHeader;
+BYTE FrameID[4];
+DWORD Flags;
+DWORD FrameType;
+WORD StatsDataLen;
+DWORD StatsVersion;
+STATISTICS Statistics;
+} TRSTATFRAME;
+typedef TRSTATFRAME *LPTRSTATFRAME;
+typedef TRSTATFRAME UNALIGNED *ULPTRSTATFRAME;
+#define TRSTATFRAME_SIZE (sizeof(TRSTATFRAME))
+typedef struct _ESTATFRAME {
+__MINGW_EXTENSION __int64 TimeStamp;
+DWORD FrameLength;
+DWORD nBytesAvail;
+EFRAMEHDR FrameHeader;
+BYTE FrameID[4];
+DWORD Flags;
+DWORD FrameType;
+WORD StatsDataLen;
+DWORD StatsVersion;
+STATISTICS Statistics;
+} ESTATFRAME;
+typedef ESTATFRAME *LPESTATFRAME;
+typedef ESTATFRAME UNALIGNED *ULPESTATFRAME;
+#define ESTATFRAME_SIZE (sizeof(ESTATFRAME))
+#define STATISTICS_VERSION_1_0 (0)
+#define STATISTICS_VERSION_2_0 (0x20)
+#define MAX_STATSFRAME_SIZE (sizeof(TRSTATFRAME))
+#define STATS_FRAME_TYPE (103)
+#pragma pack(pop)
+#pragma pack(push,1)
+typedef struct _ADDRESS {
+DWORD Type;
+__MINGW_EXTENSION union {
+BYTE MACAddress[MAC_ADDRESS_SIZE];
+BYTE IPAddress[IP_ADDRESS_SIZE];
+BYTE IPXRawAddress[IPX_ADDR_SIZE];
+IPX_ADDR IPXAddress;
+BYTE VinesIPRawAddress[VINES_IP_ADDRESS_SIZE];
+VINES_IP_ADDRESS VinesIPAddress;
+ETHERNET_SRC_ADDRESS EthernetSrcAddress;
+ETHERNET_DST_ADDRESS EthernetDstAddress;
+TOKENRING_SRC_ADDRESS TokenringSrcAddress;
+TOKENRING_DST_ADDRESS TokenringDstAddress;
+FDDI_SRC_ADDRESS FddiSrcAddress;
+FDDI_DST_ADDRESS FddiDstAddress;
+};
+WORD Flags;
+} ADDRESS;
+typedef ADDRESS *LPADDRESS;
+#define ADDRESS_SIZE sizeof(ADDRESS)
+#pragma pack(pop)
+typedef struct _ADDRESSPAIR {
+WORD AddressFlags;
+WORD NalReserved;
+ADDRESS DstAddress;
+ADDRESS SrcAddress;
+} ADDRESSPAIR;
+typedef ADDRESSPAIR *LPADDRESSPAIR;
+#define ADDRESSPAIR_SIZE sizeof(ADDRESSPAIR)
+typedef struct _ADDRESSTABLE {
+DWORD nAddressPairs;
+DWORD nNonMacAddressPairs;
+ADDRESSPAIR AddressPair[MAX_ADDRESS_PAIRS];
+} ADDRESSTABLE;
+typedef ADDRESSTABLE *LPADDRESSTABLE;
+#define ADDRESSTABLE_SIZE sizeof(ADDRESSTABLE)
+typedef struct _ADDRESSINFO {
+ADDRESS Address;
+WCHAR Name[MAX_NAME_SIZE];
+DWORD Flags;
+LPVOID lpAddressInstData;
+} ADDRESSINFO;
+typedef struct _ADDRESSINFO *LPADDRESSINFO;
+#define ADDRESSINFO_SIZE sizeof(ADDRESSINFO)
+typedef struct _ADDRESSINFOTABLE {
+DWORD nAddressInfos;
+LPADDRESSINFO lpAddressInfo[0];
+} ADDRESSINFOTABLE;
+typedef ADDRESSINFOTABLE *LPADDRESSINFOTABLE;
+#define ADDRESSINFOTABLE_SIZE sizeof(ADDRESSINFOTABLE)
+DWORD __cdecl SetNPPAddressFilterInBlob(HBLOB hBlob,LPADDRESSTABLE pAddressTable);
+DWORD __cdecl GetNPPAddressFilterFromBlob(HBLOB hBlob,LPADDRESSTABLE pAddressTable,HBLOB hErrorBlob);
+#pragma pack(push,8)
+typedef enum __MIDL___MIDL_itf_netmon_0000_0005 {
+NMCOLUMNTYPE_UINT8 = 0,
+NMCOLUMNTYPE_SINT8,NMCOLUMNTYPE_UINT16,NMCOLUMNTYPE_SINT16,NMCOLUMNTYPE_UINT32,NMCOLUMNTYPE_SINT32,
+NMCOLUMNTYPE_FLOAT64,NMCOLUMNTYPE_FRAME,NMCOLUMNTYPE_YESNO,NMCOLUMNTYPE_ONOFF,NMCOLUMNTYPE_TRUEFALSE,
+NMCOLUMNTYPE_MACADDR,NMCOLUMNTYPE_IPXADDR,NMCOLUMNTYPE_IPADDR,NMCOLUMNTYPE_VARTIME,NMCOLUMNTYPE_STRING
+} NMCOLUMNTYPE;
+typedef struct _NMCOLUMNVARIANT {
+NMCOLUMNTYPE Type;
+union {
+BYTE Uint8Val;
+char Sint8Val;
+WORD Uint16Val;
+short Sint16Val;
+DWORD Uint32Val;
+long Sint32Val;
+DOUBLE Float64Val;
+DWORD FrameVal;
+WINBOOL YesNoVal;
+WINBOOL OnOffVal;
+WINBOOL TrueFalseVal;
+BYTE MACAddrVal[6];
+IPX_ADDR IPXAddrVal;
+DWORD IPAddrVal;
+DOUBLE VarTimeVal;
+LPCSTR pStringVal;
+} Value;
+} NMCOLUMNVARIANT;
+typedef struct _NMCOLUMNINFO {
+LPSTR szColumnName;
+NMCOLUMNVARIANT VariantData;
+} NMCOLUMNINFO;
+typedef NMCOLUMNINFO *PNMCOLUMNINFO;
+typedef LPSTR JTYPE;
+typedef struct _NMEVENTDATA {
+LPSTR pszReserved;
+BYTE Version;
+DWORD EventIdent;
+DWORD Flags;
+DWORD Severity;
+BYTE NumColumns;
+LPSTR szSourceName;
+LPSTR szEventName;
+LPSTR szDescription;
+LPSTR szMachine;
+JTYPE Justification;
+PVOID pvReserved;
+SYSTEMTIME SysTime;
+NMCOLUMNINFO Column[0];
+} NMEVENTDATA;
+typedef NMEVENTDATA *PNMEVENTDATA;
+#pragma pack(pop)
+#define NMEVENTFLAG_EXPERT (0x1)
+#define NMEVENTFLAG_DO_NOT_DISPLAY_SEVERITY (0x80000000)
+#define NMEVENTFLAG_DO_NOT_DISPLAY_SOURCE (0x40000000)
+#define NMEVENTFLAG_DO_NOT_DISPLAY_EVENT_NAME (0x20000000)
+#define NMEVENTFLAG_DO_NOT_DISPLAY_DESCRIPTION (0x10000000)
+#define NMEVENTFLAG_DO_NOT_DISPLAY_MACHINE (0x8000000)
+#define NMEVENTFLAG_DO_NOT_DISPLAY_TIME (0x4000000)
+#define NMEVENTFLAG_DO_NOT_DISPLAY_DATE (0x2000000)
+#define NMEVENTFLAG_DO_NOT_DISPLAY_FIXED_COLUMNS (0xfe000000)
+enum _NMEVENT_SEVERITIES {
+NMEVENT_SEVERITY_INFORMATIONAL = 0,NMEVENT_SEVERITY_WARNING,
+NMEVENT_SEVERITY_STRONG_WARNING,NMEVENT_SEVERITY_ERROR,
+NMEVENT_SEVERITY_SEVERE_ERROR,NMEVENT_SEVERITY_CRITICAL_ERROR
+};
+typedef struct __MIDL___MIDL_itf_netmon_0000_0007 {
+DWORD dwNumBlobs;
+HBLOB hBlobs[1];
+} BLOB_TABLE;
+typedef BLOB_TABLE *PBLOB_TABLE;
+typedef struct __MIDL___MIDL_itf_netmon_0000_0008 {
+DWORD size;
+BYTE *pBytes;
+} MBLOB;
+typedef struct __MIDL___MIDL_itf_netmon_0000_0009 {
+DWORD dwNumBlobs;
+MBLOB mBlobs[1];
+} MBLOB_TABLE;
+typedef MBLOB_TABLE *PMBLOB_TABLE;
+DWORD __cdecl GetNPPBlobTable(HBLOB hFilterBlob,PBLOB_TABLE *ppBlobTable);
+DWORD __cdecl GetNPPBlobFromUI(HWND hwnd,HBLOB hFilterBlob,HBLOB *phBlob);
+DWORD __cdecl GetNPPBlobFromUIExU(HWND hwnd,HBLOB hFilterBlob,HBLOB *phBlob,char *szHelpFileName);
+DWORD __cdecl SelectNPPBlobFromTable(HWND hwnd,PBLOB_TABLE pBlobTable,HBLOB *hBlob);
+DWORD __cdecl SelectNPPBlobFromTableExU(HWND hwnd,PBLOB_TABLE pBlobTable,HBLOB *hBlob,char *szHelpFileName);
+static __inline DWORD BLOB_TABLE_SIZE(DWORD dwNumBlobs) { return (DWORD) (sizeof(BLOB_TABLE)+dwNumBlobs*sizeof(HBLOB)); }
+static __inline PBLOB_TABLE AllocBlobTable(DWORD dwNumBlobs) {
+DWORD size = BLOB_TABLE_SIZE(dwNumBlobs);
+return (PBLOB_TABLE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size);
+}
+static __inline DWORD MBLOB_TABLE_SIZE(DWORD dwNumBlobs) { return (DWORD) (sizeof(MBLOB_TABLE)+dwNumBlobs*sizeof(MBLOB)); }
+static __inline PMBLOB_TABLE AllocMBlobTable(DWORD dwNumBlobs) {
+DWORD size = MBLOB_TABLE_SIZE(dwNumBlobs);
+return (PMBLOB_TABLE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size);
+}
+DWORD __cdecl GetNPPBlobs(PBLOB_TABLE *ppBlobTable);
+typedef DWORD (_cdecl *BLOBSPROC) (PBLOB_TABLE *ppBlobTable);
+DWORD __cdecl GetConfigBlob(HBLOB *phBlob);
+typedef DWORD (_cdecl *GETCFGBLOB)(HBLOB,HBLOB*);
+typedef DWORD (_cdecl *CFGPROC)(HWND hwnd,HBLOB SpecialBlob,PBLOB_TABLE *ppBlobTable);
+WINBOOL __cdecl FilterNPPBlob(HBLOB hBlob,HBLOB FilterBlob);
+WINBOOL __cdecl RaiseNMEvent(HINSTANCE hInstance,WORD EventType,DWORD EventID,WORD nStrings,const char **aInsertStrs,LPVOID lpvData,DWORD dwDataSize);
+#ifndef __cplusplus
+#ifndef try
+#define try __try
+#endif
+#ifndef except
+#define except __except
+#endif
+#endif
+#define WINDOWS_VERSION_UNKNOWN (0)
+#define WINDOWS_VERSION_WIN32S (1)
+#define WINDOWS_VERSION_WIN32C (2)
+#define WINDOWS_VERSION_WIN32 (3)
+#define FRAME_MASK_ETHERNET ((BYTE)~0x1)
+#define FRAME_MASK_TOKENRING ((BYTE)~0x80)
+#define FRAME_MASK_FDDI ((BYTE)~0x1)
+typedef LPVOID HOBJECTHEAP;
+typedef VOID (WINAPI *OBJECTPROC)(HOBJECTHEAP,LPVOID);
+typedef struct _TIMER *HTIMER;
+typedef VOID (WINAPI *BHTIMERPROC)(LPVOID);
+HTIMER WINAPI BhSetTimer(BHTIMERPROC TimerProc,LPVOID InstData,DWORD TimeOut);
+VOID WINAPI BhKillTimer(HTIMER hTimer);
+DWORD WINAPI BhGetLastError(VOID);
+DWORD WINAPI BhSetLastError(DWORD Error);
+HOBJECTHEAP WINAPI CreateObjectHeap(DWORD ObjectSize,OBJECTPROC ObjectProc);
+HOBJECTHEAP WINAPI DestroyObjectHeap(HOBJECTHEAP hObjectHeap);
+LPVOID WINAPI AllocObject(HOBJECTHEAP hObjectHeap);
+LPVOID WINAPI FreeObject(HOBJECTHEAP hObjectHeap,LPVOID ObjectMemory);
+DWORD WINAPI GrowObjectHeap(HOBJECTHEAP hObjectHeap,DWORD nObjects);
+DWORD WINAPI GetObjectHeapSize(HOBJECTHEAP hObjectHeap);
+VOID WINAPI PurgeObjectHeap(HOBJECTHEAP hObjectHeap);
+LPVOID WINAPI AllocMemory(SIZE_T size);
+LPVOID WINAPI ReallocMemory(LPVOID ptr,SIZE_T NewSize);
+VOID WINAPI FreeMemory(LPVOID ptr);
+VOID WINAPI TestMemory(LPVOID ptr);
+SIZE_T WINAPI MemorySize(LPVOID ptr);
+HANDLE WINAPI MemoryHandle(LPBYTE ptr);
+LPEXPRESSION WINAPI InitializeExpression(LPEXPRESSION Expression);
+LPPATTERNMATCH WINAPI InitializePattern(LPPATTERNMATCH Pattern,LPVOID ptr,DWORD offset,DWORD length);
+LPEXPRESSION WINAPI AndExpression(LPEXPRESSION Expression,LPPATTERNMATCH Pattern);
+LPEXPRESSION WINAPI OrExpression(LPEXPRESSION Expression,LPPATTERNMATCH Pattern);
+LPPATTERNMATCH WINAPI NegatePattern(LPPATTERNMATCH Pattern);
+LPADDRESSTABLE2 WINAPI AdjustOperatorPrecedence(LPADDRESSTABLE2 AddressTable);
+LPADDRESS2 WINAPI NormalizeAddress(LPADDRESS2 Address);
+LPADDRESSTABLE2 WINAPI NormalizeAddressTable(LPADDRESSTABLE2 AddressTable);
+DWORD WINAPI BhGetWindowsVersion(VOID);
+WINBOOL WINAPI IsDaytona(VOID);
+VOID __cdecl dprintf(LPSTR format,...);
+typedef VOID UNALIGNED *ULPVOID;
+typedef BYTE UNALIGNED *ULPBYTE;
+typedef WORD UNALIGNED *ULPWORD;
+typedef DWORD UNALIGNED *ULPDWORD;
+typedef CHAR UNALIGNED *ULPSTR;
+typedef SYSTEMTIME UNALIGNED *ULPSYSTEMTIME;
+typedef struct _PARSER *HPARSER;
+typedef struct _CAPFRAMEDESC *HFRAME;
+typedef struct _CAPTURE *HCAPTURE;
+typedef struct _FILTER *HFILTER;
+typedef struct _ADDRESSDB *HADDRESSDB;
+typedef struct _PROTOCOL *HPROTOCOL;
+typedef DWORD_PTR HPROPERTY;
+typedef HPROTOCOL *LPHPROTOCOL;
+#define GetTableSize(TableBaseSize,nElements,ElementSize) ((TableBaseSize) + ((nElements) *(ElementSize)))
+typedef DWORD OBJECTTYPE;
+#ifndef MAKE_IDENTIFIER
+#define MAKE_IDENTIFIER(a,b,c,d) ((DWORD) MAKELONG(MAKEWORD(a,b),MAKEWORD(c,d)))
+#endif
+#define HANDLE_TYPE_INVALID MAKE_IDENTIFIER(-1,-1,-1,-1)
+#define HANDLE_TYPE_CAPTURE MAKE_IDENTIFIER('C','A','P','$')
+#define HANDLE_TYPE_PARSER MAKE_IDENTIFIER('P','S','R','$')
+#define HANDLE_TYPE_ADDRESSDB MAKE_IDENTIFIER('A','D','R','$')
+#define HANDLE_TYPE_PROTOCOL MAKE_IDENTIFIER('P','R','T','$')
+#define HANDLE_TYPE_BUFFER MAKE_IDENTIFIER('B','U','F','$')
+#define INLINE __inline
+#define BHAPI WINAPI
+#define MAX_NAME_LENGTH (16)
+#define MAX_ADDR_LENGTH (6)
+#define ETYPE_LOOP (0x9000)
+#define ETYPE_3COM_NETMAP1 (0x9001)
+#define ETYPE_3COM_NETMAP2 (0x9002)
+#define ETYPE_IBM_RT (0x80d5)
+#define ETYPE_NETWARE (0x8137)
+#define ETYPE_XNS1 (0x600)
+#define ETYPE_XNS2 (0x807)
+#define ETYPE_3COM_NBP0 (0x3c00)
+#define ETYPE_3COM_NBP1 (0x3c01)
+#define ETYPE_3COM_NBP2 (0x3c02)
+#define ETYPE_3COM_NBP3 (0x3c03)
+#define ETYPE_3COM_NBP4 (0x3c04)
+#define ETYPE_3COM_NBP5 (0x3c05)
+#define ETYPE_3COM_NBP6 (0x3c06)
+#define ETYPE_3COM_NBP7 (0x3c07)
+#define ETYPE_3COM_NBP8 (0x3c08)
+#define ETYPE_3COM_NBP9 (0x3c09)
+#define ETYPE_3COM_NBP10 (0x3c0a)
+#define ETYPE_IP (0x800)
+#define ETYPE_ARP1 (0x806)
+#define ETYPE_ARP2 (0x807)
+#define ETYPE_RARP (0x8035)
+#define ETYPE_TRLR0 (0x1000)
+#define ETYPE_TRLR1 (0x1001)
+#define ETYPE_TRLR2 (0x1002)
+#define ETYPE_TRLR3 (0x1003)
+#define ETYPE_TRLR4 (0x1004)
+#define ETYPE_TRLR5 (0x1005)
+#define ETYPE_PUP (0x200)
+#define ETYPE_PUP_ARP (0x201)
+#define ETYPE_APPLETALK_ARP (0x80f3)
+#define ETYPE_APPLETALK_LAP (0x809b)
+#define ETYPE_SNMP (0x814c)
+#define SAP_SNAP (0xaa)
+#define SAP_BPDU (0x42)
+#define SAP_IBM_NM (0xf4)
+#define SAP_IBM_NETBIOS (0xf0)
+#define SAP_SNA1 (0x4)
+#define SAP_SNA2 (0x5)
+#define SAP_SNA3 (0x8)
+#define SAP_SNA4 (0xc)
+#define SAP_NETWARE1 (0x10)
+#define SAP_NETWARE2 (0xe0)
+#define SAP_NETWARE3 (0xfe)
+#define SAP_IP (0x6)
+#define SAP_X25 (0x7e)
+#define SAP_RPL1 (0xf8)
+#define SAP_RPL2 (0xfc)
+#define SAP_UB (0xfa)
+#define SAP_XNS (0x80)
+#define PROP_TYPE_VOID (0)
+#define PROP_TYPE_SUMMARY (0x1)
+#define PROP_TYPE_BYTE (0x2)
+#define PROP_TYPE_WORD (0x3)
+#define PROP_TYPE_DWORD (0x4)
+#define PROP_TYPE_LARGEINT (0x5)
+#define PROP_TYPE_ADDR (0x6)
+#define PROP_TYPE_TIME (0x7)
+#define PROP_TYPE_STRING (0x8)
+#define PROP_TYPE_IP_ADDRESS (0x9)
+#define PROP_TYPE_IPX_ADDRESS (0xa)
+#define PROP_TYPE_BYTESWAPPED_WORD (0xb)
+#define PROP_TYPE_BYTESWAPPED_DWORD (0xc)
+#define PROP_TYPE_TYPED_STRING (0xd)
+#define PROP_TYPE_RAW_DATA (0xe)
+#define PROP_TYPE_COMMENT (0xf)
+#define PROP_TYPE_SRCFRIENDLYNAME (0x10)
+#define PROP_TYPE_DSTFRIENDLYNAME (0x11)
+#define PROP_TYPE_TOKENRING_ADDRESS (0x12)
+#define PROP_TYPE_FDDI_ADDRESS (0x13)
+#define PROP_TYPE_ETHERNET_ADDRESS (0x14)
+#define PROP_TYPE_OBJECT_IDENTIFIER (0x15)
+#define PROP_TYPE_VINES_IP_ADDRESS (0x16)
+#define PROP_TYPE_VAR_LEN_SMALL_INT (0x17)
+#define PROP_TYPE_ATM_ADDRESS (0x18)
+#define PROP_TYPE_1394_ADDRESS (0x19)
+#define PROP_TYPE_IP6_ADDRESS (0x1a)
+#define PROP_QUAL_NONE (0)
+#define PROP_QUAL_RANGE (0x1)
+#define PROP_QUAL_SET (0x2)
+#define PROP_QUAL_BITFIELD (0x3)
+#define PROP_QUAL_LABELED_SET (0x4)
+#define PROP_QUAL_LABELED_BITFIELD (0x8)
+#define PROP_QUAL_CONST (0x9)
+#define PROP_QUAL_FLAGS (0xa)
+#define PROP_QUAL_ARRAY (0xb)
+typedef LARGE_INTEGER *LPLARGEINT;
+typedef LARGE_INTEGER UNALIGNED *ULPLARGEINT;
+typedef struct _RANGE {
+DWORD MinValue;
+DWORD MaxValue;
+} RANGE;
+typedef RANGE *LPRANGE;
+typedef struct _LABELED_BYTE {
+BYTE Value;
+LPSTR Label;
+} LABELED_BYTE;
+typedef LABELED_BYTE *LPLABELED_BYTE;
+typedef struct _LABELED_WORD {
+WORD Value;
+LPSTR Label;
+} LABELED_WORD;
+typedef LABELED_WORD *LPLABELED_WORD;
+typedef struct _LABELED_DWORD {
+DWORD Value;
+LPSTR Label;
+} LABELED_DWORD;
+typedef LABELED_DWORD *LPLABELED_DWORD;
+typedef struct _LABELED_LARGEINT {
+LARGE_INTEGER Value;
+LPSTR Label;
+} LABELED_LARGEINT;
+typedef LABELED_LARGEINT *LPLABELED_LARGEINT;
+typedef struct _LABELED_SYSTEMTIME {
+SYSTEMTIME Value;
+LPSTR Label;
+} LABELED_SYSTEMTIME;
+typedef LABELED_SYSTEMTIME *LPLABELED_SYSTEMTIME;
+typedef struct _LABELED_BIT {
+BYTE BitNumber;
+LPSTR LabelOff;
+LPSTR LabelOn;
+} LABELED_BIT;
+typedef LABELED_BIT *LPLABELED_BIT;
+#define TYPED_STRING_NORMAL (1)
+#define TYPED_STRING_UNICODE (2)
+#define TYPED_STRING_EXFLAG (1)
+typedef struct _TYPED_STRING {
+BYTE StringType:7;
+BYTE fStringEx:1;
+LPSTR lpString;
+BYTE Byte[0];
+} TYPED_STRING;
+typedef TYPED_STRING *LPTYPED_STRING;
+typedef struct _OBJECT_IDENTIFIER {
+DWORD Length;
+LPDWORD lpIdentifier;
+} OBJECT_IDENTIFIER;
+typedef OBJECT_IDENTIFIER *LPOBJECT_IDENTIFIER;
+typedef struct _SET {
+DWORD nEntries;
+__MINGW_EXTENSION union {
+LPVOID lpVoidTable;
+LPBYTE lpByteTable;
+LPWORD lpWordTable;
+LPDWORD lpDwordTable;
+LPLARGEINT lpLargeIntTable;
+LPSYSTEMTIME lpSystemTimeTable;
+LPLABELED_BYTE lpLabeledByteTable;
+LPLABELED_WORD lpLabeledWordTable;
+LPLABELED_DWORD lpLabeledDwordTable;
+LPLABELED_LARGEINT lpLabeledLargeIntTable;
+LPLABELED_SYSTEMTIME lpLabeledSystemTimeTable;
+LPLABELED_BIT lpLabeledBit;
+};
+} SET;
+typedef SET *LPSET;
+typedef struct _STRINGTABLE {
+DWORD nStrings;
+LPSTR String[0];
+} STRINGTABLE;
+typedef STRINGTABLE *LPSTRINGTABLE;
+#define STRINGTABLE_SIZE sizeof(STRINGTABLE)
+typedef struct _RECOGNIZEDATA {
+WORD ProtocolID;
+WORD nProtocolOffset;
+LPVOID InstData;
+} RECOGNIZEDATA;
+typedef RECOGNIZEDATA *LPRECOGNIZEDATA;
+typedef struct _RECOGNIZEDATATABLE {
+WORD nRecognizeDatas;
+RECOGNIZEDATA RecognizeData[0];
+} RECOGNIZEDATATABLE;
+typedef RECOGNIZEDATATABLE *LPRECOGNIZEDATATABLE;
+typedef struct _PROPERTYINFO {
+HPROPERTY hProperty;
+DWORD Version;
+LPSTR Label;
+LPSTR Comment;
+BYTE DataType;
+BYTE DataQualifier;
+__MINGW_EXTENSION union {
+LPVOID lpExtendedInfo;
+LPRANGE lpRange;
+LPSET lpSet;
+DWORD Bitmask;
+DWORD Value;
+};
+WORD FormatStringSize;
+LPVOID InstanceData;
+} PROPERTYINFO;
+typedef PROPERTYINFO *LPPROPERTYINFO;
+#define PROPERTYINFO_SIZE (sizeof(PROPERTYINFO))
+typedef struct _PROPERTYINSTEX {
+WORD Length;
+WORD LengthEx;
+ULPVOID lpData;
+__MINGW_EXTENSION union {
+BYTE Byte[1];
+WORD Word[1];
+DWORD Dword[1];
+LARGE_INTEGER LargeInt[1];
+SYSTEMTIME SysTime[1];
+TYPED_STRING TypedString;
+};
+} PROPERTYINSTEX;
+typedef PROPERTYINSTEX *LPPROPERTYINSTEX;
+typedef PROPERTYINSTEX UNALIGNED *ULPPROPERTYINSTEX;
+#define PROPERTYINSTEX_SIZE sizeof(PROPERTYINSTEX)
+typedef struct _PROPERTYINST {
+LPPROPERTYINFO lpPropertyInfo;
+LPSTR szPropertyText;
+__MINGW_EXTENSION union {
+LPVOID lpData;
+ULPBYTE lpByte;
+ULPWORD lpWord;
+ULPDWORD lpDword;
+ULPLARGEINT lpLargeInt;
+ULPSYSTEMTIME lpSysTime;
+LPPROPERTYINSTEX lpPropertyInstEx;
+};
+WORD DataLength;
+WORD Level : 4;
+WORD HelpID : 12;
+DWORD IFlags;
+} PROPERTYINST;
+typedef PROPERTYINST *LPPROPERTYINST;
+#define PROPERTYINST_SIZE sizeof(PROPERTYINST)
+#define IFLAG_ERROR (0x1)
+#define IFLAG_SWAPPED (0x2)
+#define IFLAG_UNICODE (0x4)
+typedef struct _PROPERTYINSTTABLE {
+WORD nPropertyInsts;
+WORD nPropertyInstIndex;
+} PROPERTYINSTTABLE;
+typedef PROPERTYINSTTABLE *LPPROPERTYINSTTABLE;
+#define PROPERTYINSTTABLE_SIZE (sizeof(PROPERTYINSTTABLE))
+typedef struct _PROPERTYTABLE {
+LPVOID lpFormatBuffer;
+DWORD FormatBufferLength;
+DWORD nTotalPropertyInsts;
+LPPROPERTYINST lpFirstPropertyInst;
+BYTE nPropertyInstTables;
+PROPERTYINSTTABLE PropertyInstTable[0];
+} PROPERTYTABLE;
+typedef PROPERTYTABLE *LPPROPERTYTABLE;
+#define PROPERTYTABLE_SIZE sizeof(PROPERTYTABLE)
+typedef VOID (WINAPI *REGISTER)(HPROTOCOL);
+typedef VOID (WINAPI *DEREGISTER)(HPROTOCOL);
+typedef LPBYTE (WINAPI *RECOGNIZEFRAME)(HFRAME,ULPBYTE,ULPBYTE,DWORD,DWORD,HPROTOCOL,DWORD,LPDWORD,LPHPROTOCOL,PDWORD_PTR);
+typedef LPBYTE (WINAPI *ATTACHPROPERTIES)(HFRAME,ULPBYTE,ULPBYTE,DWORD,DWORD,HPROTOCOL,DWORD,DWORD_PTR);
+typedef DWORD (WINAPI *FORMATPROPERTIES)(HFRAME,ULPBYTE,ULPBYTE,DWORD,LPPROPERTYINST);
+typedef struct _ENTRYPOINTS {
+REGISTER Register;
+DEREGISTER Deregister;
+RECOGNIZEFRAME RecognizeFrame;
+ATTACHPROPERTIES AttachProperties;
+FORMATPROPERTIES FormatProperties;
+} ENTRYPOINTS;
+typedef ENTRYPOINTS *LPENTRYPOINTS;
+#define ENTRYPOINTS_SIZE sizeof(ENTRYPOINTS)
+typedef struct _PROPERTYDATABASE {
+DWORD nProperties;
+LPPROPERTYINFO PropertyInfo[0];
+} PROPERTYDATABASE;
+#define PROPERTYDATABASE_SIZE sizeof(PROPERTYDATABASE)
+typedef PROPERTYDATABASE *LPPROPERTYDATABASE;
+typedef struct _PROTOCOLINFO {
+DWORD ProtocolID;
+LPPROPERTYDATABASE PropertyDatabase;
+BYTE ProtocolName[16];
+BYTE HelpFile[16];
+BYTE Comment[128];
+} PROTOCOLINFO;
+typedef PROTOCOLINFO *LPPROTOCOLINFO;
+#define PROTOCOLINFO_SIZE sizeof(PROTOCOLINFO)
+typedef struct _PROTOCOLTABLE {
+DWORD nProtocols;
+HPROTOCOL hProtocol[1];
+} PROTOCOLTABLE;
+typedef PROTOCOLTABLE *LPPROTOCOLTABLE;
+#define PROTOCOLTABLE_SIZE (sizeof(PROTOCOLTABLE) - sizeof(HPROTOCOL))
+#define PROTOCOLTABLE_ACTUAL_SIZE(p) GetTableSize(PROTOCOLTABLE_SIZE,(p)->nProtocols,sizeof(HPROTOCOL))
+#define SORT_BYADDRESS (0)
+#define SORT_BYNAME (1)
+#define PERMANENT_NAME (0x100)
+typedef struct _ADDRESSINFO2 {
+ADDRESS2 Address;
+WCHAR Name[MAX_NAME_SIZE];
+DWORD Flags;
+LPVOID lpAddressInstData;
+} ADDRESSINFO2;
+typedef struct _ADDRESSINFO2 *LPADDRESSINFO2;
+#define ADDRESSINFO2_SIZE sizeof(ADDRESSINFO2)
+typedef struct _ADDRESSINFOTABLE2 {
+DWORD nAddressInfos;
+LPADDRESSINFO2 lpAddressInfo[0];
+} ADDRESSINFOTABLE2;
+typedef ADDRESSINFOTABLE2 *LPADDRESSINFOTABLE2;
+#define ADDRESSINFOTABLE2_SIZE sizeof(ADDRESSINFOTABLE2)
+typedef DWORD (WINAPI *FILTERPROC)(HCAPTURE,HFRAME,LPVOID);
+#define NMERR_SUCCESS (0)
+#define NMERR_MEMORY_MAPPED_FILE_ERROR (1)
+#define NMERR_INVALID_HFILTER (2)
+#define NMERR_CAPTURING (3)
+#define NMERR_NOT_CAPTURING (4)
+#define NMERR_NO_MORE_FRAMES (5)
+#define NMERR_BUFFER_TOO_SMALL (6)
+#define NMERR_FRAME_NOT_RECOGNIZED (7)
+#define NMERR_FILE_ALREADY_EXISTS (8)
+#define NMERR_DRIVER_NOT_FOUND (9)
+#define NMERR_ADDRESS_ALREADY_EXISTS (10)
+#define NMERR_INVALID_HFRAME (11)
+#define NMERR_INVALID_HPROTOCOL (12)
+#define NMERR_INVALID_HPROPERTY (13)
+#define NMERR_LOCKED (14)
+#define NMERR_STACK_EMPTY (15)
+#define NMERR_STACK_OVERFLOW (16)
+#define NMERR_TOO_MANY_PROTOCOLS (17)
+#define NMERR_FILE_NOT_FOUND (18)
+#define NMERR_OUT_OF_MEMORY (19)
+#define NMERR_CAPTURE_PAUSED (20)
+#define NMERR_NO_BUFFERS (21)
+#define NMERR_BUFFERS_ALREADY_EXIST (22)
+#define NMERR_NOT_LOCKED (23)
+#define NMERR_OUT_OF_RANGE (24)
+#define NMERR_LOCK_NESTING_TOO_DEEP (25)
+#define NMERR_LOAD_PARSER_FAILED (26)
+#define NMERR_UNLOAD_PARSER_FAILED (27)
+#define NMERR_INVALID_HADDRESSDB (28)
+#define NMERR_ADDRESS_NOT_FOUND (29)
+#define NMERR_NETWORK_NOT_PRESENT (30)
+#define NMERR_NO_PROPERTY_DATABASE (31)
+#define NMERR_PROPERTY_NOT_FOUND (32)
+#define NMERR_INVALID_HPROPERTYDB (33)
+#define NMERR_PROTOCOL_NOT_ENABLED (34)
+#define NMERR_PROTOCOL_NOT_FOUND (35)
+#define NMERR_INVALID_PARSER_DLL (36)
+#define NMERR_NO_ATTACHED_PROPERTIES (37)
+#define NMERR_NO_FRAMES (38)
+#define NMERR_INVALID_FILE_FORMAT (39)
+#define NMERR_COULD_NOT_CREATE_TEMPFILE (40)
+#define NMERR_OUT_OF_DOS_MEMORY (41)
+#define NMERR_NO_PROTOCOLS_ENABLED (42)
+#define NMERR_UNKNOWN_MACTYPE (46)
+#define NMERR_ROUTING_INFO_NOT_PRESENT (47)
+#define NMERR_INVALID_HNETWORK (48)
+#define NMERR_NETWORK_ALREADY_OPENED (49)
+#define NMERR_NETWORK_NOT_OPENED (50)
+#define NMERR_FRAME_NOT_FOUND (51)
+#define NMERR_NO_HANDLES (53)
+#define NMERR_INVALID_NETWORK_ID (54)
+#define NMERR_INVALID_HCAPTURE (55)
+#define NMERR_PROTOCOL_ALREADY_ENABLED (56)
+#define NMERR_FILTER_INVALID_EXPRESSION (57)
+#define NMERR_TRANSMIT_ERROR (58)
+#define NMERR_INVALID_HBUFFER (59)
+#define NMERR_INVALID_DATA (60)
+#define NMERR_MSDOS_DRIVER_NOT_LOADED (61)
+#define NMERR_WINDOWS_DRIVER_NOT_LOADED (62)
+#define NMERR_MSDOS_DRIVER_INIT_FAILURE (63)
+#define NMERR_WINDOWS_DRIVER_INIT_FAILURE (64)
+#define NMERR_NETWORK_BUSY (65)
+#define NMERR_CAPTURE_NOT_PAUSED (66)
+#define NMERR_INVALID_PACKET_LENGTH (67)
+#define NMERR_INTERNAL_EXCEPTION (69)
+#define NMERR_PROMISCUOUS_MODE_NOT_SUPPORTED (70)
+#define NMERR_MAC_DRIVER_OPEN_FAILURE (71)
+#define NMERR_RUNAWAY_PROTOCOL (72)
+#define NMERR_PENDING (73)
+#define NMERR_ACCESS_DENIED (74)
+#define NMERR_INVALID_HPASSWORD (75)
+#define NMERR_INVALID_PARAMETER (76)
+#define NMERR_FILE_READ_ERROR (77)
+#define NMERR_FILE_WRITE_ERROR (78)
+#define NMERR_PROTOCOL_NOT_REGISTERED (79)
+#define NMERR_IP_ADDRESS_NOT_FOUND (80)
+#define NMERR_TRANSMIT_CANCELLED (81)
+#define NMERR_LOCKED_FRAMES (82)
+#define NMERR_NO_TRANSMITS_PENDING (83)
+#define NMERR_PATH_NOT_FOUND (84)
+#define NMERR_WINDOWS_ERROR (85)
+#define NMERR_NO_FRAME_NUMBER (86)
+#define NMERR_FRAME_HAS_NO_CAPTURE (87)
+#define NMERR_FRAME_ALREADY_HAS_CAPTURE (88)
+#define NMERR_NAL_IS_NOT_REMOTE (89)
+#define NMERR_NOT_SUPPORTED (90)
+#define NMERR_DISCARD_FRAME (91)
+#define NMERR_CANCEL_SAVE_CAPTURE (92)
+#define NMERR_LOST_CONNECTION (93)
+#define NMERR_INVALID_MEDIA_TYPE (94)
+#define NMERR_AGENT_IN_USE (95)
+#define NMERR_TIMEOUT (96)
+#define NMERR_DISCONNECTED (97)
+#define NMERR_SETTIMER_FAILED (98)
+#define NMERR_NETWORK_ERROR (99)
+#define NMERR_INVALID_FRAMESPROC (100)
+#define NMERR_UNKNOWN_CAPTURETYPE (101)
+#define NMERR_NOT_CONNECTED (102)
+#define NMERR_ALREADY_CONNECTED (103)
+#define NMERR_INVALID_REGISTRY_CONFIGURATION (104)
+#define NMERR_DELAYED (105)
+#define NMERR_NOT_DELAYED (106)
+#define NMERR_REALTIME (107)
+#define NMERR_NOT_REALTIME (108)
+#define NMERR_STATS_ONLY (109)
+#define NMERR_NOT_STATS_ONLY (110)
+#define NMERR_TRANSMIT (111)
+#define NMERR_NOT_TRANSMIT (112)
+#define NMERR_TRANSMITTING (113)
+#define NMERR_DISK_NOT_LOCAL_FIXED (114)
+#define NMERR_COULD_NOT_CREATE_DIRECTORY (115)
+#define NMERR_NO_DEFAULT_CAPTURE_DIRECTORY (116)
+#define NMERR_UPLEVEL_CAPTURE_FILE (117)
+#define NMERR_LOAD_EXPERT_FAILED (118)
+#define NMERR_EXPERT_REPORT_FAILED (119)
+#define NMERR_REG_OPERATION_FAILED (120)
+#define NMERR_NO_DLLS_FOUND (121)
+#define NMERR_NO_CONVERSATION_STATS (122)
+#define NMERR_SECURITY_BREACH_CAPTURE_DELETED (123)
+#define NMERR_FRAME_FAILED_FILTER (124)
+#define NMERR_EXPERT_TERMINATE (125)
+#define NMERR_REMOTE_NOT_A_SERVER (126)
+#define NMERR_REMOTE_VERSION_OUTOFSYNC (127)
+#define NMERR_INVALID_EXPERT_GROUP (128)
+#define NMERR_INVALID_EXPERT_NAME (129)
+#define NMERR_INVALID_EXPERT_HANDLE (130)
+#define NMERR_GROUP_NAME_ALREADY_EXISTS (131)
+#define NMERR_INVALID_GROUP_NAME (132)
+#define NMERR_EXPERT_ALREADY_IN_GROUP (133)
+#define NMERR_EXPERT_NOT_IN_GROUP (134)
+#define NMERR_NOT_INITIALIZED (135)
+#define NMERR_INVALID_GROUP_ROOT (136)
+#define NMERR_BAD_VERSION (137)
+#define NMERR_ESP (138)
+#define NMERR_NOT_ESP (139)
+#define NMERR_BLOB_NOT_INITIALIZED (1000)
+#define NMERR_INVALID_BLOB (1001)
+#define NMERR_UPLEVEL_BLOB (1002)
+#define NMERR_BLOB_ENTRY_ALREADY_EXISTS (1003)
+#define NMERR_BLOB_ENTRY_DOES_NOT_EXIST (1004)
+#define NMERR_AMBIGUOUS_SPECIFIER (1005)
+#define NMERR_BLOB_OWNER_NOT_FOUND (1006)
+#define NMERR_BLOB_CATEGORY_NOT_FOUND (1007)
+#define NMERR_UNKNOWN_CATEGORY (1008)
+#define NMERR_UNKNOWN_TAG (1009)
+#define NMERR_BLOB_CONVERSION_ERROR (1010)
+#define NMERR_ILLEGAL_TRIGGER (1011)
+#define NMERR_BLOB_STRING_INVALID (1012)
+#define NMERR_UNABLE_TO_LOAD_LIBRARY (1013)
+#define NMERR_UNABLE_TO_GET_PROCADDR (1014)
+#define NMERR_CLASS_NOT_REGISTERED (1015)
+#define NMERR_INVALID_REMOTE_COMPUTERNAME (1016)
+#define NMERR_RPC_REMOTE_FAILURE (1017)
+#define NMERR_NO_NPPS (3016)
+#define NMERR_NO_MATCHING_NPPS (3017)
+#define NMERR_NO_NPP_SELECTED (3018)
+#define NMERR_NO_INPUT_BLOBS (3019)
+#define NMERR_NO_NPP_DLLS (3020)
+#define NMERR_NO_VALID_NPP_DLLS (3021)
+#ifndef INLINE
+#define INLINE __CRT_INLINE
+#endif
+typedef LONG HRESULT;
+INLINE HRESULT NMERR_TO_HRESULT(DWORD nmerror) {
+HRESULT hResult;
+if(nmerror==NMERR_SUCCESS) hResult = NOERROR;
+else hResult = MAKE_HRESULT(SEVERITY_ERROR,FACILITY_ITF,(WORD)nmerror);
+return hResult;
+}
+INLINE DWORD HRESULT_TO_NMERR(HRESULT hResult) { return HRESULT_CODE(hResult); }
+typedef HFILTER *LPHFILTER;
+typedef DWORD FILTERACTIONTYPE;
+typedef DWORD VALUETYPE;
+#define PROTOCOL_NUM_ANY (-1)
+typedef PROTOCOLTABLE PROTOCOLTABLETYPE;
+typedef PROTOCOLTABLETYPE *LPPROTOCOLTABLETYPE;
+typedef DWORD FILTERBITS;
+typedef FILTERBITS *LPFILTERBITS;
+typedef SYSTEMTIME *LPTIME;
+typedef SYSTEMTIME UNALIGNED *ULPTIME;
+typedef struct _FILTEROBJECT2 {
+FILTERACTIONTYPE Action;
+HPROPERTY hProperty;
+__MINGW_EXTENSION union {
+VALUETYPE Value;
+HPROTOCOL hProtocol;
+LPVOID lpArray;
+LPPROTOCOLTABLETYPE lpProtocolTable;
+LPADDRESS2 lpAddress;
+ULPLARGEINT lpLargeInt;
+ULPTIME lpTime;
+LPOBJECT_IDENTIFIER lpOID;
+};
+__MINGW_EXTENSION union {
+WORD ByteCount;
+WORD ByteOffset;
+};
+struct _FILTEROBJECT2 *pNext;
+} FILTEROBJECT2;
+typedef FILTEROBJECT2 *LPFILTEROBJECT2;
+#define FILTERINFO_SIZE (sizeof(FILTEROBJECT2))
+typedef struct _FILTERDESC2 {
+WORD NumEntries;
+WORD Flags;
+LPFILTEROBJECT2 lpStack;
+LPFILTEROBJECT2 lpKeepLast;
+LPVOID UIInstanceData;
+LPFILTERBITS lpFilterBits;
+LPFILTERBITS lpCheckBits;
+} FILTERDESC2;
+typedef FILTERDESC2 *LPFILTERDESC2;
+#define FILTERDESC2_SIZE sizeof(FILTERDESC2)
+typedef struct _FILTEROBJECT {
+FILTERACTIONTYPE Action;
+HPROPERTY hProperty;
+__MINGW_EXTENSION union {
+VALUETYPE Value;
+HPROTOCOL hProtocol;
+LPVOID lpArray;
+LPPROTOCOLTABLETYPE lpProtocolTable;
+LPADDRESS lpAddress;
+ULPLARGEINT lpLargeInt;
+ULPTIME lpTime;
+LPOBJECT_IDENTIFIER lpOID;
+};
+__MINGW_EXTENSION union {
+WORD ByteCount;
+WORD ByteOffset;
+};
+struct _FILTEROBJECT *pNext;
+} FILTEROBJECT;
+typedef FILTEROBJECT *LPFILTEROBJECT;
+typedef struct _FILTERDESC {
+WORD NumEntries;
+WORD Flags;
+LPFILTEROBJECT lpStack;
+LPFILTEROBJECT lpKeepLast;
+LPVOID UIInstanceData;
+LPFILTERBITS lpFilterBits;
+LPFILTERBITS lpCheckBits;
+} FILTERDESC;
+typedef FILTERDESC *LPFILTERDESC;
+#define FILTERDESC_SIZE sizeof(FILTERDESC)
+#define FilterGetUIInstanceData(hfilt) (((LPFILTERDESC2)hfilt)->UIInstanceData)
+#define FilterSetUIInstanceData(hfilt,inst) (((LPFILTERDESC2)hfilt)->UIInstanceData = (LPVOID)inst)
+#define FILTERFREEPOOLSTART (20)
+#define INVALIDELEMENT (-1)
+#define INVALIDVALUE ((VALUETYPE)-9999)
+#define FILTER_FAIL_WITH_ERROR (-1)
+#define FILTER_PASSED (TRUE)
+#define FILTER_FAILED (FALSE)
+#define FILTERACTION_INVALID (0)
+#define FILTERACTION_PROPERTY (1)
+#define FILTERACTION_VALUE (2)
+#define FILTERACTION_STRING (3)
+#define FILTERACTION_ARRAY (4)
+#define FILTERACTION_AND (5)
+#define FILTERACTION_OR (6)
+#define FILTERACTION_XOR (7)
+#define FILTERACTION_PROPERTYEXIST (8)
+#define FILTERACTION_CONTAINSNC (9)
+#define FILTERACTION_CONTAINS (10)
+#define FILTERACTION_NOT (11)
+#define FILTERACTION_EQUALNC (12)
+#define FILTERACTION_EQUAL (13)
+#define FILTERACTION_NOTEQUALNC (14)
+#define FILTERACTION_NOTEQUAL (15)
+#define FILTERACTION_GREATERNC (16)
+#define FILTERACTION_GREATER (17)
+#define FILTERACTION_LESSNC (18)
+#define FILTERACTION_LESS (19)
+#define FILTERACTION_GREATEREQUALNC (20)
+#define FILTERACTION_GREATEREQUAL (21)
+#define FILTERACTION_LESSEQUALNC (22)
+#define FILTERACTION_LESSEQUAL (23)
+#define FILTERACTION_PLUS (24)
+#define FILTERACTION_MINUS (25)
+#define FILTERACTION_ADDRESS (26)
+#define FILTERACTION_ADDRESSANY (27)
+#define FILTERACTION_FROM (28)
+#define FILTERACTION_TO (29)
+#define FILTERACTION_FROMTO (30)
+#define FILTERACTION_AREBITSON (31)
+#define FILTERACTION_AREBITSOFF (32)
+#define FILTERACTION_PROTOCOLSEXIST (33)
+#define FILTERACTION_PROTOCOLEXIST (34)
+#define FILTERACTION_ARRAYEQUAL (35)
+#define FILTERACTION_DEREFPROPERTY (36)
+#define FILTERACTION_LARGEINT (37)
+#define FILTERACTION_TIME (38)
+#define FILTERACTION_ADDR_ETHER (39)
+#define FILTERACTION_ADDR_TOKEN (40)
+#define FILTERACTION_ADDR_FDDI (41)
+#define FILTERACTION_ADDR_IPX (42)
+#define FILTERACTION_ADDR_IP (43)
+#define FILTERACTION_OID (44)
+#define FILTERACTION_OID_CONTAINS (45)
+#define FILTERACTION_OID_BEGINS_WITH (46)
+#define FILTERACTION_OID_ENDS_WITH (47)
+#define FILTERACTION_ADDR_VINES (48)
+#define FILTERACTION_ADDR_IP6 (49)
+#define FILTERACTION_EXPRESSION (97)
+#define FILTERACTION_BOOL (98)
+#define FILTERACTION_NOEVAL (99)
+#define FILTER_NO_MORE_FRAMES (0xffffffff)
+#define FILTER_CANCELED (0xfffffffe)
+#define FILTER_DIRECTION_NEXT (TRUE)
+#define FILTER_DIRECTION_PREV (FALSE)
+typedef WINBOOL (WINAPI *STATUSPROC)(DWORD,HCAPTURE,HFILTER,LPVOID);
+HFILTER WINAPI CreateFilter(VOID);
+DWORD WINAPI DestroyFilter(HFILTER hFilter);
+HFILTER WINAPI FilterDuplicate(HFILTER hFilter);
+DWORD WINAPI DisableParserFilter(HFILTER hFilter,HPARSER hParser);
+DWORD WINAPI EnableParserFilter(HFILTER hFilter,HPARSER hParser);
+DWORD WINAPI FilterAddObject(HFILTER hFilter,LPFILTEROBJECT2 lpFilterObject);
+VOID WINAPI FilterFlushBits(HFILTER hFilter);
+DWORD WINAPI FilterFrame(HFRAME hFrame,HFILTER hFilter,HCAPTURE hCapture);
+WINBOOL WINAPI FilterAttachesProperties(HFILTER hFilter);
+DWORD WINAPI FilterFindFrame (HFILTER hFilter,HCAPTURE hCapture,DWORD nFrame,STATUSPROC StatusProc,LPVOID UIInstance,DWORD TimeDelta,WINBOOL FilterDirection);
+HFRAME FilterFindPropertyInstance (HFRAME hFrame,HFILTER hMasterFilter,HCAPTURE hCapture,HFILTER hInstanceFilter,LPPROPERTYINST *lpPropRestartKey,STATUSPROC StatusProc,LPVOID UIInstance,DWORD TimeDelta,WINBOOL FilterForward);
+VOID WINAPI SetCurrentFilter(HFILTER);
+HFILTER WINAPI GetCurrentFilter(VOID);
+typedef struct _ETHERNET {
+BYTE DstAddr[MAX_ADDR_LENGTH];
+BYTE SrcAddr[MAX_ADDR_LENGTH];
+__MINGW_EXTENSION union {
+WORD Length;
+WORD Type;
+};
+BYTE Info[0];
+} ETHERNET;
+typedef ETHERNET *LPETHERNET;
+typedef ETHERNET UNALIGNED *ULPETHERNET;
+#define ETHERNET_SIZE sizeof(ETHERNET)
+#define ETHERNET_HEADER_LENGTH (14)
+#define ETHERNET_DATA_LENGTH (0x5dc)
+#define ETHERNET_FRAME_LENGTH (0x5ea)
+#define ETHERNET_FRAME_TYPE (0x600)
+typedef struct _NM_ATM {
+UCHAR DstAddr[6];
+UCHAR SrcAddr[6];
+ULONG Vpi;
+ULONG Vci;
+} NM_ATM;
+typedef NM_ATM *PNM_ATM;
+typedef NM_ATM *UPNM_ATM;
+#define NM_ATM_HEADER_LENGTH sizeof(NM_ATM)
+#pragma pack(push,1)
+typedef struct _NM_1394 {
+UCHAR DstAddr[6];
+UCHAR SrcAddr[6];
+ULONGLONG VcId;
+} NM_1394;
+typedef NM_1394 *PNM_1394;
+typedef NM_1394 *UPNM_1394;
+#define NM_1394_HEADER_LENGTH sizeof(NM_1394)
+typedef struct _TOKENRING {
+BYTE AccessCtrl;
+BYTE FrameCtrl;
+BYTE DstAddr[MAX_ADDR_LENGTH];
+BYTE SrcAddr[MAX_ADDR_LENGTH];
+__MINGW_EXTENSION union {
+BYTE Info[0];
+WORD RoutingInfo[0];
+};
+} TOKENRING;
+typedef TOKENRING *LPTOKENRING;
+typedef TOKENRING UNALIGNED *ULPTOKENRING;
+#define TOKENRING_SIZE sizeof(TOKENRING)
+#define TOKENRING_HEADER_LENGTH (14)
+#define TOKENRING_SA_ROUTING_INFO (0x80)
+#define TOKENRING_SA_LOCAL (0x40)
+#define TOKENRING_DA_LOCAL (0x40)
+#define TOKENRING_DA_GROUP (0x80)
+#define TOKENRING_RC_LENGTHMASK (0x1f)
+#define TOKENRING_BC_MASK (0xe0)
+#define TOKENRING_TYPE_MAC (0)
+#define TOKENRING_TYPE_LLC (0x40)
+#pragma pack(pop)
+#pragma pack(push,1)
+typedef struct _FDDI {
+BYTE FrameCtrl;
+BYTE DstAddr[MAX_ADDR_LENGTH];
+BYTE SrcAddr[MAX_ADDR_LENGTH];
+BYTE Info[0];
+} FDDI;
+#define FDDI_SIZE sizeof(FDDI)
+typedef FDDI *LPFDDI;
+typedef FDDI UNALIGNED *ULPFDDI;
+#define FDDI_HEADER_LENGTH (13)
+#define FDDI_TYPE_MAC (0)
+#define FDDI_TYPE_LLC (0x10)
+#define FDDI_TYPE_LONG_ADDRESS (0x40)
+#pragma pack(pop)
+#pragma pack(push,1)
+typedef struct _LLC {
+BYTE dsap;
+BYTE ssap;
+struct {
+__MINGW_EXTENSION union {
+	BYTE Command;
+	BYTE NextSend;
+};
+__MINGW_EXTENSION union {
+	BYTE NextRecv;
+	BYTE Data[1];
+};
+} ControlField;
+} LLC;
+typedef LLC *LPLLC;
+typedef LLC UNALIGNED *ULPLLC;
+#define LLC_SIZE (sizeof(LLC))
+#pragma pack(pop)
+#define IsRoutingInfoPresent(f) ((((ULPTOKENRING) (f))->SrcAddr[0] & TOKENRING_SA_ROUTING_INFO) ? TRUE : FALSE)
+#define GetRoutingInfoLength(f) (IsRoutingInfoPresent(f) ? (((ULPTOKENRING) (f))->RoutingInfo[0] & TOKENRING_RC_LENGTHMASK) : 0)
+typedef VOID (WINAPIV *FORMAT)(LPPROPERTYINST,...);
+#define PROTOCOL_STATUS_RECOGNIZED (0)
+#define PROTOCOL_STATUS_NOT_RECOGNIZED (1)
+#define PROTOCOL_STATUS_CLAIMED (2)
+#define PROTOCOL_STATUS_NEXT_PROTOCOL (3)
+extern BYTE HexTable[];
+#define XCHG(x) MAKEWORD(HIBYTE(x),LOBYTE(x))
+#define DXCHG(x) MAKELONG(XCHG(HIWORD(x)),XCHG(LOWORD(x)))
+#define LONIBBLE(b) ((BYTE) ((b) & 0x0F))
+#define HINIBBLE(b) ((BYTE) ((b) >> 4))
+#define HEX(b) (HexTable[LONIBBLE(b)])
+#define SWAPBYTES(w) ((w) = XCHG(w))
+#define SWAPWORDS(d) ((d) = DXCHG(d))
+typedef union _MACFRAME {
+LPBYTE MacHeader;
+LPETHERNET Ethernet;
+LPTOKENRING Tokenring;
+LPFDDI Fddi;
+} MACFRAME;
+typedef MACFRAME *LPMACFRAME;
+#define HOT_SIGNATURE MAKE_IDENTIFIER('H','O','T','$')
+#define HOE_SIGNATURE MAKE_IDENTIFIER('H','O','E','$')
+typedef struct _HANDOFFENTRY {
+DWORD hoe_sig;
+DWORD hoe_ProtIdentNumber;
+HPROTOCOL hoe_ProtocolHandle;
+DWORD hoe_ProtocolData;
+} HANDOFFENTRY;
+typedef HANDOFFENTRY *LPHANDOFFENTRY;
+typedef struct _HANDOFFTABLE {
+DWORD hot_sig;
+DWORD hot_NumEntries;
+LPHANDOFFENTRY hot_Entries;
+} HANDOFFTABLE;
+typedef struct _HANDOFFTABLE *LPHANDOFFTABLE;
+INLINE LPVOID GetPropertyInstanceData(LPPROPERTYINST PropertyInst) {
+if(PropertyInst->DataLength!=(WORD) -1) return PropertyInst->lpData;
+return (LPVOID) PropertyInst->lpPropertyInstEx->Byte;
+}
+#define GetPropertyInstanceDataValue(p,type) ((type *) GetPropertyInstanceData(p))[0]
+INLINE DWORD GetPropertyInstanceFrameDataLength(LPPROPERTYINST PropertyInst) {
+if(PropertyInst->DataLength!=(WORD) -1) return PropertyInst->DataLength;
+return PropertyInst->lpPropertyInstEx->Length;
+}
+INLINE DWORD GetPropertyInstanceExDataLength(LPPROPERTYINST PropertyInst) {
+if(PropertyInst->DataLength==(WORD) -1) {
+PropertyInst->lpPropertyInstEx->Length;
+}
+return (WORD) -1;
+}
+LPLABELED_WORD WINAPI GetProtocolDescriptionTable(LPDWORD TableSize);
+LPLABELED_WORD WINAPI GetProtocolDescription(DWORD ProtocolID);
+DWORD WINAPI GetMacHeaderLength(LPVOID MacHeader,DWORD MacType);
+DWORD WINAPI GetLLCHeaderLength(LPLLC Frame);
+DWORD WINAPI GetEtype(LPVOID MacHeader,DWORD MacType);
+DWORD WINAPI GetSaps(LPVOID MacHeader,DWORD MacType);
+WINBOOL WINAPI IsLLCPresent(LPVOID MacHeader,DWORD MacType);
+VOID WINAPI CanonicalizeHexString(LPSTR hex,LPSTR dest,DWORD len);
+void WINAPI CanonHex(UCHAR *pDest,UCHAR *pSource,int iLen,WINBOOL fOx);
+DWORD WINAPI ByteToBinary(LPSTR string,DWORD ByteValue);
+DWORD WINAPI WordToBinary(LPSTR string,DWORD WordValue);
+DWORD WINAPI DwordToBinary(LPSTR string,DWORD DwordValue);
+LPSTR WINAPI AddressToString(LPSTR string,BYTE *lpAddress);
+LPBYTE WINAPI StringToAddress(BYTE *lpAddress,LPSTR string);
+LPDWORD WINAPI VarLenSmallIntToDword(LPBYTE pValue,WORD ValueLen,WINBOOL fIsByteswapped,LPDWORD lpDword);
+LPBYTE WINAPI LookupByteSetString (LPSET lpSet,BYTE Value);
+LPBYTE WINAPI LookupWordSetString (LPSET lpSet,WORD Value);
+LPBYTE WINAPI LookupDwordSetString (LPSET lpSet,DWORD Value);
+DWORD WINAPIV FormatByteFlags(LPSTR string,DWORD ByteValue,DWORD BitMask);
+DWORD WINAPIV FormatWordFlags(LPSTR string,DWORD WordValue,DWORD BitMask);
+DWORD WINAPIV FormatDwordFlags(LPSTR string,DWORD DwordValue,DWORD BitMask);
+LPSTR WINAPIV FormatTimeAsString(SYSTEMTIME *time,LPSTR string);
+VOID WINAPIV FormatLabeledByteSetAsFlags(LPPROPERTYINST lpPropertyInst);
+VOID WINAPIV FormatLabeledWordSetAsFlags(LPPROPERTYINST lpPropertyInst);
+VOID WINAPIV FormatLabeledDwordSetAsFlags(LPPROPERTYINST lpPropertyInst);
+VOID WINAPIV FormatPropertyDataAsByte(LPPROPERTYINST lpPropertyInst,DWORD Base);
+VOID WINAPIV FormatPropertyDataAsWord(LPPROPERTYINST lpPropertyInst,DWORD Base);
+VOID WINAPIV FormatPropertyDataAsDword(LPPROPERTYINST lpPropertyInst,DWORD Base);
+VOID WINAPIV FormatLabeledByteSet(LPPROPERTYINST lpPropertyInst);
+VOID WINAPIV FormatLabeledWordSet(LPPROPERTYINST lpPropertyInst);
+VOID WINAPIV FormatLabeledDwordSet(LPPROPERTYINST lpPropertyInst);
+VOID WINAPIV FormatPropertyDataAsInt64(LPPROPERTYINST lpPropertyInst,DWORD Base);
+VOID WINAPIV FormatPropertyDataAsTime(LPPROPERTYINST lpPropertyInst);
+VOID WINAPIV FormatPropertyDataAsString(LPPROPERTYINST lpPropertyInst);
+VOID WINAPIV FormatPropertyDataAsHexString(LPPROPERTYINST lpPropertyInst);
+ULPBYTE WINAPI ParserTemporaryLockFrame(HFRAME hFrame);
+LPVOID WINAPI GetCCInstPtr(VOID);
+VOID WINAPI SetCCInstPtr(LPVOID lpCurCaptureInst);
+LPVOID WINAPI CCHeapAlloc(DWORD dwBytes,WINBOOL bZeroInit);
+LPVOID WINAPI CCHeapReAlloc(LPVOID lpMem,DWORD dwBytes,WINBOOL bZeroInit);
+WINBOOL WINAPI CCHeapFree(LPVOID lpMem);
+SIZE_T WINAPI CCHeapSize(LPVOID lpMem);
+WINBOOL __cdecl BERGetInteger(ULPBYTE pCurrentPointer,ULPBYTE *ppValuePointer,LPDWORD pHeaderLength,LPDWORD pDataLength,ULPBYTE *ppNext);
+WINBOOL __cdecl BERGetString(ULPBYTE pCurrentPointer,ULPBYTE *ppValuePointer,LPDWORD pHeaderLength,LPDWORD pDataLength,ULPBYTE *ppNext);
+WINBOOL __cdecl BERGetHeader(ULPBYTE pCurrentPointer,ULPBYTE pTag,LPDWORD pHeaderLength,LPDWORD pDataLength,ULPBYTE *ppNext);
+#define MAX_PROTOCOL_COMMENT_LEN (256)
+#define NETMON_MAX_PROTOCOL_NAME_LEN (16)
+#ifndef MAX_PROTOCOL_NAME_LEN
+#define MAX_PROTOCOL_NAME_LEN (NETMON_MAX_PROTOCOL_NAME_LEN)
+#else
+#undef MAX_PROTOCOL_NAME_LEN
+#endif
+typedef enum __MIDL___MIDL_itf_netmon_0000_0015 {
+HANDOFF_VALUE_FORMAT_BASE_UNKNOWN = 0,HANDOFF_VALUE_FORMAT_BASE_DECIMAL = 10,HANDOFF_VALUE_FORMAT_BASE_HEX = 16
+} PF_HANDOFFVALUEFORMATBASE;
+typedef struct _PF_HANDOFFENTRY {
+char szIniFile[260];
+char szIniSection[260];
+char szProtocol[16];
+DWORD dwHandOffValue;
+PF_HANDOFFVALUEFORMATBASE ValueFormatBase;
+} PF_HANDOFFENTRY;
+typedef PF_HANDOFFENTRY *PPF_HANDOFFENTRY;
+typedef struct _PF_HANDOFFSET {
+DWORD nEntries;
+PF_HANDOFFENTRY Entry[0];
+} PF_HANDOFFSET;
+typedef PF_HANDOFFSET *PPF_HANDOFFSET;
+typedef struct _PF_FOLLOWENTRY {
+char szProtocol[16];
+} PF_FOLLOWENTRY;
+typedef PF_FOLLOWENTRY *PPF_FOLLOWENTRY;
+typedef struct _PF_FOLLOWSET {
+DWORD nEntries;
+PF_FOLLOWENTRY Entry[0];
+} PF_FOLLOWSET;
+typedef PF_FOLLOWSET *PPF_FOLLOWSET;
+typedef struct _PF_PARSERINFO {
+char szProtocolName[NETMON_MAX_PROTOCOL_NAME_LEN];
+char szComment[MAX_PROTOCOL_COMMENT_LEN];
+char szHelpFile[MAX_PATH];
+PPF_FOLLOWSET pWhoCanPrecedeMe;
+PPF_FOLLOWSET pWhoCanFollowMe;
+PPF_HANDOFFSET pWhoHandsOffToMe;
+PPF_HANDOFFSET pWhoDoIHandOffTo;
+} PF_PARSERINFO;
+typedef PF_PARSERINFO *PPF_PARSERINFO;
+typedef struct _PF_PARSERDLLINFO {
+DWORD nParsers;
+PF_PARSERINFO ParserInfo[0];
+} PF_PARSERDLLINFO;
+typedef PF_PARSERDLLINFO *PPF_PARSERDLLINFO;
+#define INI_PATH_LENGTH (256)
+#define MAX_HANDOFF_ENTRY_LENGTH (80)
+#define MAX_PROTOCOL_NAME (40)
+#define NUMALLOCENTRIES (10)
+#define RAW_INI_STR_LEN (200)
+#define PARSERS_SUBDIR "PARSERS"
+#define INI_EXTENSION "INI"
+#define BASE10_FORMAT_STR "%ld=%s %ld"
+#define BASE16_FORMAT_STR "%lx=%s %lx"
+LPSTR __cdecl BuildINIPath(char *FullPath,char *IniFileName);
+DWORD WINAPI CreateHandoffTable(LPSTR secName,LPSTR iniFile,LPHANDOFFTABLE *hTable,DWORD nMaxProtocolEntries,DWORD base);
+HPROTOCOL WINAPI GetProtocolFromTable(LPHANDOFFTABLE hTable,DWORD ItemToFind,PDWORD_PTR lpInstData);
+VOID WINAPI DestroyHandoffTable(LPHANDOFFTABLE hTable);
+BOOLEAN WINAPI IsRawIPXEnabled(LPSTR secName,LPSTR iniFile,LPSTR CurProtocol);
+#define EXPERTSTRINGLENGTH (260)
+#define EXPERTGROUPNAMELENGTH (25)
+typedef LPVOID HEXPERTKEY;
+typedef HEXPERTKEY *PHEXPERTKEY;
+typedef LPVOID HEXPERT;
+typedef HEXPERT *PHEXPERT;
+typedef LPVOID HRUNNINGEXPERT;
+typedef HRUNNINGEXPERT *PHRUNNINGEXPERT;
+typedef struct _EXPERTENUMINFO *PEXPERTENUMINFO;
+typedef struct _EXPERTCONFIG *PEXPERTCONFIG;
+typedef struct _EXPERTSTARTUPINFO *PEXPERTSTARTUPINFO;
+#define EXPERTENTRY_REGISTER "Register"
+#define EXPERTENTRY_CONFIGURE "Configure"
+#define EXPERTENTRY_RUN "Run"
+typedef WINBOOL (WINAPI *PEXPERTREGISTERPROC)(PEXPERTENUMINFO);
+typedef WINBOOL (WINAPI *PEXPERTCONFIGPROC) (HEXPERTKEY,PEXPERTCONFIG*,PEXPERTSTARTUPINFO,DWORD,HWND);
+typedef WINBOOL (WINAPI *PEXPERTRUNPROC) (HEXPERTKEY,PEXPERTCONFIG,PEXPERTSTARTUPINFO,DWORD,HWND);
+typedef struct _EXPERTENUMINFO {
+char szName[EXPERTSTRINGLENGTH];
+char szVendor[EXPERTSTRINGLENGTH];
+char szDescription[EXPERTSTRINGLENGTH];
+DWORD Version;
+DWORD Flags;
+char szDllName[MAX_PATH];
+HEXPERT hExpert;
+HINSTANCE hModule;
+PEXPERTREGISTERPROC pRegisterProc;
+PEXPERTCONFIGPROC pConfigProc;
+PEXPERTRUNPROC pRunProc;
+} EXPERTENUMINFO;
+typedef EXPERTENUMINFO *PEXPERTENUMINFO;
+#define EXPERT_ENUM_FLAG_CONFIGURABLE (0x1)
+#define EXPERT_ENUM_FLAG_VIEWER_PRIVATE (0x2)
+#define EXPERT_ENUM_FLAG_NO_VIEWER (0x4)
+#define EXPERT_ENUM_FLAG_ADD_ME_TO_RMC_IN_SUMMARY (0x10)
+#define EXPERT_ENUM_FLAG_ADD_ME_TO_RMC_IN_DETAIL (0x20)
+typedef struct _EXPERTSTARTUPINFO {
+DWORD Flags;
+HCAPTURE hCapture;
+char szCaptureFile[MAX_PATH];
+DWORD dwFrameNumber;
+HPROTOCOL hProtocol;
+LPPROPERTYINST lpPropertyInst;
+struct {
+BYTE BitNumber;
+WINBOOL bOn;
+} sBitfield;
+} EXPERTSTARTUPINFO;
+typedef struct _EXPERTCONFIG {
+DWORD RawConfigLength;
+BYTE RawConfigData[0];
+} EXPERTCONFIG;
+typedef EXPERTCONFIG *PEXPERTCONFIG;
+typedef struct {
+HEXPERT hExpert;
+DWORD StartupFlags;
+PEXPERTCONFIG pConfig;
+} CONFIGUREDEXPERT;
+typedef CONFIGUREDEXPERT *PCONFIGUREDEXPERT;
+typedef struct {
+DWORD FrameNumber;
+HFRAME hFrame;
+ULPFRAME pFrame;
+LPRECOGNIZEDATATABLE lpRecognizeDataTable;
+LPPROPERTYTABLE lpPropertyTable;
+} EXPERTFRAMEDESCRIPTOR;
+typedef EXPERTFRAMEDESCRIPTOR *LPEXPERTFRAMEDESCRIPTOR;
+#define GET_SPECIFIED_FRAME (0)
+#define GET_FRAME_NEXT_FORWARD (1)
+#define GET_FRAME_NEXT_BACKWARD (2)
+#define FLAGS_DEFER_TO_UI_FILTER (0x1)
+#define FLAGS_ATTACH_PROPERTIES (0x2)
+typedef enum __MIDL___MIDL_itf_netmon_0000_0016 {
+EXPERTSTATUS_INACTIVE = 0,EXPERTSTATUS_STARTING,EXPERTSTATUS_RUNNING,
+EXPERTSTATUS_PROBLEM,EXPERTSTATUS_ABORTED,EXPERTSTATUS_DONE
+} EXPERTSTATUSENUMERATION;
+#define EXPERTSUBSTATUS_ABORTED_USER (0x1)
+#define EXPERTSUBSTATUS_ABORTED_LOAD_FAIL (0x2)
+#define EXPERTSUBSTATUS_ABORTED_THREAD_FAIL (0x4)
+#define EXPERTSUBSTATUS_ABORTED_BAD_ENTRY (0x8)
+typedef struct __MIDL___MIDL_itf_netmon_0000_0017 {
+EXPERTSTATUSENUMERATION Status;
+DWORD SubStatus;
+DWORD PercentDone;
+DWORD Frame;
+char szStatusText[260];
+} EXPERTSTATUS;
+typedef EXPERTSTATUS *PEXPERTSTATUS;
+#define EXPERT_STARTUP_FLAG_USE_STARTUP_DATA_OVER_CONFIG_DATA (0x1)
+#define INVALID_FRAME_NUMBER ((DWORD)-1)
+#define CAPTUREFILE_OPEN OPEN_EXISTING
+#define CAPTUREFILE_CREATE CREATE_NEW
+LPSYSTEMTIME WINAPI GetCaptureTimeStamp(HCAPTURE hCapture);
+DWORD WINAPI GetCaptureMacType(HCAPTURE hCapture);
+DWORD WINAPI GetCaptureTotalFrames(HCAPTURE hCapture);
+LPSTR WINAPI GetCaptureComment(HCAPTURE hCapture);
+DWORD WINAPI MacTypeToAddressType(DWORD MacType);
+DWORD WINAPI AddressTypeToMacType(DWORD AddressType);
+DWORD WINAPI GetFrameDstAddressOffset(HFRAME hFrame,DWORD AddressType,LPDWORD AddressLength);
+DWORD WINAPI GetFrameSrcAddressOffset(HFRAME hFrame,DWORD AddressType,LPDWORD AddressLength);
+HCAPTURE WINAPI GetFrameCaptureHandle(HFRAME hFrame);
+DWORD WINAPI GetFrameDestAddress(HFRAME hFrame,LPADDRESS2 lpAddress,DWORD AddressType,DWORD Flags);
+DWORD WINAPI GetFrameSourceAddress(HFRAME hFrame,LPADDRESS2 lpAddress,DWORD AddressType,DWORD Flags);
+DWORD WINAPI GetFrameMacHeaderLength(HFRAME hFrame);
+WINBOOL WINAPI CompareFrameDestAddress(HFRAME hFrame,LPADDRESS2 lpAddress);
+WINBOOL WINAPI CompareFrameSourceAddress(HFRAME hFrame,LPADDRESS2 lpAddress);
+DWORD WINAPI GetFrameLength(HFRAME hFrame);
+DWORD WINAPI GetFrameStoredLength(HFRAME hFrame);
+DWORD WINAPI GetFrameMacType(HFRAME hFrame);
+DWORD WINAPI GetFrameMacHeaderLength(HFRAME hFrame);
+DWORD WINAPI GetFrameNumber(HFRAME hFrame);
+__MINGW_EXTENSION __int64 WINAPI GetFrameTimeStamp(HFRAME hFrame);
+ULPFRAME WINAPI GetFrameFromFrameHandle(HFRAME hFrame);
+__MINGW_EXTENSION HFRAME WINAPI ModifyFrame(HCAPTURE hCapture,DWORD FrameNumber,LPBYTE FrameData,DWORD FrameLength,__int64 TimeStamp);
+HFRAME WINAPI FindNextFrame(HFRAME hCurrentFrame,LPSTR ProtocolName,LPADDRESS2 lpDestAddress,LPADDRESS2 lpSrcAddress,LPWORD ProtocolOffset,DWORD OriginalFrameNumber,DWORD nHighestFrame);
+HFRAME WINAPI FindPreviousFrame(HFRAME hCurrentFrame,LPSTR ProtocolName,LPADDRESS2 lpDstAddress,LPADDRESS2 lpSrcAddress,LPWORD ProtocolOffset,DWORD OriginalFrameNumber,DWORD nLowestFrame);
+HCAPTURE WINAPI GetFrameCaptureHandle(HFRAME);
+HFRAME WINAPI GetFrame(HCAPTURE hCapture,DWORD FrameNumber);
+LPRECOGNIZEDATATABLE WINAPI GetFrameRecognizeData(HFRAME hFrame);
+HPROTOCOL WINAPI CreateProtocol(LPSTR ProtocolName,LPENTRYPOINTS lpEntryPoints,DWORD cbEntryPoints);
+VOID WINAPI DestroyProtocol(HPROTOCOL hProtocol);
+LPPROTOCOLINFO WINAPI GetProtocolInfo(HPROTOCOL hProtocol);
+HPROPERTY WINAPI GetProperty(HPROTOCOL hProtocol,LPSTR PropertyName);
+HPROTOCOL WINAPI GetProtocolFromName(LPSTR ProtocolName);
+DWORD WINAPI GetProtocolStartOffset(HFRAME hFrame,LPSTR ProtocolName);
+DWORD WINAPI GetProtocolStartOffsetHandle(HFRAME hFrame,HPROTOCOL hProtocol);
+DWORD WINAPI GetPreviousProtocolOffsetByName(HFRAME hFrame,DWORD dwStartOffset,LPSTR szProtocolName,DWORD *pdwPreviousOffset);
+LPPROTOCOLTABLE WINAPI GetEnabledProtocols(HCAPTURE hCapture);
+DWORD WINAPI CreatePropertyDatabase(HPROTOCOL hProtocol,DWORD nProperties);
+DWORD WINAPI DestroyPropertyDatabase(HPROTOCOL hProtocol);
+HPROPERTY WINAPI AddProperty(HPROTOCOL hProtocol,LPPROPERTYINFO PropertyInfo);
+WINBOOL WINAPI AttachPropertyInstance(HFRAME hFrame,HPROPERTY hProperty,DWORD Length,ULPVOID lpData,DWORD HelpID,DWORD Level,DWORD IFlags);
+WINBOOL WINAPI AttachPropertyInstanceEx(HFRAME hFrame,HPROPERTY hProperty,DWORD Length,ULPVOID lpData,DWORD ExLength,ULPVOID lpExData,DWORD HelpID,DWORD Level,DWORD IFlags);
+LPPROPERTYINST WINAPI FindPropertyInstance(HFRAME hFrame,HPROPERTY hProperty);
+LPPROPERTYINST WINAPI FindPropertyInstanceRestart (HFRAME hFrame,HPROPERTY hProperty,LPPROPERTYINST *lpRestartKey,WINBOOL DirForward);
+LPPROPERTYINFO WINAPI GetPropertyInfo(HPROPERTY hProperty);
+LPSTR WINAPI GetPropertyText(HFRAME hFrame,LPPROPERTYINST lpPI,LPSTR szBuffer,DWORD BufferSize);
+DWORD WINAPI ResetPropertyInstanceLength(LPPROPERTYINST lpProp,WORD nOrgLen,WORD nNewLen);
+DWORD WINAPI GetCaptureCommentFromFilename(LPSTR lpFilename,LPSTR lpComment,DWORD BufferSize);
+int WINAPI CompareAddresses(LPADDRESS2 lpAddress1,LPADDRESS2 lpAddress2);
+DWORD WINAPIV FormatPropertyInstance(LPPROPERTYINST lpPropertyInst,...);
+__MINGW_EXTENSION SYSTEMTIME *WINAPI AdjustSystemTime(SYSTEMTIME *SystemTime,__int64 TimeDelta);
+LPSTR WINAPI NMRtlIpv6AddressToStringA(const BYTE IP6Addr[],LPSTR S);
+LPWSTR WINAPI NMRtlIpv6AddressToStringW(const BYTE IP6Addr[],LPWSTR S);
+ULONG WINAPI NMRtlIpv6StringToAddressA(LPCSTR S,LPCSTR *Terminator,BYTE IP6Addr[]);
+ULONG WINAPI NMRtlIpv6StringToAddressW(LPCWSTR S,LPCWSTR *Terminator,BYTE IP6Addr[]);
+DWORD WINAPI ExpertGetFrame(HEXPERTKEY hExpertKey,DWORD Direction,DWORD RequestFlags,DWORD RequestedFrameNumber,HFILTER hFilter,LPEXPERTFRAMEDESCRIPTOR pEFrameDescriptor);
+LPVOID WINAPI ExpertAllocMemory(HEXPERTKEY hExpertKey,SIZE_T nBytes,DWORD *pError);
+LPVOID WINAPI ExpertReallocMemory(HEXPERTKEY hExpertKey,LPVOID pOriginalMemory,SIZE_T nBytes,DWORD *pError);
+DWORD WINAPI ExpertFreeMemory(HEXPERTKEY hExpertKey,LPVOID pOriginalMemory);
+SIZE_T WINAPI ExpertMemorySize(HEXPERTKEY hExpertKey,LPVOID pOriginalMemory);
+DWORD WINAPI ExpertIndicateStatus(HEXPERTKEY hExpertKey,EXPERTSTATUSENUMERATION Status,DWORD SubStatus,const char *szText,LONG PercentDone);
+DWORD WINAPI ExpertSubmitEvent(HEXPERTKEY hExpertKey,PNMEVENTDATA pExpertEvent);
+DWORD WINAPI ExpertGetStartupInfo(HEXPERTKEY hExpertKey,PEXPERTSTARTUPINFO pExpertStartupInfo);
+#define INITIAL_RESTART_KEY (0xffffffff)
+DWORD __cdecl CreateBlob(HBLOB *phBlob);
+DWORD __cdecl DestroyBlob(HBLOB hBlob);
+DWORD __cdecl SetStringInBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,const char *pString);
+DWORD __cdecl SetWStringInBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,const WCHAR *pwString);
+DWORD __cdecl ConvertWStringToHexString(const WCHAR *pwsz,char **ppsz);
+DWORD __cdecl GetStringFromBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,const char **ppString);
+DWORD __cdecl ConvertHexStringToWString(CHAR *psz,WCHAR **ppwsz);
+DWORD __cdecl GetWStringFromBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,WCHAR **ppwString);
+DWORD __cdecl GetStringsFromBlob(HBLOB hBlob,const char *pRequestedOwnerName,const char *pRequestedCategoryName,const char *pRequestedTagName,const char **ppReturnedOwnerName,const char **ppReturnedCategoryName,const char **ppReturnedTagName,const char **ppReturnedString,DWORD *pRestartKey);
+DWORD __cdecl RemoveFromBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName);
+DWORD __cdecl LockBlob(HBLOB hBlob);
+DWORD __cdecl UnlockBlob(HBLOB hBlob);
+DWORD __cdecl FindUnknownBlobCategories(HBLOB hBlob,const char *pOwnerName,const char *pKnownCategoriesTable[],HBLOB hUnknownCategoriesBlob);
+DWORD __cdecl MergeBlob(HBLOB hDstBlob,HBLOB hSrcBlob);
+DWORD __cdecl DuplicateBlob (HBLOB hSrcBlob,HBLOB *hBlobThatWillBeCreated);
+DWORD __cdecl WriteBlobToFile(HBLOB hBlob,const char *pFileName);
+DWORD __cdecl ReadBlobFromFile(HBLOB *phBlob,const char *pFileName);
+DWORD __cdecl RegCreateBlobKey(HKEY hkey,const char *szBlobName,HBLOB hBlob);
+DWORD __cdecl RegOpenBlobKey(HKEY hkey,const char *szBlobName,HBLOB *phBlob);
+DWORD __cdecl MarshalBlob(HBLOB hBlob,DWORD *pSize,BYTE **ppBytes);
+DWORD __cdecl UnMarshalBlob(HBLOB *phBlob,DWORD Size,BYTE *pBytes);
+DWORD __cdecl SetDwordInBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,DWORD Dword);
+DWORD __cdecl GetDwordFromBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,DWORD *pDword);
+DWORD __cdecl SetBoolInBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,WINBOOL Bool);
+DWORD __cdecl GetBoolFromBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,WINBOOL *pBool);
+DWORD __cdecl GetMacAddressFromBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,BYTE *pMacAddress);
+DWORD __cdecl SetMacAddressInBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,const BYTE *pMacAddress);
+DWORD __cdecl FindUnknownBlobTags(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pKnownTagsTable[],HBLOB hUnknownTagsBlob);
+DWORD __cdecl SetNetworkInfoInBlob(HBLOB hBlob,LPNETWORKINFO lpNetworkInfo);
+DWORD __cdecl GetNetworkInfoFromBlob(HBLOB hBlob,LPNETWORKINFO lpNetworkInfo);
+DWORD __cdecl CreateNPPInterface (HBLOB hBlob,REFIID iid,void **ppvObject);
+DWORD __cdecl SetClassIDInBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,const CLSID *pClsID);
+DWORD __cdecl GetClassIDFromBlob(HBLOB hBlob,const char *pOwnerName,const char *pCategoryName,const char *pTagName,CLSID *pClsID);
+DWORD __cdecl SetNPPPatternFilterInBlob(HBLOB hBlob,LPEXPRESSION pExpression,HBLOB hErrorBlob);
+DWORD __cdecl GetNPPPatternFilterFromBlob(HBLOB hBlob,LPEXPRESSION pExpression,HBLOB hErrorBlob);
+DWORD __cdecl SetNPPAddress2FilterInBlob(HBLOB hBlob,LPADDRESSTABLE2 pAddressTable);
+DWORD __cdecl GetNPPAddress2FilterFromBlob(HBLOB hBlob,LPADDRESSTABLE2 pAddressTable,HBLOB hErrorBlob);
+DWORD __cdecl SetNPPTriggerInBlob(HBLOB hBlob,LPTRIGGER pTrigger,HBLOB hErrorBlob);
+DWORD __cdecl GetNPPTriggerFromBlob(HBLOB hBlob,LPTRIGGER pTrigger,HBLOB hErrorBlob);
+DWORD __cdecl SetNPPEtypeSapFilter(HBLOB hBlob,WORD nSaps,WORD nEtypes,LPBYTE lpSapTable,LPWORD lpEtypeTable,DWORD FilterFlags,HBLOB hErrorBlob);
+DWORD __cdecl GetNPPEtypeSapFilter(HBLOB hBlob,WORD *pnSaps,WORD *pnEtypes,LPBYTE *ppSapTable,LPWORD *ppEtypeTable,DWORD *pFilterFlags,HBLOB hErrorBlob);
+DWORD __cdecl GetNPPMacTypeAsNumber(HBLOB hBlob,LPDWORD lpMacType);
+WINBOOL __cdecl IsRemoteNPP (HBLOB hBLOB);
+#define OWNER_NPP "NPP"
+#define CATEGORY_NETWORKINFO "NetworkInfo"
+#define TAG_MACTYPE "MacType"
+#define TAG_CURRENTADDRESS "CurrentAddress"
+#define TAG_LINKSPEED "LinkSpeed"
+#define TAG_MAXFRAMESIZE "MaxFrameSize"
+#define TAG_FLAGS "Flags"
+#define TAG_TIMESTAMPSCALEFACTOR "TimeStampScaleFactor"
+#define TAG_COMMENT "Comment"
+#define TAG_NODENAME "NodeName"
+#define TAG_NAME "Name"
+#define TAG_FAKENPP "Fake"
+#define TAG_PROMISCUOUS_MODE "PMode"
+#define CATEGORY_LOCATION "Location"
+#define TAG_RAS "Dial-up Connection"
+#define TAG_MACADDRESS "MacAddress"
+#define TAG_CLASSID "ClassID"
+#define TAG_NAME "Name"
+#define TAG_CONNECTIONNAME "Connection Name"
+#define TAG_FRIENDLYNAME "Friendly Name"
+#define CATEGORY_CONFIG "Config"
+#define TAG_FRAME_SIZE "FrameSize"
+#define TAG_UPDATE_FREQUENCY "UpdateFreq"
+#define TAG_BUFFER_SIZE "BufferSize"
+#define TAG_PATTERN_DESIGNATOR "PatternMatch"
+#define TAG_PATTERN "Pattern"
+#define TAG_ADDRESS_PAIR "AddressPair"
+#define TAG_CONNECTIONFLAGS "ConnectionFlags"
+#define TAG_ETYPES "Etypes"
+#define TAG_SAPS "Saps"
+#define TAG_NO_CONVERSATION_STATS "NoConversationStats"
+#define TAG_NO_STATS_FRAME "NoStatsFrame"
+#define TAG_DONT_DELETE_EMPTY_CAPTURE "DontDeleteEmptyCapture"
+#define TAG_WANT_PROTOCOL_INFO "WantProtocolInfo"
+#define TAG_INTERFACE_DELAYED_CAPTURE "IDdC"
+#define TAG_INTERFACE_REALTIME_CAPTURE "IRTC"
+#define TAG_INTERFACE_STATS "ISts"
+#define TAG_INTERFACE_TRANSMIT "IXmt"
+#define TAG_LOCAL_ONLY "LocalOnly"
+#define TAG_IS_REMOTE "IsRemote"
+#define CATEGORY_TRIGGER "Trigger"
+#define TAG_TRIGGER "Trigger"
+#define CATEGORY_FINDER "Finder"
+#define TAG_ROOT "Root"
+#define TAG_PROCNAME "ProcName"
+#define TAG_DISP_STRING "Display"
+#define TAG_DLL_FILENAME "DLLName"
+#define TAG_GET_SPECIAL_BLOBS "Specials"
+#define CATEGORY_REMOTE "Remote"
+#define TAG_REMOTECOMPUTER "RemoteComputer"
+#define TAG_REMOTECLASSID "ClassID"
+#define PROTOCOL_STRING_ETHERNET_TXT "ETHERNET"
+#define PROTOCOL_STRING_TOKENRING_TXT "TOKENRING"
+#define PROTOCOL_STRING_FDDI_TXT "FDDI"
+#define PROTOCOL_STRING_ATM_TXT "ATM"
+#define PROTOCOL_STRING_1394_TXT "IP/1394"
+#define PROTOCOL_STRING_IP_TXT "IP"
+#define PROTOCOL_STRING_IP6_TXT "IP6"
+#define PROTOCOL_STRING_IPX_TXT "IPX"
+#define PROTOCOL_STRING_XNS_TXT "XNS"
+#define PROTOCOL_STRING_VINES_IP_TXT "VINES IP"
+#define PROTOCOL_STRING_ICMP_TXT "ICMP"
+#define PROTOCOL_STRING_TCP_TXT "TCP"
+#define PROTOCOL_STRING_UDP_TXT "UDP"
+#define PROTOCOL_STRING_SPX_TXT "SPX"
+#define PROTOCOL_STRING_NCP_TXT "NCP"
+#define PROTOCOL_STRING_ANY_TXT "ANY"
+#define PROTOCOL_STRING_ANY_GROUP_TXT "ANY GROUP"
+#define PROTOCOL_STRING_HIGHEST_TXT "HIGHEST"
+#define PROTOCOL_STRING_LOCAL_ONLY_TXT "LOCAL ONLY"
+#define PROTOCOL_STRING_UNKNOWN_TXT "UNKNOWN"
+#define PROTOCOL_STRING_DATA_TXT "DATA"
+#define PROTOCOL_STRING_FRAME_TXT "FRAME"
+#define PROTOCOL_STRING_NONE_TXT "NONE"
+#define PROTOCOL_STRING_EFFECTIVE_TXT "EFFECTIVE"
+#define ADDRESS_PAIR_INCLUDE_TXT "INCLUDE"
+#define ADDRESS_PAIR_EXCLUDE_TXT "EXCLUDE"
+#define INCLUDE_ALL_EXCEPT_TXT "INCLUDE ALL EXCEPT"
+#define EXCLUDE_ALL_EXCEPT_TXT "EXCLUDE ALL EXCEPT"
+#define PATTERN_MATCH_OR_TXT "OR("
+#define PATTERN_MATCH_AND_TXT "AND("
+#define TRIGGER_PATTERN_TXT "PATTERN MATCH"
+#define TRIGGER_BUFFER_TXT "BUFFER CONTENT"
+#define TRIGGER_NOTIFY_TXT "NOTIFY"
+#define TRIGGER_STOP_TXT "STOP"
+#define TRIGGER_PAUSE_TXT "PAUSE"
+#define TRIGGER_25_PERCENT_TXT "25 PERCENT"
+#define TRIGGER_50_PERCENT_TXT "50 PERCENT"
+#define TRIGGER_75_PERCENT_TXT "75 PERCENT"
+#define TRIGGER_100_PERCENT_TXT "100 PERCENT"
+#define PATTERN_MATCH_NOT_TXT "NOT"
+LPCSTR __cdecl FindOneOf(LPCSTR p1,LPCSTR p2);
+LONG __cdecl recursiveDeleteKey(HKEY hKeyParent,const char *lpszKeyChild);
+WINBOOL __cdecl SubkeyExists(const char *pszPath,const char *szSubkey);
+WINBOOL __cdecl setKeyAndValue(const char *szKey,const char *szSubkey,const char *szValue,const char *szName);
+#pragma pack(push,1)
+typedef struct _IP {
+__MINGW_EXTENSION union {
+BYTE Version;
+BYTE HdrLen;
+};
+BYTE ServiceType;
+WORD TotalLen;
+WORD ID;
+__MINGW_EXTENSION union {
+WORD Flags;
+WORD FragOff;
+};
+BYTE TimeToLive;
+BYTE Protocol;
+WORD HdrChksum;
+DWORD SrcAddr;
+DWORD DstAddr;
+BYTE Options[0];
+} IP;
+typedef IP *LPIP;
+typedef IP UNALIGNED *ULPIP;
+typedef struct _PSUHDR {
+DWORD ph_SrcIP;
+DWORD ph_DstIP;
+UCHAR ph_Zero;
+UCHAR ph_Proto;
+WORD ph_ProtLen;
+} PSUHDR;
+typedef PSUHDR UNALIGNED *LPPSUHDR;
+#define IP_VERSION_MASK ((BYTE) 0xf0)
+#define IP_VERSION_SHIFT (4)
+#define IP_HDRLEN_MASK ((BYTE) 0x0f)
+#define IP_HDRLEN_SHIFT (0)
+#define IP_PRECEDENCE_MASK ((BYTE) 0xE0)
+#define IP_PRECEDENCE_SHIFT (5)
+#define IP_TOS_MASK ((BYTE) 0x1E)
+#define IP_TOS_SHIFT (1)
+#define IP_DELAY_MASK ((BYTE) 0x10)
+#define IP_THROUGHPUT_MASK ((BYTE) 0x08)
+#define IP_RELIABILITY_MASK ((BYTE) 0x04)
+#define IP_FLAGS_MASK ((BYTE) 0xE0)
+#define IP_FLAGS_SHIFT (13)
+#define IP_DF_MASK ((BYTE) 0x40)
+#define IP_MF_MASK ((BYTE) 0x20)
+#define IP_MF_SHIFT (5)
+#define IP_FRAGOFF_MASK ((WORD) 0x1FFF)
+#define IP_FRAGOFF_SHIFT (3)
+#define IP_TCC_MASK ((DWORD) 0xFFFFFF00)
+#define IP_TIME_OPTS_MASK ((BYTE) 0x0F)
+#define IP_MISS_STNS_MASK ((BYTE) 0xF0)
+#define IP_TIME_OPTS_SHIFT (0)
+#define IP_MISS_STNS_SHIFT (4)
+#define IP_CHKSUM_OFF 10
+#ifndef __CRT__NO_INLINE
+INLINE BYTE IP_Version(ULPIP pIP) { return (pIP->Version & IP_VERSION_MASK) >> IP_VERSION_SHIFT; }
+INLINE DWORD IP_HdrLen(ULPIP pIP) { return ((pIP->HdrLen & IP_HDRLEN_MASK) >> IP_HDRLEN_SHIFT) << 2; }
+INLINE WORD IP_FragOff(ULPIP pIP) { return (XCHG(pIP->FragOff) & IP_FRAGOFF_MASK) << IP_FRAGOFF_SHIFT; }
+INLINE DWORD IP_TotalLen(ULPIP pIP) { return XCHG(pIP->TotalLen); }
+INLINE DWORD IP_MoreFragments(ULPIP pIP) { return (pIP->Flags & IP_MF_MASK) >> IP_MF_SHIFT; }
+#endif
+#define PORT_TCPMUX 1
+#define PORT_RJE 5
+#define PORT_ECHO 7
+#define PORT_DISCARD 9
+#define PORT_USERS 11
+#define PORT_DAYTIME 13
+#define PORT_NETSTAT 15
+#define PORT_QUOTE 17
+#define PORT_CHARGEN 19
+#define PORT_FTPDATA 20
+#define PORT_FTP 21
+#define PORT_TELNET 23
+#define PORT_SMTP 25
+#define PORT_NSWFE 27
+#define PORT_MSGICP 29
+#define PORT_MSGAUTH 31
+#define PORT_DSP 33
+#define PORT_PRTSERVER 35
+#define PORT_TIME 37
+#define PORT_RLP 39
+#define PORT_GRAPHICS 41
+#define PORT_NAMESERVER 42
+#define PORT_NICNAME 43
+#define PORT_MPMFLAGS 44
+#define PORT_MPM 45
+#define PORT_MPMSND 46
+#define PORT_NIFTP 47
+#define PORT_LOGIN 49
+#define PORT_LAMAINT 51
+#define PORT_DOMAIN 53
+#define PORT_ISIGL 55
+#define PORT_ANYTERMACC 57
+#define PORT_ANYFILESYS 59
+#define PORT_NIMAIL 61
+#define PORT_VIAFTP 63
+#define PORT_TACACSDS 65
+#define PORT_BOOTPS 67
+#define PORT_BOOTPC 68
+#define PORT_TFTP 69
+#define PORT_NETRJS1 71
+#define PORT_NETRJS2 72
+#define PORT_NETRJS3 73
+#define PORT_NETRJS4 74
+#define PORT_ANYDIALOUT 75
+#define PORT_ANYRJE 77
+#define PORT_FINGER 79
+#define PORT_HTTP 80
+#define PORT_HOSTS2NS 81
+#define PORT_MITMLDEV1 83
+#define PORT_MITMLDEV2 85
+#define PORT_ANYTERMLINK 87
+#define PORT_SUMITTG 89
+#define PORT_MITDOV 91
+#define PORT_DCP 93
+#define PORT_SUPDUP 95
+#define PORT_SWIFTRVF 97
+#define PORT_TACNEWS 98
+#define PORT_METAGRAM 99
+#define PORT_NEWACCT 100
+#define PORT_HOSTNAME 101
+#define PORT_ISOTSAP 102
+#define PORT_X400 103
+#define PORT_X400SND 104
+#define PORT_CSNETNS 105
+#define PORT_RTELNET 107
+#define PORT_POP2 109
+#define PORT_POP3 110
+#define PORT_SUNRPC 111
+#define PORT_AUTH 113
+#define PORT_SFTP 115
+#define PORT_UUCPPATH 117
+#define PORT_NNTP 119
+#define PORT_ERPC 121
+#define PORT_NTP 123
+#define PORT_LOCUSMAP 125
+#define PORT_LOCUSCON 127
+#define PORT_PWDGEN 129
+#define PORT_CISCOFNA 130
+#define PORT_CISCOTNA 131
+#define PORT_CISCOSYS 132
+#define PORT_STATSRV 133
+#define PORT_INGRESNET 134
+#define PORT_LOCSRV 135
+#define PORT_PROFILE 136
+#define PORT_NETBIOSNS 137
+#define PORT_NETBIOSDGM 138
+#define PORT_NETBIOSSSN 139
+#define PORT_EMFISDATA 140
+#define PORT_EMFISCNTL 141
+#define PORT_BLIDM 142
+#define PORT_IMAP2 143
+#define PORT_NEWS 144
+#define PORT_UAAC 145
+#define PORT_ISOTP0 146
+#define PORT_ISOIP 147
+#define PORT_CRONUS 148
+#define PORT_AED512 149
+#define PORT_SQLNET 150
+#define PORT_HEMS 151
+#define PORT_BFTP 152
+#define PORT_SGMP 153
+#define PORT_NETSCPROD 154
+#define PORT_NETSCDEV 155
+#define PORT_SQLSRV 156
+#define PORT_KNETCMP 157
+#define PORT_PCMAILSRV 158
+#define PORT_NSSROUTING 159
+#define PORT_SGMPTRAPS 160
+#define PORT_SNMP 161
+#define PORT_SNMPTRAP 162
+#define PORT_CMIPMANAGE 163
+#define PORT_CMIPAGENT 164
+#define PORT_XNSCOURIER 165
+#define PORT_SNET 166
+#define PORT_NAMP 167
+#define PORT_RSVD 168
+#define PORT_SEND 169
+#define PORT_PRINTSRV 170
+#define PORT_MULTIPLEX 171
+#define PORT_CL1 172
+#define PORT_XYPLEXMUX 173
+#define PORT_MAILQ 174
+#define PORT_VMNET 175
+#define PORT_GENRADMUX 176
+#define PORT_XDMCP 177
+#define PORT_NEXTSTEP 178
+#define PORT_BGP 179
+#define PORT_RIS 180
+#define PORT_UNIFY 181
+#define PORT_UNISYSCAM 182
+#define PORT_OCBINDER 183
+#define PORT_OCSERVER 184
+#define PORT_REMOTEKIS 185
+#define PORT_KIS 186
+#define PORT_ACI 187
+#define PORT_MUMPS 188
+#define PORT_QFT 189
+#define PORT_GACP 190
+#define PORT_PROSPERO 191
+#define PORT_OSUNMS 192
+#define PORT_SRMP 193
+#define PORT_IRC 194
+#define PORT_DN6NLMAUD 195
+#define PORT_DN6SMMRED 196
+#define PORT_DLS 197
+#define PORT_DLSMON 198
+#define PORT_ATRMTP 201
+#define PORT_ATNBP 202
+#define PORT_AT3 203
+#define PORT_ATECHO 204
+#define PORT_AT5 205
+#define PORT_ATZIS 206
+#define PORT_AT7 207
+#define PORT_AT8 208
+#define PORT_SURMEAS 243
+#define PORT_LINK 245
+#define PORT_DSP3270 246
+#define PORT_LDAP1 389
+#define PORT_ISAKMP 500
+#define PORT_REXEC 512
+#define PORT_RLOGIN 513
+#define PORT_RSH 514
+#define PORT_LPD 515
+#define PORT_RIP 520
+#define PORT_TEMPO 526
+#define PORT_COURIER 530
+#define PORT_NETNEWS 532
+#define PORT_UUCPD 540
+#define PORT_KLOGIN 543
+#define PORT_KSHELL 544
+#define PORT_DSF 555
+#define PORT_REMOTEEFS 556
+#define PORT_CHSHELL 562
+#define PORT_METER 570
+#define PORT_PCSERVER 600
+#define PORT_NQS 607
+#define PORT_HMMP_INDICATION 612
+#define PORT_HMMP_OPERATION 613
+#define PORT_MDQS 666
+#define PORT_LPD721 721
+#define PORT_LPD722 722
+#define PORT_LPD723 723
+#define PORT_LPD724 724
+#define PORT_LPD725 725
+#define PORT_LPD726 726
+#define PORT_LPD727 727
+#define PORT_LPD728 728
+#define PORT_LPD729 729
+#define PORT_LPD730 730
+#define PORT_LPD731 731
+#define PORT_RFILE 750
+#define PORT_PUMP 751
+#define PORT_QRH 752
+#define PORT_RRH 753
+#define PORT_TELL 754
+#define PORT_NLOGIN 758
+#define PORT_CON 759
+#define PORT_NS 760
+#define PORT_RXE 761
+#define PORT_QUOTAD 762
+#define PORT_CYCLESERV 763
+#define PORT_OMSERV 764
+#define PORT_WEBSTER 765
+#define PORT_PHONEBOOK 767
+#define PORT_VID 769
+#define PORT_RTIP 771
+#define PORT_CYCLESERV2 772
+#define PORT_SUBMIT 773
+#define PORT_RPASSWD 774
+#define PORT_ENTOMB 775
+#define PORT_WPAGES 776
+#define PORT_WPGS 780
+#define PORT_MDBSDAEMON 800
+#define PORT_DEVICE 801
+#define PORT_MAITRD 997
+#define PORT_BUSBOY 998
+#define PORT_GARCON 999
+#define PORT_NFS 2049
+#define PORT_LDAP2 3268
+#define PORT_PPTP 5678
+typedef struct _RequestReplyFields {
+WORD ID;
+WORD SeqNo;
+} ReqReply;
+typedef struct _ParameterProblemFields {
+BYTE Pointer;
+BYTE junk[3];
+} ParmProb;
+typedef struct _TimestampFields {
+DWORD tsOrig;
+DWORD tsRecv;
+DWORD tsXmit;
+} TS;
+typedef struct _RouterAnnounceHeaderFields {
+BYTE NumAddrs;
+BYTE AddrEntrySize;
+WORD Lifetime;
+} RouterAH;
+typedef struct _RouterAnnounceEntry {
+DWORD Address;
+DWORD PreferenceLevel;
+} RouterAE;
+typedef struct _ICMP {
+BYTE Type;
+BYTE Code;
+WORD Checksum;
+__MINGW_EXTENSION union {
+DWORD Unused;
+DWORD Address;
+ReqReply RR;
+ParmProb PP;
+RouterAH RAH;
+};
+__MINGW_EXTENSION union {
+TS Time;
+IP IP;
+RouterAE RAE[0];
+};
+} ICMP;
+typedef ICMP *LPICMP;
+typedef ICMP UNALIGNED *ULPICMP;
+#define ICMP_HEADER_LENGTH (8)
+#define ICMP_IP_DATA_LENGTH (8)
+#define ECHO_REPLY (0)
+#define DESTINATION_UNREACHABLE (3)
+#define SOURCE_QUENCH (4)
+#define REDIRECT (5)
+#define ECHO (8)
+#define ROUTER_ADVERTISEMENT (9)
+#define ROUTER_SOLICITATION (10)
+#define TIME_EXCEEDED (11)
+#define PARAMETER_PROBLEM (12)
+#define TIMESTAMP (13)
+#define TIMESTAMP_REPLY (14)
+#define INFORMATION_REQUEST (15)
+#define INFORMATION_REPLY (16)
+#define ADDRESS_MASK_REQUEST (17)
+#define ADDRESS_MASK_REPLY (18)
+typedef struct __MIDL___MIDL_itf_netmon_0000_0018 {
+UCHAR ha_address[6];
+} HOST_ADDRESS;
+typedef struct _IPXADDRESS {
+ULONG ipx_NetNumber;
+HOST_ADDRESS ipx_HostAddr;
+} IPXADDRESS;
+typedef IPXADDRESS UNALIGNED *PIPXADDRESS;
+typedef struct _NET_ADDRESS {
+IPXADDRESS na_IPXAddr;
+USHORT na_socket;
+} NET_ADDRESS;
+typedef NET_ADDRESS UNALIGNED *UPNET_ADDRESS;
+typedef struct __MIDL___MIDL_itf_netmon_0000_0019 {
+USHORT ipx_checksum;
+USHORT ipx_length;
+UCHAR ipx_xport_control;
+UCHAR ipx_packet_type;
+NET_ADDRESS ipx_dest;
+NET_ADDRESS ipx_source;
+} IPX_HDR;
+typedef IPX_HDR UNALIGNED *ULPIPX_HDR;
+typedef struct _SPX_HDR {
+IPX_HDR spx_idp_hdr;
+UCHAR spx_conn_ctrl;
+UCHAR spx_data_type;
+USHORT spx_src_conn_id;
+USHORT spx_dest_conn_id;
+USHORT spx_sequence_num;
+USHORT spx_ack_num;
+USHORT spx_alloc_num;
+} SPX_HDR;
+typedef SPX_HDR UNALIGNED *PSPX_HDR;
+typedef struct _TCP {
+WORD SrcPort;
+WORD DstPort;
+DWORD SeqNum;
+DWORD AckNum;
+BYTE DataOff;
+BYTE Flags;
+WORD Window;
+WORD Chksum;
+WORD UrgPtr;
+} TCP;
+typedef TCP *LPTCP;
+typedef TCP UNALIGNED *ULPTCP;
+#ifndef __CRT__NO_INLINE
+INLINE DWORD TCP_HdrLen(ULPTCP pTCP) { return (pTCP->DataOff & 0xf0) >> 2; }
+INLINE DWORD TCP_SrcPort(ULPTCP pTCP) { return XCHG(pTCP->SrcPort); }
+INLINE DWORD TCP_DstPort(ULPTCP pTCP) { return XCHG(pTCP->DstPort); }
+#endif
+#define TCP_OPTION_ENDOFOPTIONS (0)
+#define TCP_OPTION_NOP (1)
+#define TCP_OPTION_MAXSEGSIZE (2)
+#define TCP_OPTION_WSCALE (3)
+#define TCP_OPTION_SACK_PERMITTED (4)
+#define TCP_OPTION_SACK (5)
+#define TCP_OPTION_TIMESTAMPS (8)
+#define TCP_FLAG_URGENT (0x20)
+#define TCP_FLAG_ACK (0x10)
+#define TCP_FLAG_PUSH (0x8)
+#define TCP_FLAG_RESET (0x4)
+#define TCP_FLAG_SYN (0x2)
+#define TCP_FLAG_FIN (0x1)
+#define TCP_RESERVED_MASK (0xfc0)
+#pragma pack(pop)
+#define DEFAULT_DELAYED_BUFFER_SIZE (1)
+#define USE_DEFAULT_DRIVE_LETTER (0)
+#define RTC_FRAME_SIZE_FULL (0)
+extern RPC_IF_HANDLE __MIDL_itf_netmon_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_netmon_0000_v0_0_s_ifspec;
+#ifndef __IDelaydC_INTERFACE_DEFINED__
+#define __IDelaydC_INTERFACE_DEFINED__
+EXTERN_C const IID IID_IDelaydC;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IDelaydC : public IUnknown {
+public:
+virtual HRESULT WINAPI Connect(HBLOB hInputBlob,LPVOID StatusCallbackProc,LPVOID UserContext,HBLOB hErrorBlob) = 0;
+virtual HRESULT WINAPI Disconnect(void) = 0;
+virtual HRESULT WINAPI QueryStatus(NETWORKSTATUS *pNetworkStatus) = 0;
+virtual HRESULT WINAPI Configure(HBLOB hConfigurationBlob,HBLOB hErrorBlob) = 0;
+virtual HRESULT WINAPI Start(char *pFileName) = 0;
+virtual HRESULT WINAPI Pause(void) = 0;
+virtual HRESULT WINAPI Resume(void) = 0;
+virtual HRESULT WINAPI Stop(LPSTATISTICS lpStats) = 0;
+virtual HRESULT WINAPI GetControlState(WINBOOL *IsRunnning,WINBOOL *IsPaused) = 0;
+virtual HRESULT WINAPI GetTotalStatistics(LPSTATISTICS lpStats,WINBOOL fClearAfterReading) = 0;
+virtual HRESULT WINAPI GetConversationStatistics(DWORD *nSessions,LPSESSIONSTATS lpSessionStats,DWORD *nStations,LPSTATIONSTATS lpStationStats,WINBOOL fClearAfterReading) = 0;
+virtual HRESULT WINAPI InsertSpecialFrame(DWORD FrameType,DWORD Flags,BYTE *pUserData,DWORD UserDataLength) = 0;
+virtual HRESULT WINAPI QueryStations(QUERYTABLE *lpQueryTable) = 0;
+};
+#else
+typedef struct IDelaydCVtbl {
+BEGIN_INTERFACE
+HRESULT (WINAPI *QueryInterface)(IDelaydC *This,REFIID riid,void **ppvObject);
+ULONG (WINAPI *AddRef)(IDelaydC *This);
+ULONG (WINAPI *Release)(IDelaydC *This);
+HRESULT (WINAPI *Connect)(IDelaydC *This,HBLOB hInputBlob,LPVOID StatusCallbackProc,LPVOID UserContext,HBLOB hErrorBlob);
+HRESULT (WINAPI *Disconnect)(IDelaydC *This);
+HRESULT (WINAPI *QueryStatus)(IDelaydC *This,NETWORKSTATUS *pNetworkStatus);
+HRESULT (WINAPI *Configure)(IDelaydC *This,HBLOB hConfigurationBlob,HBLOB hErrorBlob);
+HRESULT (WINAPI *Start)(IDelaydC *This,char *pFileName);
+HRESULT (WINAPI *Pause)(IDelaydC *This);
+HRESULT (WINAPI *Resume)(IDelaydC *This);
+HRESULT (WINAPI *Stop)(IDelaydC *This,LPSTATISTICS lpStats);
+HRESULT (WINAPI *GetControlState)(IDelaydC *This,WINBOOL *IsRunnning,WINBOOL *IsPaused);
+HRESULT (WINAPI *GetTotalStatistics)(IDelaydC *This,LPSTATISTICS lpStats,WINBOOL fClearAfterReading);
+HRESULT (WINAPI *GetConversationStatistics)(IDelaydC *This,DWORD *nSessions,LPSESSIONSTATS lpSessionStats,DWORD *nStations,LPSTATIONSTATS lpStationStats,WINBOOL fClearAfterReading);
+HRESULT (WINAPI *InsertSpecialFrame)(IDelaydC *This,DWORD FrameType,DWORD Flags,BYTE *pUserData,DWORD UserDataLength);
+HRESULT (WINAPI *QueryStations)(IDelaydC *This,QUERYTABLE *lpQueryTable);
+END_INTERFACE
+} IDelaydCVtbl;
+struct IDelaydC {
+CONST_VTBL struct IDelaydCVtbl *lpVtbl;
+};
+#ifdef COBJMACROS
+#define IDelaydC_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDelaydC_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDelaydC_Release(This) (This)->lpVtbl->Release(This)
+#define IDelaydC_Connect(This,hInputBlob,StatusCallbackProc,UserContext,hErrorBlob) (This)->lpVtbl->Connect(This,hInputBlob,StatusCallbackProc,UserContext,hErrorBlob)
+#define IDelaydC_Disconnect(This) (This)->lpVtbl->Disconnect(This)
+#define IDelaydC_QueryStatus(This,pNetworkStatus) (This)->lpVtbl->QueryStatus(This,pNetworkStatus)
+#define IDelaydC_Configure(This,hConfigurationBlob,hErrorBlob) (This)->lpVtbl->Configure(This,hConfigurationBlob,hErrorBlob)
+#define IDelaydC_Start(This,pFileName) (This)->lpVtbl->Start(This,pFileName)
+#define IDelaydC_Pause(This) (This)->lpVtbl->Pause(This)
+#define IDelaydC_Resume(This) (This)->lpVtbl->Resume(This)
+#define IDelaydC_Stop(This,lpStats) (This)->lpVtbl->Stop(This,lpStats)
+#define IDelaydC_GetControlState(This,IsRunnning,IsPaused) (This)->lpVtbl->GetControlState(This,IsRunnning,IsPaused)
+#define IDelaydC_GetTotalStatistics(This,lpStats,fClearAfterReading) (This)->lpVtbl->GetTotalStatistics(This,lpStats,fClearAfterReading)
+#define IDelaydC_GetConversationStatistics(This,nSessions,lpSessionStats,nStations,lpStationStats,fClearAfterReading) (This)->lpVtbl->GetConversationStatistics(This,nSessions,lpSessionStats,nStations,lpStationStats,fClearAfterReading)
+#define IDelaydC_InsertSpecialFrame(This,FrameType,Flags,pUserData,UserDataLength) (This)->lpVtbl->InsertSpecialFrame(This,FrameType,Flags,pUserData,UserDataLength)
+#define IDelaydC_QueryStations(This,lpQueryTable) (This)->lpVtbl->QueryStations(This,lpQueryTable)
+#endif
+#endif
+HRESULT WINAPI IDelaydC_Connect_Proxy(IDelaydC *This,HBLOB hInputBlob,LPVOID StatusCallbackProc,LPVOID UserContext,HBLOB hErrorBlob);
+void __RPC_STUB IDelaydC_Connect_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_Disconnect_Proxy(IDelaydC *This);
+void __RPC_STUB IDelaydC_Disconnect_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_QueryStatus_Proxy(IDelaydC *This,NETWORKSTATUS *pNetworkStatus);
+void __RPC_STUB IDelaydC_QueryStatus_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_Configure_Proxy(IDelaydC *This,HBLOB hConfigurationBlob,HBLOB hErrorBlob);
+void __RPC_STUB IDelaydC_Configure_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_Start_Proxy(IDelaydC *This,char *pFileName);
+void __RPC_STUB IDelaydC_Start_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_Pause_Proxy(IDelaydC *This);
+void __RPC_STUB IDelaydC_Pause_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_Resume_Proxy(IDelaydC *This);
+void __RPC_STUB IDelaydC_Resume_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_Stop_Proxy(IDelaydC *This,LPSTATISTICS lpStats);
+void __RPC_STUB IDelaydC_Stop_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_GetControlState_Proxy(IDelaydC *This,WINBOOL *IsRunnning,WINBOOL *IsPaused);
+void __RPC_STUB IDelaydC_GetControlState_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_GetTotalStatistics_Proxy(IDelaydC *This,LPSTATISTICS lpStats,WINBOOL fClearAfterReading);
+void __RPC_STUB IDelaydC_GetTotalStatistics_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_GetConversationStatistics_Proxy(IDelaydC *This,DWORD *nSessions,LPSESSIONSTATS lpSessionStats,DWORD *nStations,LPSTATIONSTATS lpStationStats,WINBOOL fClearAfterReading);
+void __RPC_STUB IDelaydC_GetConversationStatistics_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_InsertSpecialFrame_Proxy(IDelaydC *This,DWORD FrameType,DWORD Flags,BYTE *pUserData,DWORD UserDataLength);
+void __RPC_STUB IDelaydC_InsertSpecialFrame_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IDelaydC_QueryStations_Proxy(IDelaydC *This,QUERYTABLE *lpQueryTable);
+void __RPC_STUB IDelaydC_QueryStations_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+#define DEFAULT_RTC_BUFFER_SIZE (0x100000)
+extern RPC_IF_HANDLE __MIDL_itf_netmon_0010_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_netmon_0010_v0_0_s_ifspec;
+#ifndef __IRTC_INTERFACE_DEFINED__
+#define __IRTC_INTERFACE_DEFINED__
+EXTERN_C const IID IID_IRTC;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IRTC : public IUnknown {
+public:
+virtual HRESULT WINAPI Connect(HBLOB hInputBlob,LPVOID StatusCallbackProc,LPVOID FramesCallbackProc,LPVOID UserContext,HBLOB hErrorBlob) = 0;
+virtual HRESULT WINAPI Disconnect(void) = 0;
+virtual HRESULT WINAPI QueryStatus(NETWORKSTATUS *pNetworkStatus) = 0;
+virtual HRESULT WINAPI Configure(HBLOB hConfigurationBlob,HBLOB hErrorBlob) = 0;
+virtual HRESULT WINAPI Start(void) = 0;
+virtual HRESULT WINAPI Pause(void) = 0;
+virtual HRESULT WINAPI Resume(void) = 0;
+virtual HRESULT WINAPI Stop(void) = 0;
+virtual HRESULT WINAPI GetControlState(WINBOOL *IsRunnning,WINBOOL *IsPaused) = 0;
+virtual HRESULT WINAPI GetTotalStatistics(LPSTATISTICS lpStats,WINBOOL fClearAfterReading) = 0;
+virtual HRESULT WINAPI GetConversationStatistics(DWORD *nSessions,LPSESSIONSTATS lpSessionStats,DWORD *nStations,LPSTATIONSTATS lpStationStats,WINBOOL fClearAfterReading) = 0;
+virtual HRESULT WINAPI InsertSpecialFrame(DWORD FrameType,DWORD Flags,BYTE *pUserData,DWORD UserDataLength) = 0;
+virtual HRESULT WINAPI QueryStations(QUERYTABLE *lpQueryTable) = 0;
+};
+#else
+typedef struct IRTCVtbl {
+BEGIN_INTERFACE
+HRESULT (WINAPI *QueryInterface)(IRTC *This,REFIID riid,void **ppvObject);
+ULONG (WINAPI *AddRef)(IRTC *This);
+ULONG (WINAPI *Release)(IRTC *This);
+HRESULT (WINAPI *Connect)(IRTC *This,HBLOB hInputBlob,LPVOID StatusCallbackProc,LPVOID FramesCallbackProc,LPVOID UserContext,HBLOB hErrorBlob);
+HRESULT (WINAPI *Disconnect)(IRTC *This);
+HRESULT (WINAPI *QueryStatus)(IRTC *This,NETWORKSTATUS *pNetworkStatus);
+HRESULT (WINAPI *Configure)(IRTC *This,HBLOB hConfigurationBlob,HBLOB hErrorBlob);
+HRESULT (WINAPI *Start)(IRTC *This);
+HRESULT (WINAPI *Pause)(IRTC *This);
+HRESULT (WINAPI *Resume)(IRTC *This);
+HRESULT (WINAPI *Stop)(IRTC *This);
+HRESULT (WINAPI *GetControlState)(IRTC *This,WINBOOL *IsRunnning,WINBOOL *IsPaused);
+HRESULT (WINAPI *GetTotalStatistics)(IRTC *This,LPSTATISTICS lpStats,WINBOOL fClearAfterReading);
+HRESULT (WINAPI *GetConversationStatistics)(IRTC *This,DWORD *nSessions,LPSESSIONSTATS lpSessionStats,DWORD *nStations,LPSTATIONSTATS lpStationStats,WINBOOL fClearAfterReading);
+HRESULT (WINAPI *InsertSpecialFrame)(IRTC *This,DWORD FrameType,DWORD Flags,BYTE *pUserData,DWORD UserDataLength);
+HRESULT (WINAPI *QueryStations)(IRTC *This,QUERYTABLE *lpQueryTable);
+END_INTERFACE
+} IRTCVtbl;
+struct IRTC {
+CONST_VTBL struct IRTCVtbl *lpVtbl;
+};
+#ifdef COBJMACROS
+#define IRTC_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IRTC_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IRTC_Release(This) (This)->lpVtbl->Release(This)
+#define IRTC_Connect(This,hInputBlob,StatusCallbackProc,FramesCallbackProc,UserContext,hErrorBlob) (This)->lpVtbl->Connect(This,hInputBlob,StatusCallbackProc,FramesCallbackProc,UserContext,hErrorBlob)
+#define IRTC_Disconnect(This) (This)->lpVtbl->Disconnect(This)
+#define IRTC_QueryStatus(This,pNetworkStatus) (This)->lpVtbl->QueryStatus(This,pNetworkStatus)
+#define IRTC_Configure(This,hConfigurationBlob,hErrorBlob) (This)->lpVtbl->Configure(This,hConfigurationBlob,hErrorBlob)
+#define IRTC_Start(This) (This)->lpVtbl->Start(This)
+#define IRTC_Pause(This) (This)->lpVtbl->Pause(This)
+#define IRTC_Resume(This) (This)->lpVtbl->Resume(This)
+#define IRTC_Stop(This) (This)->lpVtbl->Stop(This)
+#define IRTC_GetControlState(This,IsRunnning,IsPaused) (This)->lpVtbl->GetControlState(This,IsRunnning,IsPaused)
+#define IRTC_GetTotalStatistics(This,lpStats,fClearAfterReading) (This)->lpVtbl->GetTotalStatistics(This,lpStats,fClearAfterReading)
+#define IRTC_GetConversationStatistics(This,nSessions,lpSessionStats,nStations,lpStationStats,fClearAfterReading) (This)->lpVtbl->GetConversationStatistics(This,nSessions,lpSessionStats,nStations,lpStationStats,fClearAfterReading)
+#define IRTC_InsertSpecialFrame(This,FrameType,Flags,pUserData,UserDataLength) (This)->lpVtbl->InsertSpecialFrame(This,FrameType,Flags,pUserData,UserDataLength)
+#define IRTC_QueryStations(This,lpQueryTable) (This)->lpVtbl->QueryStations(This,lpQueryTable)
+#endif
+#endif
+HRESULT WINAPI IRTC_Connect_Proxy(IRTC *This,HBLOB hInputBlob,LPVOID StatusCallbackProc,LPVOID FramesCallbackProc,LPVOID UserContext,HBLOB hErrorBlob);
+void __RPC_STUB IRTC_Connect_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_Disconnect_Proxy(IRTC *This);
+void __RPC_STUB IRTC_Disconnect_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_QueryStatus_Proxy(IRTC *This,NETWORKSTATUS *pNetworkStatus);
+void __RPC_STUB IRTC_QueryStatus_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_Configure_Proxy(IRTC *This,HBLOB hConfigurationBlob,HBLOB hErrorBlob);
+void __RPC_STUB IRTC_Configure_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_Start_Proxy(IRTC *This);
+void __RPC_STUB IRTC_Start_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_Pause_Proxy(IRTC *This);
+void __RPC_STUB IRTC_Pause_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_Resume_Proxy(IRTC *This);
+void __RPC_STUB IRTC_Resume_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_Stop_Proxy(IRTC *This);
+void __RPC_STUB IRTC_Stop_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_GetControlState_Proxy(IRTC *This,WINBOOL *IsRunnning,WINBOOL *IsPaused);
+void __RPC_STUB IRTC_GetControlState_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_GetTotalStatistics_Proxy(IRTC *This,LPSTATISTICS lpStats,WINBOOL fClearAfterReading);
+void __RPC_STUB IRTC_GetTotalStatistics_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_GetConversationStatistics_Proxy(IRTC *This,DWORD *nSessions,LPSESSIONSTATS lpSessionStats,DWORD *nStations,LPSTATIONSTATS lpStationStats,WINBOOL fClearAfterReading);
+void __RPC_STUB IRTC_GetConversationStatistics_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_InsertSpecialFrame_Proxy(IRTC *This,DWORD FrameType,DWORD Flags,BYTE *pUserData,DWORD UserDataLength);
+void __RPC_STUB IRTC_InsertSpecialFrame_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IRTC_QueryStations_Proxy(IRTC *This,QUERYTABLE *lpQueryTable);
+void __RPC_STUB IRTC_QueryStations_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+extern RPC_IF_HANDLE __MIDL_itf_netmon_0012_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_netmon_0012_v0_0_s_ifspec;
+#ifndef __IStats_INTERFACE_DEFINED__
+#define __IStats_INTERFACE_DEFINED__
+EXTERN_C const IID IID_IStats;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IStats : public IUnknown {
+public:
+virtual HRESULT WINAPI Connect(HBLOB hInputBlob,LPVOID StatusCallbackProc,LPVOID UserContext,HBLOB hErrorBlob) = 0;
+virtual HRESULT WINAPI Disconnect(void) = 0;
+virtual HRESULT WINAPI QueryStatus(NETWORKSTATUS *pNetworkStatus) = 0;
+virtual HRESULT WINAPI Configure(HBLOB hConfigurationBlob,HBLOB hErrorBlob) = 0;
+virtual HRESULT WINAPI Start(void) = 0;
+virtual HRESULT WINAPI Pause(void) = 0;
+virtual HRESULT WINAPI Resume(void) = 0;
+virtual HRESULT WINAPI Stop(void) = 0;
+virtual HRESULT WINAPI GetControlState(WINBOOL *IsRunnning,WINBOOL *IsPaused) = 0;
+virtual HRESULT WINAPI GetTotalStatistics(LPSTATISTICS lpStats,WINBOOL fClearAfterReading) = 0;
+virtual HRESULT WINAPI GetConversationStatistics(DWORD *nSessions,LPSESSIONSTATS lpSessionStats,DWORD *nStations,LPSTATIONSTATS lpStationStats,WINBOOL fClearAfterReading) = 0;
+virtual HRESULT WINAPI InsertSpecialFrame(DWORD FrameType,DWORD Flags,BYTE *pUserData,DWORD UserDataLength) = 0;
+virtual HRESULT WINAPI QueryStations(QUERYTABLE *lpQueryTable) = 0;
+};
+#else
+typedef struct IStatsVtbl {
+BEGIN_INTERFACE
+HRESULT (WINAPI *QueryInterface)(IStats *This,REFIID riid,void **ppvObject);
+ULONG (WINAPI *AddRef)(IStats *This);
+ULONG (WINAPI *Release)(IStats *This);
+HRESULT (WINAPI *Connect)(IStats *This,HBLOB hInputBlob,LPVOID StatusCallbackProc,LPVOID UserContext,HBLOB hErrorBlob);
+HRESULT (WINAPI *Disconnect)(IStats *This);
+HRESULT (WINAPI *QueryStatus)(IStats *This,NETWORKSTATUS *pNetworkStatus);
+HRESULT (WINAPI *Configure)(IStats *This,HBLOB hConfigurationBlob,HBLOB hErrorBlob);
+HRESULT (WINAPI *Start)(IStats *This);
+HRESULT (WINAPI *Pause)(IStats *This);
+HRESULT (WINAPI *Resume)(IStats *This);
+HRESULT (WINAPI *Stop)(IStats *This);
+HRESULT (WINAPI *GetControlState)(IStats *This,WINBOOL *IsRunnning,WINBOOL *IsPaused);
+HRESULT (WINAPI *GetTotalStatistics)(IStats *This,LPSTATISTICS lpStats,WINBOOL fClearAfterReading);
+HRESULT (WINAPI *GetConversationStatistics)(IStats *This,DWORD *nSessions,LPSESSIONSTATS lpSessionStats,DWORD *nStations,LPSTATIONSTATS lpStationStats,WINBOOL fClearAfterReading);
+HRESULT (WINAPI *InsertSpecialFrame)(IStats *This,DWORD FrameType,DWORD Flags,BYTE *pUserData,DWORD UserDataLength);
+HRESULT (WINAPI *QueryStations)(IStats *This,QUERYTABLE *lpQueryTable);
+END_INTERFACE
+} IStatsVtbl;
+struct IStats {
+CONST_VTBL struct IStatsVtbl *lpVtbl;
+};
+#ifdef COBJMACROS
+#define IStats_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IStats_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IStats_Release(This) (This)->lpVtbl->Release(This)
+#define IStats_Connect(This,hInputBlob,StatusCallbackProc,UserContext,hErrorBlob) (This)->lpVtbl->Connect(This,hInputBlob,StatusCallbackProc,UserContext,hErrorBlob)
+#define IStats_Disconnect(This) (This)->lpVtbl->Disconnect(This)
+#define IStats_QueryStatus(This,pNetworkStatus) (This)->lpVtbl->QueryStatus(This,pNetworkStatus)
+#define IStats_Configure(This,hConfigurationBlob,hErrorBlob) (This)->lpVtbl->Configure(This,hConfigurationBlob,hErrorBlob)
+#define IStats_Start(This) (This)->lpVtbl->Start(This)
+#define IStats_Pause(This) (This)->lpVtbl->Pause(This)
+#define IStats_Resume(This) (This)->lpVtbl->Resume(This)
+#define IStats_Stop(This) (This)->lpVtbl->Stop(This)
+#define IStats_GetControlState(This,IsRunnning,IsPaused) (This)->lpVtbl->GetControlState(This,IsRunnning,IsPaused)
+#define IStats_GetTotalStatistics(This,lpStats,fClearAfterReading) (This)->lpVtbl->GetTotalStatistics(This,lpStats,fClearAfterReading)
+#define IStats_GetConversationStatistics(This,nSessions,lpSessionStats,nStations,lpStationStats,fClearAfterReading) (This)->lpVtbl->GetConversationStatistics(This,nSessions,lpSessionStats,nStations,lpStationStats,fClearAfterReading)
+#define IStats_InsertSpecialFrame(This,FrameType,Flags,pUserData,UserDataLength) (This)->lpVtbl->InsertSpecialFrame(This,FrameType,Flags,pUserData,UserDataLength)
+#define IStats_QueryStations(This,lpQueryTable) (This)->lpVtbl->QueryStations(This,lpQueryTable)
+#endif
+#endif
+HRESULT WINAPI IStats_Connect_Proxy(IStats *This,HBLOB hInputBlob,LPVOID StatusCallbackProc,LPVOID UserContext,HBLOB hErrorBlob);
+void __RPC_STUB IStats_Connect_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_Disconnect_Proxy(IStats *This);
+void __RPC_STUB IStats_Disconnect_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_QueryStatus_Proxy(IStats *This,NETWORKSTATUS *pNetworkStatus);
+void __RPC_STUB IStats_QueryStatus_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_Configure_Proxy(IStats *This,HBLOB hConfigurationBlob,HBLOB hErrorBlob);
+void __RPC_STUB IStats_Configure_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_Start_Proxy(IStats *This);
+void __RPC_STUB IStats_Start_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_Pause_Proxy(IStats *This);
+void __RPC_STUB IStats_Pause_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_Resume_Proxy(IStats *This);
+void __RPC_STUB IStats_Resume_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_Stop_Proxy(IStats *This);
+void __RPC_STUB IStats_Stop_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_GetControlState_Proxy(IStats *This,WINBOOL *IsRunnning,WINBOOL *IsPaused);
+void __RPC_STUB IStats_GetControlState_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_GetTotalStatistics_Proxy(IStats *This,LPSTATISTICS lpStats,WINBOOL fClearAfterReading);
+void __RPC_STUB IStats_GetTotalStatistics_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_GetConversationStatistics_Proxy(IStats *This,DWORD *nSessions,LPSESSIONSTATS lpSessionStats,DWORD *nStations,LPSTATIONSTATS lpStationStats,WINBOOL fClearAfterReading);
+void __RPC_STUB IStats_GetConversationStatistics_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_InsertSpecialFrame_Proxy(IStats *This,DWORD FrameType,DWORD Flags,BYTE *pUserData,DWORD UserDataLength);
+void __RPC_STUB IStats_InsertSpecialFrame_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+HRESULT WINAPI IStats_QueryStations_Proxy(IStats *This,QUERYTABLE *lpQueryTable);
+void __RPC_STUB IStats_QueryStations_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+#pragma pack()
+extern RPC_IF_HANDLE __MIDL_itf_netmon_0014_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_netmon_0014_v0_0_s_ifspec;
+#ifdef __cplusplus
+}
+#endif
+#endif

Mercurial > games > semicongine

comparison fuhtark_test/include/winapi/netmon.h @ 1500:91c8c3b7cbf0