diff --git a/ctypes_generation/definitions/com/IPersist.txt b/ctypes_generation/definitions/com/IPersist.txt new file mode 100644 index 0000000..95e003b --- /dev/null +++ b/ctypes_generation/definitions/com/IPersist.txt @@ -0,0 +1,22 @@ +typedef struct IPersistVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IPersist * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + __RPC__deref_out void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IPersist * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IPersist * This); + + HRESULT ( STDMETHODCALLTYPE *GetClassID )( + __RPC__in IPersist * This, + /* [out] */ __RPC__out CLSID *pClassID); + + END_INTERFACE + } IPersistVtbl; \ No newline at end of file diff --git a/ctypes_generation/definitions/defines/event_trace.txt b/ctypes_generation/definitions/defines/event_trace.txt new file mode 100644 index 0000000..ec7cb45 --- /dev/null +++ b/ctypes_generation/definitions/defines/event_trace.txt @@ -0,0 +1,114 @@ +// +// Enable flags for Kernel Events on Win7 and above +// +#define EVENT_TRACE_FLAG_DISPATCHER 0x00000800 // scheduler (ReadyThread) +#define EVENT_TRACE_FLAG_VIRTUAL_ALLOC 0x00004000 // VM operations + +// +// Enable flags for Kernel Events on Win8 and above +// +#define EVENT_TRACE_FLAG_VAMAP 0x00008000 // map/unmap (excluding images) +#define EVENT_TRACE_FLAG_NO_SYSCONFIG 0x10000000 // Do not do sys config rundown + +// +// Pre-defined Enable flags for everybody else +// +#define EVENT_TRACE_FLAG_EXTENSION 0x80000000 // Indicates more flags +#define EVENT_TRACE_FLAG_FORWARD_WMI 0x40000000 // Can forward to WMI +#define EVENT_TRACE_FLAG_ENABLE_RESERVE 0x20000000 // Reserved + +// +// Logger Mode flags +// +#define EVENT_TRACE_FILE_MODE_NONE 0x00000000 // Logfile is off +#define EVENT_TRACE_FILE_MODE_SEQUENTIAL 0x00000001 // Log sequentially +#define EVENT_TRACE_FILE_MODE_CIRCULAR 0x00000002 // Log in circular manner +#define EVENT_TRACE_FILE_MODE_APPEND 0x00000004 // Append sequential log + +#define EVENT_TRACE_REAL_TIME_MODE 0x00000100 // Real time mode on +#define EVENT_TRACE_DELAY_OPEN_FILE_MODE 0x00000200 // Delay opening file +#define EVENT_TRACE_BUFFERING_MODE 0x00000400 // Buffering mode only +#define EVENT_TRACE_PRIVATE_LOGGER_MODE 0x00000800 // Process Private Logger +#define EVENT_TRACE_ADD_HEADER_MODE 0x00001000 // Add a logfile header + +#define EVENT_TRACE_USE_GLOBAL_SEQUENCE 0x00004000 // Use global sequence no. +#define EVENT_TRACE_USE_LOCAL_SEQUENCE 0x00008000 // Use local sequence no. + +#define EVENT_TRACE_RELOG_MODE 0x00010000 // Relogger + +#define EVENT_TRACE_USE_PAGED_MEMORY 0x01000000 // Use pageable buffers + +// +// Logger Mode flags on XP and above +// + +#define EVENT_TRACE_FILE_MODE_NEWFILE 0x00000008 // Auto-switch log file +#define EVENT_TRACE_FILE_MODE_PREALLOCATE 0x00000020 // Pre-allocate mode + + +// +// ControlTrace Codes +// + +#define EVENT_TRACE_CONTROL_QUERY 0 +#define EVENT_TRACE_CONTROL_STOP 1 +#define EVENT_TRACE_CONTROL_UPDATE 2 + +// +// Flush ControlTrace Codes for XP and above +// + +#define EVENT_TRACE_CONTROL_FLUSH 3 // Flushes all the buffers + + +// +// Consumer API +// + +#define PROCESS_TRACE_MODE_REAL_TIME 0x00000100 +#define PROCESS_TRACE_MODE_RAW_TIMESTAMP 0x00001000 +#define PROCESS_TRACE_MODE_EVENT_RECORD 0x10000000 + + + +#define EVENT_HEADER_PROPERTY_XML 0x0001 +#define EVENT_HEADER_PROPERTY_FORWARDED_XML 0x0002 +#define EVENT_HEADER_PROPERTY_LEGACY_EVENTLOG 0x0004 + +#define EVENT_HEADER_FLAG_EXTENDED_INFO 0x0001 +#define EVENT_HEADER_FLAG_PRIVATE_SESSION 0x0002 +#define EVENT_HEADER_FLAG_STRING_ONLY 0x0004 +#define EVENT_HEADER_FLAG_TRACE_MESSAGE 0x0008 +#define EVENT_HEADER_FLAG_NO_CPUTIME 0x0010 +#define EVENT_HEADER_FLAG_32_BIT_HEADER 0x0020 +#define EVENT_HEADER_FLAG_64_BIT_HEADER 0x0040 +#define EVENT_HEADER_FLAG_CLASSIC_HEADER 0x0100 +#define EVENT_HEADER_FLAG_PROCESSOR_INDEX 0x0200 + + + +// Event types for system configuration records +// +#define EVENT_TRACE_TYPE_CONFIG_CPU 0x0A // CPU Configuration +#define EVENT_TRACE_TYPE_CONFIG_PHYSICALDISK 0x0B // Physical Disk Configuration +#define EVENT_TRACE_TYPE_CONFIG_LOGICALDISK 0x0C // Logical Disk Configuration +#define EVENT_TRACE_TYPE_CONFIG_NIC 0x0D // NIC Configuration +#define EVENT_TRACE_TYPE_CONFIG_VIDEO 0x0E // Video Adapter Configuration +#define EVENT_TRACE_TYPE_CONFIG_SERVICES 0x0F // Active Services +#define EVENT_TRACE_TYPE_CONFIG_POWER 0x10 // ACPI Configuration +#define EVENT_TRACE_TYPE_CONFIG_NETINFO 0x11 // Networking Configuration + +// +// Enable flags for SystemControlGuid only +// +#define EVENT_TRACE_FLAG_PROCESS 0x00000001 // process start & end +#define EVENT_TRACE_FLAG_THREAD 0x00000002 // thread start & end +#define EVENT_TRACE_FLAG_IMAGE_LOAD 0x00000004 // image load +#define EVENT_TRACE_FLAG_DISK_IO 0x00000100 // physical disk IO +#define EVENT_TRACE_FLAG_DISK_FILE_IO 0x00000200 // requires disk IO +#define EVENT_TRACE_FLAG_MEMORY_PAGE_FAULTS 0x00001000 // all page faults +#define EVENT_TRACE_FLAG_MEMORY_HARD_FAULTS 0x00002000 // hard faults only +#define EVENT_TRACE_FLAG_NETWORK_TCPIP 0x00010000 // tcpip send & receive +#define EVENT_TRACE_FLAG_REGISTRY 0x00020000 // registry calls +#define EVENT_TRACE_FLAG_DBGPRINT 0x00040000 // DbgPrint(ex) Calls +#define EVENT_TRACE_FLAG_VOLMGR 0x00200000 // volume manager traces \ No newline at end of file diff --git a/ctypes_generation/definitions/defines/network.txt b/ctypes_generation/definitions/defines/network.txt new file mode 100644 index 0000000..d14151f --- /dev/null +++ b/ctypes_generation/definitions/defines/network.txt @@ -0,0 +1,176 @@ +#define ATM_E164 0x01 /* E.164 addressing scheme */ +#define ATM_NSAP 0x02 /* NSAP-style ATM Endsystem Address scheme */ +#define ATM_AESA 0x02 /* NSAP-style ATM Endsystem Address scheme */ +#define ATM_ADDR_SIZE 20 + +#define DNS_ATMA_FORMAT_E164 ATM_E164 +#define DNS_ATMA_FORMAT_AESA ATM_AESA +#define DNS_ATMA_MAX_ADDR_LENGTH ATM_ADDR_SIZE + + +#define DNS_TYPE_ZERO 0x0000 + +// RFC 1034/1035 +#define DNS_TYPE_A 0x0001 // 1 +#define DNS_TYPE_NS 0x0002 // 2 +#define DNS_TYPE_MD 0x0003 // 3 +#define DNS_TYPE_MF 0x0004 // 4 +#define DNS_TYPE_CNAME 0x0005 // 5 +#define DNS_TYPE_SOA 0x0006 // 6 +#define DNS_TYPE_MB 0x0007 // 7 +#define DNS_TYPE_MG 0x0008 // 8 +#define DNS_TYPE_MR 0x0009 // 9 +#define DNS_TYPE_NULL 0x000a // 10 +#define DNS_TYPE_WKS 0x000b // 11 +#define DNS_TYPE_PTR 0x000c // 12 +#define DNS_TYPE_HINFO 0x000d // 13 +#define DNS_TYPE_MINFO 0x000e // 14 +#define DNS_TYPE_MX 0x000f // 15 +#define DNS_TYPE_TEXT 0x0010 // 16 + +// RFC 1183 +#define DNS_TYPE_RP 0x0011 // 17 +#define DNS_TYPE_AFSDB 0x0012 // 18 +#define DNS_TYPE_X25 0x0013 // 19 +#define DNS_TYPE_ISDN 0x0014 // 20 +#define DNS_TYPE_RT 0x0015 // 21 + +// RFC 1348 +#define DNS_TYPE_NSAP 0x0016 // 22 +#define DNS_TYPE_NSAPPTR 0x0017 // 23 + +// RFC 2065 (DNS security) +#define DNS_TYPE_SIG 0x0018 // 24 +#define DNS_TYPE_KEY 0x0019 // 25 + +// RFC 1664 (X.400 mail) +#define DNS_TYPE_PX 0x001a // 26 + +// RFC 1712 (Geographic position) +#define DNS_TYPE_GPOS 0x001b // 27 + +// RFC 1886 (IPv6 Address) +#define DNS_TYPE_AAAA 0x001c // 28 + +// RFC 1876 (Geographic location) +#define DNS_TYPE_LOC 0x001d // 29 + +// RFC 2065 (Secure negative response) +#define DNS_TYPE_NXT 0x001e // 30 +// Patton (Endpoint Identifier) +#define DNS_TYPE_EID 0x001f // 31 + +// Patton (Nimrod Locator) +#define DNS_TYPE_NIMLOC 0x0020 // 32 + +// RFC 2052 (Service location) +#define DNS_TYPE_SRV 0x0021 // 33 + +// ATM Standard something-or-another (ATM Address) +#define DNS_TYPE_ATMA 0x0022 // 34 + +// RFC 2168 (Naming Authority Pointer) +#define DNS_TYPE_NAPTR 0x0023 // 35 + +// RFC 2230 (Key Exchanger) +#define DNS_TYPE_KX 0x0024 // 36 + +// RFC 2538 (CERT) +#define DNS_TYPE_CERT 0x0025 // 37 + +// A6 Draft (A6) +#define DNS_TYPE_A6 0x0026 // 38 + +// DNAME Draft (DNAME) +#define DNS_TYPE_DNAME 0x0027 // 39 + +// Eastlake (Kitchen Sink) +#define DNS_TYPE_SINK 0x0028 // 40 + +// RFC 2671 (EDNS OPT) +#define DNS_TYPE_OPT 0x0029 // 41 + +// RFC 4034 (DNSSEC DS) +#define DNS_TYPE_DS 0x002b // 43 + +// RFC 4034 (DNSSEC RRSIG) +#define DNS_TYPE_RRSIG 0x002e // 46 + +// RFC 4034 (DNSSEC NSEC) +#define DNS_TYPE_NSEC 0x002f // 47 + +// RFC 4034 (DNSSEC DNSKEY) +#define DNS_TYPE_DNSKEY 0x0030 // 48 + +// RFC 4701 (DHCID) +#define DNS_TYPE_DHCID 0x0031 // 49 + +// RFC 5155 (DNSSEC NSEC3) +#define DNS_TYPE_NSEC3 0x0032 // 50 +// RFC 5155 (DNSSEC NSEC3PARAM) +#define DNS_TYPE_NSEC3PARAM 0x0033 // 51 + +// +// IANA Reserved +// + +#define DNS_TYPE_UINFO 0x0064 // 100 +#define DNS_TYPE_UID 0x0065 // 101 +#define DNS_TYPE_GID 0x0066 // 102 +#define DNS_TYPE_UNSPEC 0x0067 // 103 + +// +// Query only types (1035, 1995) +// - Crawford (ADDRS) +// - TKEY draft (TKEY) +// - TSIG draft (TSIG) +// - RFC 1995 (IXFR) +// - RFC 1035 (AXFR up) +// +#define DNS_TYPE_ADDRS 0x00f8 // 248 +#define DNS_TYPE_TKEY 0x00f9 // 249 +#define DNS_TYPE_TSIG 0x00fa // 250 +#define DNS_TYPE_IXFR 0x00fb // 251 +#define DNS_TYPE_AXFR 0x00fc // 252 +#define DNS_TYPE_MAILB 0x00fd // 253 +#define DNS_TYPE_MAILA 0x00fe // 254 +#define DNS_TYPE_ALL 0x00ff // 255 +#define DNS_TYPE_ANY 0x00ff // 255 +// +// Private use Microsoft types -- See www.iana.org/assignments/dns-parameters +// +#define DNS_TYPE_WINS 0xff01 // 64K - 255 +#define DNS_TYPE_WINSR 0xff02 // 64K - 254 +#define DNS_TYPE_NBSTAT (DNS_TYPE_WINSR) + +// +// DNS Query API +// + +// +// Options for DnsQuery +// + +#define DNS_QUERY_STANDARD 0x00000000 +#define DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE 0x00000001 +#define DNS_QUERY_USE_TCP_ONLY 0x00000002 +#define DNS_QUERY_NO_RECURSION 0x00000004 +#define DNS_QUERY_BYPASS_CACHE 0x00000008 +#define DNS_QUERY_NO_WIRE_QUERY 0x00000010 +#define DNS_QUERY_NO_LOCAL_NAME 0x00000020 +#define DNS_QUERY_NO_HOSTS_FILE 0x00000040 +#define DNS_QUERY_NO_NETBT 0x00000080 +#define DNS_QUERY_WIRE_ONLY 0x00000100 +#define DNS_QUERY_RETURN_MESSAGE 0x00000200 +#define DNS_QUERY_MULTICAST_ONLY 0x00000400 +#define DNS_QUERY_NO_MULTICAST 0x00000800 +#define DNS_QUERY_TREAT_AS_FQDN 0x00001000 +#define DNS_QUERY_ADDRCONFIG 0x00002000 +#define DNS_QUERY_DUAL_ADDR 0x00004000 +#define DNS_QUERY_DONT_RESET_TTL_VALUES 0x00100000 +#define DNS_QUERY_DISABLE_IDN_ENCODING 0x00200000 +#define DNS_QUERY_APPEND_MULTILABEL 0x00800000 +#define DNS_QUERY_DNSSEC_OK 0x01000000 +#define DNS_QUERY_DNSSEC_CHECKING_DISABLED 0x02000000 +#define DNS_QUERY_RESERVED 0xf0000000 + diff --git a/ctypes_generation/definitions/defines/specific_access_right.txt b/ctypes_generation/definitions/defines/specific_access_right.txt index d70258b..cf675c0 100644 --- a/ctypes_generation/definitions/defines/specific_access_right.txt +++ b/ctypes_generation/definitions/defines/specific_access_right.txt @@ -269,4 +269,25 @@ #define COM_ACTIVATE_LOCAL (0x0008) #define COM_ACTIVATE_REMOTE (0x0010) +// +// Section Access Rights. +// + +// begin_winnt +#define SECTION_QUERY 0x0001 +#define SECTION_MAP_WRITE 0x0002 +#define SECTION_MAP_READ 0x0004 +#define SECTION_MAP_EXECUTE 0x0008 +#define SECTION_EXTEND_SIZE 0x0010 +#define SECTION_MAP_EXECUTE_EXPLICIT 0x0020 // not included in SECTION_ALL_ACCESS + +#define SECTION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SECTION_QUERY| SECTION_MAP_WRITE |SECTION_MAP_READ |SECTION_MAP_EXECUTE |SECTION_EXTEND_SIZE) + + + +#define FILE_MAP_COPY SECTION_QUERY +#define FILE_MAP_WRITE SECTION_MAP_WRITE +#define FILE_MAP_READ SECTION_MAP_READ +#define FILE_MAP_ALL_ACCESS SECTION_ALL_ACCESS +#define FILE_MAP_EXECUTE SECTION_MAP_EXECUTE_EXPLICIT \ No newline at end of file diff --git a/ctypes_generation/definitions/defines/symbols.txt b/ctypes_generation/definitions/defines/symbols.txt new file mode 100644 index 0000000..8d5d0e7 --- /dev/null +++ b/ctypes_generation/definitions/defines/symbols.txt @@ -0,0 +1,4 @@ +#define SYMSEARCH_MASKOBJS 0x01 // used internally to implement other APIs +#define SYMSEARCH_RECURSE 0X02 // recurse scopes +#define SYMSEARCH_GLOBALSONLY 0X04 // search only for global symbols +#define SYMSEARCH_ALLITEMS 0X08 // search for everything in the pdb, not just normal scoped symbols \ No newline at end of file diff --git a/ctypes_generation/definitions/defines/windef.txt b/ctypes_generation/definitions/defines/windef.txt index 1671ce3..9e38837 100644 --- a/ctypes_generation/definitions/defines/windef.txt +++ b/ctypes_generation/definitions/defines/windef.txt @@ -442,22 +442,8 @@ #define SECURITY_MANDATORY_SYSTEM_RID (0x00004000L) #define SECURITY_MANDATORY_PROTECTED_PROCESS_RID (0x00005000L) -#define SECTION_QUERY 0x0001 -#define SECTION_MAP_WRITE 0x0002 -#define SECTION_MAP_READ 0x0004 -#define SECTION_MAP_EXECUTE 0x0008 -#define SECTION_EXTEND_SIZE 0x0010 -#define SECTION_MAP_EXECUTE_EXPLICIT 0x0020 -#define SECTION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SECTION_QUERY| SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE) - -#define FILE_MAP_COPY SECTION_QUERY -#define FILE_MAP_WRITE SECTION_MAP_WRITE -#define FILE_MAP_READ SECTION_MAP_READ -#define FILE_MAP_ALL_ACCESS SECTION_ALL_ACCESS -#define FILE_MAP_EXECUTE SECTION_MAP_EXECUTE_EXPLICIT - #define SC_MANAGER_CONNECT 0x0001 #define SC_MANAGER_CREATE_SERVICE 0x0002 diff --git a/ctypes_generation/definitions/defines/windef_error.txt b/ctypes_generation/definitions/defines/windef_error.txt index 1feec9d..dd03952 100644 --- a/ctypes_generation/definitions/defines/windef_error.txt +++ b/ctypes_generation/definitions/defines/windef_error.txt @@ -508,6 +508,30 @@ #define ERROR_RESOURCE_NAME_NOT_FOUND 1814L #define ERROR_RESOURCE_LANG_NOT_FOUND 1815L + +//////////////////////////////////// +// // +// WMI Error Codes // +// // +//////////////////////////////////// + +#define ERROR_WMI_GUID_NOT_FOUND 4200L +#define ERROR_WMI_INSTANCE_NOT_FOUND 4201L +#define ERROR_WMI_ITEMID_NOT_FOUND 4202L +#define ERROR_WMI_TRY_AGAIN 4203L +#define ERROR_WMI_DP_NOT_FOUND 4204L +#define ERROR_WMI_UNRESOLVED_INSTANCE_REF 4205L +#define ERROR_WMI_ALREADY_ENABLED 4206L +#define ERROR_WMI_GUID_DISCONNECTED 4207L +#define ERROR_WMI_SERVER_UNAVAILABLE 4208L +#define ERROR_WMI_DP_FAILED 4209L +#define ERROR_WMI_INVALID_MOF 4210L +#define ERROR_WMI_INVALID_REGINFO 4211L +#define ERROR_WMI_ALREADY_DISABLED 4212L +#define ERROR_WMI_READ_ONLY 4213L +#define ERROR_WMI_SET_FAILURE 4214L + + #define ERROR_INVALID_TRANSACTION 6700 #define ERROR_TRANSACTION_NOT_ACTIVE 6701 #define ERROR_TRANSACTION_REQUEST_NOT_VALID 6702 diff --git a/ctypes_generation/definitions/functions/alpc.txt b/ctypes_generation/definitions/functions/alpc.txt index c24ad9d..4da4136 100644 --- a/ctypes_generation/definitions/functions/alpc.txt +++ b/ctypes_generation/definitions/functions/alpc.txt @@ -174,3 +174,11 @@ NTSTATUS WINAPI NtAlpcImpersonateClientOfPort( _In_ PPORT_MESSAGE Message, _In_ PVOID Flags ); + +// Not documented +NTSTATUS WINAPI TpCallbackSendAlpcMessageOnCompletion( + _In_ HANDLE TpHandle, + _In_ HANDLE PortHandle, + _In_ ULONG Flags, + _In_opt_ PPORT_MESSAGE SendMessage, +); diff --git a/ctypes_generation/definitions/functions/event_trace.txt b/ctypes_generation/definitions/functions/event_trace.txt new file mode 100644 index 0000000..cd0ba42 --- /dev/null +++ b/ctypes_generation/definitions/functions/event_trace.txt @@ -0,0 +1,134 @@ +ULONG WINAPI EnumerateTraceGuidsEx( + _In_ TRACE_QUERY_INFO_CLASS TraceQueryInfoClass, + _In_ PVOID InBuffer, + _In_ ULONG InBufferSize, + _Out_ PVOID OutBuffer, + _In_ ULONG OutBufferSize, + _Out_ PULONG ReturnLength +); + + +ULONG WINAPI QueryAllTracesA( + _Out_ PEVENT_TRACE_PROPERTIES *PropertyArray, + _In_ ULONG PropertyArrayCount, + _Out_ PULONG SessionCount +); + + +ULONG WINAPI QueryAllTracesW( + _Out_ PEVENT_TRACE_PROPERTIES *PropertyArray, + _In_ ULONG PropertyArrayCount, + _Out_ PULONG SessionCount +); + + +TRACEHANDLE WINAPI OpenTraceA( + _Inout_ PEVENT_TRACE_LOGFILEA Logfile +); + + +TRACEHANDLE WINAPI OpenTraceW( + _Inout_ PEVENT_TRACE_LOGFILEW Logfile +); + + +ULONG StartTraceA( + PTRACEHANDLE TraceHandle, + LPCSTR InstanceName, + PEVENT_TRACE_PROPERTIES Properties +); + + +ULONG StartTraceW( + PTRACEHANDLE TraceHandle, + LPCWSTR InstanceName, + PEVENT_TRACE_PROPERTIES Properties +); + + +ULONG StopTraceA( + TRACEHANDLE TraceHandle, + LPCSTR InstanceName, + PEVENT_TRACE_PROPERTIES Properties +); + + +ULONG StopTraceW( + TRACEHANDLE TraceHandle, + LPCWSTR InstanceName, + PEVENT_TRACE_PROPERTIES Properties +); + + +ULONG ControlTraceA( + TRACEHANDLE TraceHandle, + LPCSTR InstanceName, + PEVENT_TRACE_PROPERTIES Properties, + ULONG ControlCode +); + + +ULONG ControlTraceW( + TRACEHANDLE TraceHandle, + LPCWSTR InstanceName, + PEVENT_TRACE_PROPERTIES Properties, + ULONG ControlCode +); + + +ULONG WINAPI ProcessTrace( + _In_ PTRACEHANDLE HandleArray, + _In_ ULONG HandleCount, + _In_ LPFILETIME StartTime, + _In_ LPFILETIME EndTime +); + + +ULONG WINAPI EnableTrace( + _In_ ULONG Enable, + _In_ ULONG EnableFlag, + _In_ ULONG EnableLevel, + _In_ LPCGUID ControlGuid, + _In_ TRACEHANDLE SessionHandle +); + + +ULONG WINAPI EnableTraceEx( + _In_ LPCGUID ProviderId, + _In_opt_ LPCGUID SourceId, + _In_ TRACEHANDLE TraceHandle, + _In_ ULONG IsEnabled, + _In_ UCHAR Level, + _In_ ULONGLONG MatchAnyKeyword, + _In_ ULONGLONG MatchAllKeyword, + _In_ ULONG EnableProperty, + _In_opt_ PEVENT_FILTER_DESCRIPTOR EnableFilterDesc +); + + +ULONG WINAPI EnableTraceEx2( + _In_ TRACEHANDLE TraceHandle, + _In_ LPCGUID ProviderId, + _In_ ULONG ControlCode, + _In_ UCHAR Level, + _In_ ULONGLONG MatchAnyKeyword, + _In_ ULONGLONG MatchAllKeyword, + _In_ ULONG Timeout, + _In_opt_ PENABLE_TRACE_PARAMETERS EnableParameters +); + +ULONG WINAPI TraceQueryInformation( + _In_ TRACEHANDLE SessionHandle, + _In_ TRACE_QUERY_INFO_CLASS InformationClass, + _Out_ PVOID TraceInformation, + _In_ ULONG InformationLength, + _Out_opt_ PULONG ReturnLength +); + + +ULONG WINAPI TraceSetInformation( + _In_ TRACEHANDLE SessionHandle, + _In_ TRACE_INFO_CLASS InformationClass, + _In_ PVOID TraceInformation, + _In_ ULONG InformationLength +); \ No newline at end of file diff --git a/ctypes_generation/definitions/functions/network.txt b/ctypes_generation/definitions/functions/network.txt new file mode 100644 index 0000000..49a0fe5 --- /dev/null +++ b/ctypes_generation/definitions/functions/network.txt @@ -0,0 +1,62 @@ +DWORD WINAPI GetExtendedTcpTable( + _Out_ PVOID pTcpTable, + _Inout_ PDWORD pdwSize, + _In_ BOOL bOrder, + _In_ ULONG ulAf, + _In_ TCP_TABLE_CLASS TableClass, + _In_ ULONG Reserved +); + +DWORD WINAPI GetExtendedUdpTable( + _Out_ PVOID pUdpTable, + _Inout_ PDWORD pdwSize, + _In_ BOOL bOrder, + _In_ ULONG ulAf, + _In_ UDP_TABLE_CLASS TableClass, + _In_ ULONG Reserved +); + +DWORD WINAPI SetTcpEntry( + _In_ PMIB_TCPROW pTcpRow +); + + +DWORD DnsGetCacheDataTable( + PDNS_CACHE_ENTRY *DnsEntries +); + + +VOID WINAPI DnsFree( + _In_ PVOID pData, + _In_ DNS_FREE_TYPE FreeType +); + + +DNS_STATUS DnsQuery_A( + PCSTR pszName, + WORD wType, + DWORD Options, + PVOID pExtra, + PDNS_RECORDA *ppQueryResults, + PVOID *pReserved +); + + +DNS_STATUS DnsQuery_W( + PCWSTR pszName, + WORD wType, + DWORD Options, + PVOID pExtra, + PDNS_RECORDW *ppQueryResults, + PVOID *pReserved +); + + +// DNS_STATUS DnsQuery_UTF8( +// PCSTR pszName, +// WORD wType, +// DWORD Options, +// PVOID pExtra, +// PDNS_RECORD *ppQueryResults, +// PVOID *pReserved +// ); \ No newline at end of file diff --git a/ctypes_generation/definitions/functions/ntregistry.txt b/ctypes_generation/definitions/functions/ntregistry.txt index 2ba548b..9f4087a 100644 --- a/ctypes_generation/definitions/functions/ntregistry.txt +++ b/ctypes_generation/definitions/functions/ntregistry.txt @@ -34,6 +34,13 @@ NTSTATUS NtQueryValueKey( PULONG ResultLength ); +NTSTATUS NtQueryKey( + HANDLE KeyHandle, + KEY_INFORMATION_CLASS KeyInformationClass, + PVOID KeyInformation, + ULONG Length, + PULONG ResultLength +); NTSTATUS NtEnumerateValueKey( HANDLE KeyHandle, diff --git a/ctypes_generation/definitions/functions/security.txt b/ctypes_generation/definitions/functions/security.txt index 51ec530..9d39e61 100644 --- a/ctypes_generation/definitions/functions/security.txt +++ b/ctypes_generation/definitions/functions/security.txt @@ -140,4 +140,22 @@ BOOL WINAPI GetAclInformation( _Out_ LPVOID pAclInformation, _In_ DWORD nAclInformationLength, _In_ ACL_INFORMATION_CLASS dwAclInformationClass - ); \ No newline at end of file + ); + +/* VOID */ +PVOID MapGenericMask( + PDWORD AccessMask, + PGENERIC_MAPPING GenericMapping +); + +BOOL AccessCheck( + PSECURITY_DESCRIPTOR pSecurityDescriptor, + HANDLE ClientToken, + DWORD DesiredAccess, + PGENERIC_MAPPING GenericMapping, + PPRIVILEGE_SET PrivilegeSet, + LPDWORD PrivilegeSetLength, + LPDWORD GrantedAccess, + LPBOOL AccessStatus +); + diff --git a/ctypes_generation/definitions/functions/symbols.txt b/ctypes_generation/definitions/functions/symbols.txt new file mode 100644 index 0000000..b841200 --- /dev/null +++ b/ctypes_generation/definitions/functions/symbols.txt @@ -0,0 +1,149 @@ +DWORD64 WINAPI SymLoadModuleExA( + _In_ HANDLE hProcess, + _In_ HANDLE hFile, + _In_ PCSTR ImageName, + _In_ PCSTR ModuleName, + _In_ DWORD64 BaseOfDll, + _In_ DWORD DllSize, + _In_ PMODLOAD_DATA Data, + _In_ DWORD Flags +); + + +DWORD64 WINAPI SymLoadModuleExW( + _In_ HANDLE hProcess, + _In_ HANDLE hFile, + _In_ PCWSTR ImageName, + _In_ PCWSTR ModuleName, + _In_ DWORD64 BaseOfDll, + _In_ DWORD DllSize, + _In_ PMODLOAD_DATA Data, + _In_ DWORD Flags +); + + +BOOL WINAPI SymFromAddr( + _In_ HANDLE hProcess, + _In_ DWORD64 Address, + _Out_opt_ PDWORD64 Displacement, + _Inout_ PSYMBOL_INFO Symbol +); + + +BOOL WINAPI SymGetModuleInfo64( + _In_ HANDLE hProcess, + _In_ DWORD64 dwAddr, + _Out_ PIMAGEHLP_MODULE64 ModuleInfo +); + +BOOL WINAPI SymInitialize( + _In_ HANDLE hProcess, + _In_opt_ LPCSTR UserSearchPath, + _In_ BOOL fInvadeProcess +); + +BOOL WINAPI SymFromName( + _In_ HANDLE hProcess, + _In_ LPCSTR Name, + _Inout_ PSYMBOL_INFO Symbol +); + + + +DWORD64 WINAPI SymLoadModuleEx( + _In_ HANDLE hProcess, + _In_ HANDLE hFile, + _In_ LPCSTR ImageName, + _In_ LPCSTR ModuleName, + _In_ DWORD64 BaseOfDll, + _In_ DWORD DllSize, + _In_ PMODLOAD_DATA Data, + _In_ DWORD Flags +); + +DWORD WINAPI SymSetOptions( + _In_ DWORD SymOptions +); + + +BOOL WINAPI SymEnumSymbols( + _In_ HANDLE hProcess, + _In_ ULONG64 BaseOfDll, + _In_ PCSTR Mask, + _In_ PVOID EnumSymbolsCallback, + _In_ PVOID UserContext +); + + +BOOL WINAPI SymEnumSymbolsEx( + _In_ HANDLE hProcess, + _In_ ULONG64 BaseOfDll, + _In_ PCSTR Mask, + _In_ PVOID EnumSymbolsCallback, + _In_ PVOID UserContext, + _In_ DWORD Options +); + +BOOL WINAPI SymEnumTypes( + _In_ HANDLE hProcess, + _In_ ULONG64 BaseOfDll, + _In_ PVOID EnumSymbolsCallback, + _In_ PVOID UserContext +); + +BOOL WINAPI SymEnumTypesByName( + _In_ HANDLE hProcess, + _In_ ULONG64 BaseOfDll, + _In_ PCSTR mask, + _In_ PVOID EnumSymbolsCallback, + _In_ PVOID UserContext +); + +BOOL WINAPI SymEnumerateModules64( + _In_ HANDLE hProcess, + _In_ PVOID EnumModulesCallback, + _In_ PVOID UserContext +); + + +BOOL WINAPI SymGetTypeFromName( + _In_ HANDLE hProcess, + _In_ ULONG64 BaseOfDll, + _In_ PCSTR Name, + _Inout_ PSYMBOL_INFO Symbol +); + + +BOOL WINAPI SymGetTypeInfo( + _In_ HANDLE hProcess, + _In_ DWORD64 ModBase, + _In_ ULONG TypeId, + _In_ IMAGEHLP_SYMBOL_TYPE_INFO GetType, + _Out_ PVOID pInfo +); + + +BOOL SymSearch( + HANDLE hProcess, + ULONG64 BaseOfDll, + DWORD Index, + DWORD SymTag, + PCSTR Mask, + DWORD64 Address, + PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, + PVOID UserContext, + DWORD Options +); + + +BOOL SymSearchW( + HANDLE hProcess, + ULONG64 BaseOfDll, + DWORD Index, + DWORD SymTag, + PCWSTR Mask, + DWORD64 Address, + PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, + PVOID UserContext, + DWORD Options +); \ No newline at end of file diff --git a/ctypes_generation/definitions/functions/syscall.txt b/ctypes_generation/definitions/functions/syscall.txt new file mode 100644 index 0000000..44097e8 --- /dev/null +++ b/ctypes_generation/definitions/functions/syscall.txt @@ -0,0 +1,353 @@ +/* + + ALPC syscall are in alpc.txt + NtWow64* are still in winfunc (make a syswow.txt?) + +*/ + + +NTSTATUS NtQueryLicenseValue( + PUNICODE_STRING Name, + ULONG *Type, + PVOID Buffer, + ULONG Length, + ULONG *DataLength +); + +NTSTATUS WINAPI NtQueryEaFile( + _In_ HANDLE FileHandle, + _Out_ PIO_STATUS_BLOCK IoStatusBlock, + _Out_writes_bytes_(Length) PVOID Buffer, + _In_ ULONG Length, + _In_ BOOLEAN ReturnSingleEntry, + _In_reads_bytes_opt_(EaListLength) PVOID EaList, + _In_ ULONG EaListLength, + _In_opt_ PULONG EaIndex, + _In_ BOOLEAN RestartScan +); + +NTSTATUS WINAPI NtSetEaFile( + _In_ HANDLE FileHandle, + _Out_ PIO_STATUS_BLOCK IoStatusBlock, + _In_reads_bytes_(Length) PVOID Buffer, + _In_ ULONG Length +); + + +NTSTATUS WINAPI NtCreateProcessEx( + _Out_ PHANDLE ProcessHandle, + _In_ ACCESS_MASK DesiredAccess, + _In_ POBJECT_ATTRIBUTES ObjectAttributes, + _In_ HANDLE ParentProcess, + _In_ ULONG Flags, + _In_ HANDLE SectionHandle, + _In_ HANDLE DebugPort, + _In_ HANDLE ExceptionPort, + _In_ BOOLEAN InJob +); + + +NTSTATUS WINAPI NtCreateNamedPipeFile( + _Out_ PHANDLE NamedPipeFileHandle, + _In_ ACCESS_MASK DesiredAccess, + _In_ POBJECT_ATTRIBUTES ObjectAttributes, + _Out_ PIO_STATUS_BLOCK IoStatusBlock, + _In_ ULONG ShareAccess, + _In_ ULONG CreateDisposition, + _In_ ULONG CreateOptions, + _In_ BOOLEAN WriteModeMessage, + _In_ BOOLEAN ReadModeMessage, + _In_ BOOLEAN NonBlocking, + _In_ ULONG MaxInstances, + _In_ ULONG InBufferSize, + _In_ ULONG OutBufferSize, + _In_ PLARGE_INTEGER DefaultTimeOut +); + + +NTSTATUS WINAPI NtCreateFile( + _Out_ PHANDLE FileHandle, + _In_ ACCESS_MASK DesiredAccess, + _In_ POBJECT_ATTRIBUTES ObjectAttributes, + _Out_ PIO_STATUS_BLOCK IoStatusBlock, + _In_opt_ PLARGE_INTEGER AllocationSize, + _In_ ULONG FileAttributes, + _In_ ULONG ShareAccess, + _In_ ULONG CreateDisposition, + _In_ ULONG CreateOptions, + _In_ PVOID EaBuffer, + _In_ ULONG EaLength +); + + +NTSTATUS WINAPI NtOpenFile( + _Out_ PHANDLE FileHandle, + _In_ ACCESS_MASK DesiredAccess, + _In_ POBJECT_ATTRIBUTES ObjectAttributes, + _Out_ PIO_STATUS_BLOCK IoStatusBlock, + _In_ ULONG ShareAccess, + _In_ ULONG OpenOptions +); + + +NTSTATUS WINAPI NtCreateSymbolicLinkObject ( + _Out_ PHANDLE pHandle, + _In_ ACCESS_MASK DesiredAccess, + _In_ POBJECT_ATTRIBUTES ObjectAttributes, + _In_ PUNICODE_STRING DestinationName +); + + +NTSTATUS WINAPI NtSetInformationProcess( + _In_ HANDLE ProcessHandle, + _In_ PROCESS_INFORMATION_CLASS ProcessInformationClass, + _In_ PVOID ProcessInformation, + _In_ ULONG ProcessInformationLength +); + +NTSTATUS WINAPI NtQueryVirtualMemory( + _In_ HANDLE ProcessHandle, + _In_opt_ PVOID BaseAddress, + _In_ MEMORY_INFORMATION_CLASS MemoryInformationClass, + _Out_ PVOID MemoryInformation, + _In_ SIZE_T MemoryInformationLength, + _Out_opt_ PSIZE_T ReturnLength +); + +NTSTATUS WINAPI NtQueryVolumeInformationFile( + _In_ HANDLE FileHandle, + _Out_ PIO_STATUS_BLOCK IoStatusBlock, + _Out_ PVOID FsInformation, + _In_ ULONG Length, + _In_ FS_INFORMATION_CLASS FsInformationClass +); + +NTSTATUS NtCreateThreadEx( + PHANDLE ThreadHandle, + ACCESS_MASK DesiredAccess, + LPVOID ObjectAttributes, + HANDLE ProcessHandle, + LPTHREAD_START_ROUTINE lpStartAddress, + LPVOID lpParameter, + BOOL CreateSuspended, + DWORD dwStackSize, + DWORD Unknown1, + DWORD Unknown2, + LPVOID Unknown3 +); + + +NTSTATUS WINAPI NtGetContextThread( + __in HANDLE hThread, + __inout LPCONTEXT lpContext +); + +NTSTATUS WINAPI NtSetContextThread( + __in HANDLE hThread, + __in CONST LPCONTEXT lpContext +); + +NTSTATUS WINAPI NtQueryInformationThread ( + _In_ HANDLE ThreadHandle, + _In_ THREAD_INFORMATION_CLASS ThreadInformationClass, + _Out_ PVOID ThreadInformation, + _In_ ULONG ThreadInformationLength, + _Out_ PULONG ReturnLength +); + + +NTSTATUS WINAPI NtAllocateVirtualMemory( + _In_ HANDLE ProcessHandle, + _Inout_ PVOID *BaseAddress, + _In_ ULONG_PTR ZeroBits, + _Inout_ PSIZE_T RegionSize, + _In_ ULONG AllocationType, + _In_ ULONG Protect +); + + +NTSTATUS WINAPI NtProtectVirtualMemory( + _In_ HANDLE ProcessHandle, + _Inout_ PVOID *BaseAddress, + _Inout_ PULONG NumberOfBytesToProtect, + _In_ ULONG NewAccessProtection, + _Out_ PULONG OldAccessProtection +); + +NTSTATUS WINAPI NtQuerySystemInformation( + _In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, + _Inout_ PVOID SystemInformation, + _In_ ULONG SystemInformationLength, + _Out_opt_ PULONG ReturnLength +); + + +NTSTATUS WINAPI NtQueryInformationProcess( + _In_ HANDLE ProcessHandle, + _In_ PROCESSINFOCLASS ProcessInformationClass, + _Out_ PVOID ProcessInformation, + _In_ ULONG ProcessInformationLength, + _Out_opt_ PULONG ReturnLength +); + + + +NTSTATUS WINAPI NtReadVirtualMemory( + _In_ HANDLE hProcess, + _In_ PVOID lpBaseAddress, + _Out_ LPVOID lpBuffer, + _In_ ULONG nSize, + _Out_ PULONG lpNumberOfBytesRead +); + + +NTSTATUS WINAPI NtWriteVirtualMemory( + _In_ HANDLE ProcessHandle, + _In_ PVOID BaseAddress, + _In_ PVOID Buffer, + _In_ ULONG NumberOfBytesToWrite, + _Out_ PULONG NumberOfBytesWritten +); + + +NTSTATUS WINAPI NtOpenEvent( + __out PHANDLE EventHandle, + __in ACCESS_MASK DesiredAccess, + __in POBJECT_ATTRIBUTES ObjectAttributes +); + + +NTSTATUS WINAPI NtQueryObject( + _In_opt_ HANDLE Handle, + _In_ OBJECT_INFORMATION_CLASS ObjectInformationClass, + _Out_opt_ PVOID ObjectInformation, + _In_ ULONG ObjectInformationLength, + _Out_opt_ PULONG ReturnLength +); + + +NTSTATUS WINAPI NtOpenDirectoryObject( + __out PHANDLE DirectoryHandle, + __in ACCESS_MASK DesiredAccess, + __in POBJECT_ATTRIBUTES ObjectAttributes +); + + +NTSTATUS WINAPI NtQueryDirectoryObject( + __in HANDLE DirectoryHandle, + __out PVOID Buffer, + __in ULONG Length, + __in BOOLEAN ReturnSingleEntry, + __in BOOLEAN RestartScan, + __inout PULONG Context, + _Out_opt_ PULONG ReturnLength + ); + +NTSTATUS WINAPI NtQuerySymbolicLinkObject( + _In_ HANDLE LinkHandle, + _Inout_ PUNICODE_STRING LinkTarget, + _Out_opt_ PULONG ReturnedLength +); + +NTSTATUS WINAPI NtOpenSymbolicLinkObject( + _Out_ PHANDLE LinkHandle, + _In_ ACCESS_MASK DesiredAccess, + _In_ POBJECT_ATTRIBUTES ObjectAttributes +); + + +NTSTATUS WINAPI NtQueryInformationFile( + _In_ HANDLE FileHandle, + _Out_ PIO_STATUS_BLOCK IoStatusBlock, + _Out_ PVOID FileInformation, + _In_ ULONG Length, + _In_ FILE_INFORMATION_CLASS FileInformationClass +); + +NTSTATUS WINAPI NtQueryDirectoryFile( + _In_ HANDLE FileHandle, + _In_opt_ HANDLE Event, + _In_opt_ PIO_APC_ROUTINE ApcRoutine, + _In_opt_ PVOID ApcContext, + _Out_ PIO_STATUS_BLOCK IoStatusBlock, + _Out_ PVOID FileInformation, + _In_ ULONG Length, + _In_ FILE_INFORMATION_CLASS FileInformationClass, + _In_ BOOLEAN ReturnSingleEntry, + _In_opt_ PUNICODE_STRING FileName, + _In_ BOOLEAN RestartScan +); + + +NTSTATUS NtSetInformationFile( + HANDLE FileHandle, + PIO_STATUS_BLOCK IoStatusBlock, + PVOID FileInformation, + ULONG Length, + FILE_INFORMATION_CLASS FileInformationClass +); + + +NTSTATUS WINAPI NtEnumerateSystemEnvironmentValuesEx( + _In_ ULONG InformationClass, + _In_ PVOID Buffer, + _In_ ULONG BufferLength +); + + + +NTSTATUS WINAPI NtFreeVirtualMemory( + _In_ HANDLE ProcessHandle, + _Inout_ PVOID *BaseAddress, + _Inout_ PSIZE_T RegionSize, + _In_ ULONG FreeType +); + + + +NTSTATUS WINAPI NtGetContextThread( + __in HANDLE hThread, + __inout LPCONTEXT lpContext +); + + +NTSTATUS WINAPI NtSetContextThread( + __in HANDLE hThread, + __in CONST LPCONTEXT lpContext +); + + +NTSTATUS NtCreateSection( + PHANDLE SectionHandle, + ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes, + PLARGE_INTEGER MaximumSize, + ULONG SectionPageProtection, + ULONG AllocationAttributes, + HANDLE FileHandle +); + +NTSTATUS NtOpenSection( + PHANDLE SectionHandle, + ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes +); + +NTSTATUS NtMapViewOfSection( + HANDLE SectionHandle, + HANDLE ProcessHandle, + PVOID *BaseAddress, + ULONG_PTR ZeroBits, + SIZE_T CommitSize, + PLARGE_INTEGER SectionOffset, + PSIZE_T ViewSize, + SECTION_INHERIT InheritDisposition, + ULONG AllocationType, + ULONG Win32Protect +); + +NTSTATUS NtUnmapViewOfSection( + HANDLE ProcessHandle, + PVOID BaseAddress +); + diff --git a/ctypes_generation/definitions/functions/time.txt b/ctypes_generation/definitions/functions/time.txt new file mode 100644 index 0000000..31a6979 --- /dev/null +++ b/ctypes_generation/definitions/functions/time.txt @@ -0,0 +1,19 @@ +BOOL FileTimeToSystemTime( + FILETIME *lpFileTime, + LPSYSTEMTIME lpSystemTime +); + +BOOL SystemTimeToFileTime( + SYSTEMTIME *lpSystemTime, + LPFILETIME lpFileTime +); + +// void +PVOID GetSystemTime( + LPSYSTEMTIME lpSystemTime +); + +// void +PVOID GetSystemTimeAsFileTime( + LPFILETIME lpSystemTimeAsFileTime +); \ No newline at end of file diff --git a/ctypes_generation/definitions/functions/trace_data_helper.txt b/ctypes_generation/definitions/functions/trace_data_helper.txt new file mode 100644 index 0000000..37670bd --- /dev/null +++ b/ctypes_generation/definitions/functions/trace_data_helper.txt @@ -0,0 +1,4 @@ +TDHSTATUS TdhEnumerateProviders( + PPROVIDER_ENUMERATION_INFO pBuffer, + ULONG *pBufferSize +); \ No newline at end of file diff --git a/ctypes_generation/definitions/functions/winfunc.txt b/ctypes_generation/definitions/functions/winfunc.txt index 70fc73f..711e28b 100644 --- a/ctypes_generation/definitions/functions/winfunc.txt +++ b/ctypes_generation/definitions/functions/winfunc.txt @@ -32,19 +32,7 @@ HANDLE WINAPI CreateFileW( ); -NTSTATUS WINAPI NtCreateFile( - _Out_ PHANDLE FileHandle, - _In_ ACCESS_MASK DesiredAccess, - _In_ POBJECT_ATTRIBUTES ObjectAttributes, - _Out_ PIO_STATUS_BLOCK IoStatusBlock, - _In_opt_ PLARGE_INTEGER AllocationSize, - _In_ ULONG FileAttributes, - _In_ ULONG ShareAccess, - _In_ ULONG CreateDisposition, - _In_ ULONG CreateOptions, - _In_ PVOID EaBuffer, - _In_ ULONG EaLength -); + NTSTATUS WINAPI LdrLoadDll( __in_opt LPCWSTR PathToFile, @@ -53,67 +41,8 @@ NTSTATUS WINAPI LdrLoadDll( _Out_ PHANDLE ModuleHandle ); -NTSTATUS WINAPI NtQuerySystemInformation( - _In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, - _Inout_ PVOID SystemInformation, - _In_ ULONG SystemInformationLength, - _Out_opt_ PULONG ReturnLength -); -NTSTATUS WINAPI NtQueryInformationProcess( - _In_ HANDLE ProcessHandle, - _In_ PROCESSINFOCLASS ProcessInformationClass, - _Out_ PVOID ProcessInformation, - _In_ ULONG ProcessInformationLength, - _Out_opt_ PULONG ReturnLength -); - -NTSTATUS WINAPI NtSetInformationProcess( - _In_ HANDLE ProcessHandle, - _In_ PROCESS_INFORMATION_CLASS ProcessInformationClass, - _In_ PVOID ProcessInformation, - _In_ ULONG ProcessInformationLength -); - -NTSTATUS WINAPI NtQueryVirtualMemory( - _In_ HANDLE ProcessHandle, - _In_opt_ PVOID BaseAddress, - _In_ MEMORY_INFORMATION_CLASS MemoryInformationClass, - _Out_ PVOID MemoryInformation, - _In_ SIZE_T MemoryInformationLength, - _Out_opt_ PSIZE_T ReturnLength -); - -NTSTATUS WINAPI NtQueryVolumeInformationFile( - _In_ HANDLE FileHandle, - _Out_ PIO_STATUS_BLOCK IoStatusBlock, - _Out_ PVOID FsInformation, - _In_ ULONG Length, - _In_ FS_INFORMATION_CLASS FsInformationClass -); - -NTSTATUS NtCreateThreadEx( - PHANDLE ThreadHandle, - ACCESS_MASK DesiredAccess, - LPVOID ObjectAttributes, - HANDLE ProcessHandle, - LPTHREAD_START_ROUTINE lpStartAddress, - LPVOID lpParameter, - BOOL CreateSuspended, - DWORD dwStackSize, - DWORD Unknown1, - DWORD Unknown2, - LPVOID Unknown3 -); - -NTSTATUS WINAPI NtQueryInformationThread ( - _In_ HANDLE ThreadHandle, - _In_ THREAD_INFORMATION_CLASS ThreadInformationClass, - _Out_ PVOID ThreadInformation, - _In_ ULONG ThreadInformationLength, - _Out_ PULONG ReturnLength -); BOOL WINAPI GetExitCodeThread( _In_ HANDLE hThread, @@ -150,24 +79,8 @@ LPVOID WINAPI VirtualAllocEx( _In_ DWORD flProtect ); -NTSTATUS WINAPI NtAllocateVirtualMemory( - _In_ HANDLE ProcessHandle, - _Inout_ PVOID *BaseAddress, - _In_ ULONG_PTR ZeroBits, - _Inout_ PSIZE_T RegionSize, - _In_ ULONG AllocationType, - _In_ ULONG Protect -); -NTSTATUS WINAPI NtProtectVirtualMemory( - _In_ HANDLE ProcessHandle, - _Inout_ PVOID *BaseAddress, - _Inout_ PULONG NumberOfBytesToProtect, - _In_ ULONG NewAccessProtection, - _Out_ PULONG OldAccessProtection -); - BOOL WINAPI VirtualFree( _In_ LPVOID lpAddress, @@ -183,12 +96,6 @@ BOOL WINAPI VirtualFreeEx( ); -NTSTATUS WINAPI NtFreeVirtualMemory( - _In_ HANDLE ProcessHandle, - _Inout_ PVOID *BaseAddress, - _Inout_ PSIZE_T RegionSize, - _In_ ULONG FreeType -); BOOL WINAPI VirtualProtect( _In_ LPVOID lpAddress, @@ -330,20 +237,12 @@ BOOL WINAPI GetThreadContext( __inout LPCONTEXT lpContext ); -NTSTATUS WINAPI NtGetContextThread( - __in HANDLE hThread, - __inout LPCONTEXT lpContext -); BOOL WINAPI SetThreadContext( __in HANDLE hThread, __in CONST LPCONTEXT lpContext ); -NTSTATUS WINAPI NtSetContextThread( - __in HANDLE hThread, - __in CONST LPCONTEXT lpContext -); HANDLE WINAPI OpenThread( @@ -378,13 +277,7 @@ NTSTATUS WINAPI NtWow64ReadVirtualMemory64( _Out_ PULONG64 lpNumberOfBytesRead ); -NTSTATUS WINAPI NtReadVirtualMemory( - _In_ HANDLE hProcess, - _In_ PVOID lpBaseAddress, - _Out_ LPVOID lpBuffer, - _In_ ULONG nSize, - _Out_ PULONG lpNumberOfBytesRead -); + BOOL WINAPI WriteProcessMemory( @@ -405,13 +298,6 @@ NTSTATUS WINAPI NtWow64WriteVirtualMemory64( ); -NTSTATUS WINAPI NtWriteVirtualMemory( - _In_ HANDLE ProcessHandle, - _In_ PVOID BaseAddress, - _In_ PVOID Buffer, - _In_ ULONG NumberOfBytesToWrite, - _Out_ PULONG NumberOfBytesWritten -); HANDLE WINAPI CreateToolhelp32Snapshot( @@ -625,27 +511,6 @@ BOOL WINAPI WriteFile( _Inout_opt_ LPOVERLAPPED lpOverlapped ); -DWORD WINAPI GetExtendedTcpTable( - _Out_ PVOID pTcpTable, - _Inout_ PDWORD pdwSize, - _In_ BOOL bOrder, - _In_ ULONG ulAf, - _In_ TCP_TABLE_CLASS TableClass, - _In_ ULONG Reserved -); - -DWORD WINAPI GetExtendedUdpTable( - _Out_ PVOID pUdpTable, - _Inout_ PDWORD pdwSize, - _In_ BOOL bOrder, - _In_ ULONG ulAf, - _In_ UDP_TABLE_CLASS TableClass, - _In_ ULONG Reserved -); - -DWORD WINAPI SetTcpEntry( - _In_ PMIB_TCPROW pTcpRow -); PVOID WINAPI AddVectoredContinueHandler( _In_ ULONG FirstHandler, @@ -981,39 +846,6 @@ NTSTATUS RtlGetCompressionWorkSpaceSize( PULONG CompressFragmentWorkSpaceSize ); -NTSTATUS NtCreateSection( - PHANDLE SectionHandle, - ACCESS_MASK DesiredAccess, - POBJECT_ATTRIBUTES ObjectAttributes, - PLARGE_INTEGER MaximumSize, - ULONG SectionPageProtection, - ULONG AllocationAttributes, - HANDLE FileHandle -); - -NTSTATUS NtOpenSection( - PHANDLE SectionHandle, - ACCESS_MASK DesiredAccess, - POBJECT_ATTRIBUTES ObjectAttributes -); - -NTSTATUS NtMapViewOfSection( - HANDLE SectionHandle, - HANDLE ProcessHandle, - PVOID *BaseAddress, - ULONG_PTR ZeroBits, - SIZE_T CommitSize, - PLARGE_INTEGER SectionOffset, - PSIZE_T ViewSize, - SECTION_INHERIT InheritDisposition, - ULONG AllocationType, - ULONG Win32Protect -); - -NTSTATUS NtUnmapViewOfSection( - HANDLE ProcessHandle, - PVOID BaseAddress -); HANDLE WINAPI OpenEventA( __in DWORD dwDesiredAccess, @@ -1028,11 +860,6 @@ HANDLE WINAPI OpenEventW( __in LPCWSTR lpName ); -NTSTATUS WINAPI NtOpenEvent( - __out PHANDLE EventHandle, - __in ACCESS_MASK DesiredAccess, - __in POBJECT_ATTRIBUTES ObjectAttributes -); INT WINAPI lstrcmpA( @@ -1237,13 +1064,7 @@ BOOL WINAPI FindNextVolumeW( _In_ DWORD cchBufferLength ); -NTSTATUS WINAPI NtQueryObject( - _In_opt_ HANDLE Handle, - _In_ OBJECT_INFORMATION_CLASS ObjectInformationClass, - _Out_opt_ PVOID ObjectInformation, - _In_ ULONG ObjectInformationLength, - _Out_opt_ PULONG ReturnLength -); + BOOL WINAPI DuplicateHandle( _In_ HANDLE hSourceProcessHandle, @@ -1382,35 +1203,6 @@ DWORD WINAPI GetIpAddrTable( _In_ BOOL bOrder ); -NTSTATUS WINAPI NtOpenDirectoryObject( - __out PHANDLE DirectoryHandle, - __in ACCESS_MASK DesiredAccess, - __in POBJECT_ATTRIBUTES ObjectAttributes -); - - -NTSTATUS WINAPI NtQueryDirectoryObject( - __in HANDLE DirectoryHandle, - __out PVOID Buffer, - __in ULONG Length, - __in BOOLEAN ReturnSingleEntry, - __in BOOLEAN RestartScan, - __inout PULONG Context, - _Out_opt_ PULONG ReturnLength - ); - -NTSTATUS WINAPI NtQuerySymbolicLinkObject( - _In_ HANDLE LinkHandle, - _Inout_ PUNICODE_STRING LinkTarget, - _Out_opt_ PULONG ReturnedLength -); - -NTSTATUS WINAPI NtOpenSymbolicLinkObject( - _Out_ PHANDLE LinkHandle, - _In_ ACCESS_MASK DesiredAccess, - _In_ POBJECT_ATTRIBUTES ObjectAttributes -); - BOOL WINAPI GetProcessTimes( _In_ HANDLE hProcess, _Out_ LPFILETIME lpCreationTime, @@ -1588,29 +1380,6 @@ VOID WINAPI RtlGetUnloadEventTraceEx( ); -NTSTATUS WINAPI NtQueryInformationFile( - _In_ HANDLE FileHandle, - _Out_ PIO_STATUS_BLOCK IoStatusBlock, - _Out_ PVOID FileInformation, - _In_ ULONG Length, - _In_ FILE_INFORMATION_CLASS FileInformationClass -); - -NTSTATUS WINAPI NtQueryDirectoryFile( - _In_ HANDLE FileHandle, - _In_opt_ HANDLE Event, - _In_opt_ PIO_APC_ROUTINE ApcRoutine, - _In_opt_ PVOID ApcContext, - _Out_ PIO_STATUS_BLOCK IoStatusBlock, - _Out_ PVOID FileInformation, - _In_ ULONG Length, - _In_ FILE_INFORMATION_CLASS FileInformationClass, - _In_ BOOLEAN ReturnSingleEntry, - _In_opt_ PUNICODE_STRING FileName, - _In_ BOOLEAN RestartScan -); - - BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( _In_ PCWSTR DosName, _Out_ PUNICODE_STRING NtName, @@ -1661,13 +1430,7 @@ BOOL WINAPI GetProductInfo( ); -NTSTATUS NtSetInformationFile( - HANDLE FileHandle, - PIO_STATUS_BLOCK IoStatusBlock, - PVOID FileInformation, - ULONG Length, - FILE_INFORMATION_CLASS FileInformationClass -); + BOOL GetProcessMemoryInfo( @@ -1723,10 +1486,6 @@ DWORD WINAPI GetFirmwareEnvironmentVariableExW( _Out_ PDWORD pdwAttribubutes ); -NTSTATUS WINAPI NtEnumerateSystemEnvironmentValuesEx( - _In_ ULONG InformationClass, - _In_ PVOID Buffer, - _In_ ULONG BufferLength -); + diff --git a/ctypes_generation/definitions/functions/winfunc_notdoc.txt b/ctypes_generation/definitions/functions/winfunc_notdoc.txt index e11a2b2..e69de29 100644 --- a/ctypes_generation/definitions/functions/winfunc_notdoc.txt +++ b/ctypes_generation/definitions/functions/winfunc_notdoc.txt @@ -1,47 +0,0 @@ -NTSTATUS WINAPI TpCallbackSendAlpcMessageOnCompletion( - _In_ HANDLE TpHandle, - _In_ HANDLE PortHandle, - _In_ ULONG Flags, - _In_opt_ PPORT_MESSAGE SendMessage, -); - - -NTSTATUS NtQueryLicenseValue( - PUNICODE_STRING Name, - ULONG *Type, - PVOID Buffer, - ULONG Length, - ULONG *DataLength -); - -NTSTATUS WINAPI NtQueryEaFile( - _In_ HANDLE FileHandle, - _Out_ PIO_STATUS_BLOCK IoStatusBlock, - _Out_writes_bytes_(Length) PVOID Buffer, - _In_ ULONG Length, - _In_ BOOLEAN ReturnSingleEntry, - _In_reads_bytes_opt_(EaListLength) PVOID EaList, - _In_ ULONG EaListLength, - _In_opt_ PULONG EaIndex, - _In_ BOOLEAN RestartScan -); - -NTSTATUS WINAPI NtSetEaFile( - _In_ HANDLE FileHandle, - _Out_ PIO_STATUS_BLOCK IoStatusBlock, - _In_reads_bytes_(Length) PVOID Buffer, - _In_ ULONG Length -); - - -NTSTATUS WINAPI NtCreateProcessEx( - _Out_ PHANDLE ProcessHandle, - _In_ ACCESS_MASK DesiredAccess, - _In_ POBJECT_ATTRIBUTES ObjectAttributes, - _In_ HANDLE ParentProcess, - _In_ ULONG Flags, - _In_ HANDLE SectionHandle, - _In_ HANDLE DebugPort, - _In_ HANDLE ExceptionPort, - _In_ BOOLEAN InJob -); \ No newline at end of file diff --git a/ctypes_generation/definitions/simple_types.txt b/ctypes_generation/definitions/simple_types.txt index c0bf201..8d93bcb 100644 --- a/ctypes_generation/definitions/simple_types.txt +++ b/ctypes_generation/definitions/simple_types.txt @@ -7,6 +7,7 @@ PSIZE_T = POINTER(SIZE_T) PVOID = c_void_p NTSTATUS = DWORD TDHSTATUS = ULONG +DNS_STATUS = ULONG SECURITY_INFORMATION = DWORD PSECURITY_INFORMATION = POINTER(SECURITY_INFORMATION) PULONG = POINTER(ULONG) @@ -78,6 +79,8 @@ NCRYPT_PROV_HANDLE = ULONG_PTR NCRYPT_KEY_HANDLE = ULONG_PTR NCRYPT_HASH_HANDLE = ULONG_PTR NCRYPT_SECRET_HANDLE = ULONG_PTR +TRACEHANDLE = ULONG64 +PTRACEHANDLE = POINTER(TRACEHANDLE) /* INT sized*/ @@ -106,6 +109,10 @@ HCRYPTPROV_OR_NCRYPT_KEY_HANDLE = PULONG EVT_HANDLE = HANDLE EVT_OBJECT_ARRAY_PROPERTY_HANDLE = HANDLE +/* Network */ + +IP4_ADDRESS = DWORD // Make a extended struct ? + /* Security */ PSECURITY_DESCRIPTOR = PVOID diff --git a/ctypes_generation/definitions/structures/event_trace.txt b/ctypes_generation/definitions/structures/event_trace.txt new file mode 100644 index 0000000..6b3b6f4 --- /dev/null +++ b/ctypes_generation/definitions/structures/event_trace.txt @@ -0,0 +1,308 @@ +typedef enum { + TraceGuidQueryList, + TraceGuidQueryInfo, + TraceGuidQueryProcess, + TraceStackTracingInfo, + TraceSystemTraceEnableFlagsInfo, + TraceSampledProfileIntervalInfo, + TraceProfileSourceConfigInfo, + TraceProfileSourceListInfo, + TracePmcEventListInfo, + TracePmcCounterListInfo, + TraceSetDisallowList, + TraceVersionInfo, + TraceGroupQueryList, + TraceGroupQueryInfo, + TraceDisallowListQuery, + TraceInfoReserved15, // Reserved, not on MSDN... + TracePeriodicCaptureStateListInfo, + TracePeriodicCaptureStateInfo, + TraceProviderBinaryTracking, + TraceMaxLoggersQuery, + MaxTraceSetInfoClass +} TRACE_INFO_CLASS, TRACE_QUERY_INFO_CLASS; + + + +typedef struct _TRACE_GUID_INFO { + ULONG InstanceCount; + ULONG Reserved; +} TRACE_GUID_INFO, *PTRACE_GUID_INFO; + + +typedef struct _TRACE_PROVIDER_INSTANCE_INFO { + ULONG NextOffset; + ULONG EnableCount; + ULONG Pid; + ULONG Flags; +} TRACE_PROVIDER_INSTANCE_INFO, *PTRACE_PROVIDER_INSTANCE_INFO; + + +typedef struct _TRACE_ENABLE_INFO { + ULONG IsEnabled; + UCHAR Level; + UCHAR Reserved1; + USHORT LoggerId; + ULONG EnableProperty; + ULONG Reserved2; + ULONGLONG MatchAnyKeyword; + ULONGLONG MatchAllKeyword; +} TRACE_ENABLE_INFO, *PTRACE_ENABLE_INFO; + + +typedef struct _WNODE_HEADER { + ULONG BufferSize; + ULONG ProviderId; + union { + ULONG64 HistoricalContext; + struct { + ULONG Version; + ULONG Linkage; + }; + }; + union { + HANDLE KernelHandle; + LARGE_INTEGER TimeStamp; + }; + GUID Guid; + ULONG ClientContext; + ULONG Flags; +} WNODE_HEADER, *PWNODE_HEADER; + +typedef struct _EVENT_TRACE_PROPERTIES { + WNODE_HEADER Wnode; + ULONG BufferSize; + ULONG MinimumBuffers; + ULONG MaximumBuffers; + ULONG MaximumFileSize; + ULONG LogFileMode; + ULONG FlushTimer; + ULONG EnableFlags; + LONG AgeLimit; + ULONG NumberOfBuffers; + ULONG FreeBuffers; + ULONG EventsLost; + ULONG BuffersWritten; + ULONG LogBuffersLost; + ULONG RealTimeBuffersLost; + HANDLE LoggerThreadId; + ULONG LogFileNameOffset; + ULONG LoggerNameOffset; +} EVENT_TRACE_PROPERTIES, *PEVENT_TRACE_PROPERTIES; + +typedef struct _EVENT_TRACE_HEADER { + USHORT Size; + union { + USHORT FieldTypeFlags; + struct { + BYTE HeaderType; + BYTE MarkerFlags; + }; + }; + union { + ULONG Version; + struct { + BYTE Type; + BYTE Level; + USHORT Version; + }Class; + }; + ULONG ThreadId; + ULONG ProcessId; + LARGE_INTEGER TimeStamp; + union { + GUID Guid; + ULONGLONG GuidPtr; + }; + union { + struct { + ULONG KernelTime; + ULONG UserTime; + }; + ULONG64 ProcessorTime; + struct { + ULONG ClientContext; + ULONG Flags; + }; + }; +} EVENT_TRACE_HEADER, *PEVENT_TRACE_HEADER; + +typedef struct _ETW_BUFFER_CONTEXT { + union { + struct { + BYTE ProcessorNumber; + BYTE Alignment; + }; + USHORT ProcessorIndex; + }; + USHORT LoggerId; +} ETW_BUFFER_CONTEXT, *PETW_BUFFER_CONTEXT; + +typedef struct _EVENT_TRACE { + EVENT_TRACE_HEADER Header; + ULONG InstanceId; + ULONG ParentInstanceId; + GUID ParentGuid; + PVOID MofData; + ULONG MofLength; + union { + ULONG ClientContext; + ETW_BUFFER_CONTEXT BufferContext; + }; +} EVENT_TRACE, *PEVENT_TRACE; + + +typedef struct _TRACE_LOGFILE_HEADER { + ULONG BufferSize; // Logger buffer size in Kbytes + union { + ULONG Version; // Logger version + struct { + UCHAR MajorVersion; + UCHAR MinorVersion; + UCHAR SubVersion; + UCHAR SubMinorVersion; + } VersionDetail; + } DUMMYUNIONNAME; + ULONG ProviderVersion; // defaults to NT version + ULONG NumberOfProcessors; // Number of Processors + LARGE_INTEGER EndTime; // Time when logger stops + ULONG TimerResolution; // assumes timer is constant!!! + ULONG MaximumFileSize; // Maximum in Mbytes + ULONG LogFileMode; // specify logfile mode + ULONG BuffersWritten; // used to file start of Circular File + union { + GUID LogInstanceGuid; // For RealTime Buffer Delivery + struct { + ULONG StartBuffers; // Count of buffers written at start. + ULONG PointerSize; // Size of pointer type in bits + ULONG EventsLost; // Events losts during log session + ULONG CpuSpeedInMHz; // Cpu Speed in MHz + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME2; + LPWSTR LoggerName; + LPWSTR LogFileName; + TIME_ZONE_INFORMATION TimeZone; + LARGE_INTEGER BootTime; + LARGE_INTEGER PerfFreq; // Reserved + LARGE_INTEGER StartTime; // Reserved + ULONG ReservedFlags; // ClockType + ULONG BuffersLost; +} TRACE_LOGFILE_HEADER, *PTRACE_LOGFILE_HEADER; + + +typedef struct _EVENT_TRACE_LOGFILEA { + LPSTR LogFileName; + LPSTR LoggerName; + LONGLONG CurrentTime; + ULONG BuffersRead; + union { + ULONG LogFileMode; + ULONG ProcessTraceMode; + }; + EVENT_TRACE CurrentEvent; + TRACE_LOGFILE_HEADER LogfileHeader; + PEVENT_TRACE_BUFFER_CALLBACKA BufferCallback; + ULONG BufferSize; + ULONG Filled; + ULONG EventsLost; + union { + PEVENT_CALLBACK EventCallback; + PEVENT_RECORD_CALLBACK EventRecordCallback; + }; + ULONG IsKernelTrace; + PVOID Context; +} EVENT_TRACE_LOGFILEA, *PEVENT_TRACE_LOGFILEA; + + +typedef struct _EVENT_TRACE_LOGFILEW { + LPWSTR LogFileName; + LPWSTR LoggerName; + LONGLONG CurrentTime; + ULONG BuffersRead; + union { + ULONG LogFileMode; + ULONG ProcessTraceMode; + }; + EVENT_TRACE CurrentEvent; + TRACE_LOGFILE_HEADER LogfileHeader; + PEVENT_TRACE_BUFFER_CALLBACKW BufferCallback; + ULONG BufferSize; + ULONG Filled; + ULONG EventsLost; + union { + PEVENT_CALLBACK EventCallback; + PEVENT_RECORD_CALLBACK EventRecordCallback; + }; + ULONG IsKernelTrace; + PVOID Context; +} EVENT_TRACE_LOGFILEW, *PEVENT_TRACE_LOGFILEW; + + +typedef struct _EVENT_FILTER_DESCRIPTOR { + ULONGLONG Ptr; + ULONG Size; + ULONG Type; +} EVENT_FILTER_DESCRIPTOR, *PEVENT_FILTER_DESCRIPTOR; + + + +typedef struct _ENABLE_TRACE_PARAMETERS { + ULONG Version; + ULONG EnableProperty; + ULONG ControlFlags; + GUID SourceId; + PEVENT_FILTER_DESCRIPTOR EnableFilterDesc; + ULONG FilterDescCount; +} ENABLE_TRACE_PARAMETERS, *PENABLE_TRACE_PARAMETERS; + +typedef struct _EVENT_DESCRIPTOR { + USHORT Id; + BYTE Version; + BYTE Channel; + BYTE Level; + BYTE Opcode; + USHORT Task; + ULONGLONG Keyword; +} EVENT_DESCRIPTOR, *PEVENT_DESCRIPTOR; + +typedef struct _EVENT_HEADER { + USHORT Size; + USHORT HeaderType; + USHORT Flags; + USHORT EventProperty; + ULONG ThreadId; + ULONG ProcessId; + LARGE_INTEGER TimeStamp; + GUID ProviderId; + EVENT_DESCRIPTOR EventDescriptor; + union { + struct { + ULONG KernelTime; + ULONG UserTime; + } DUMMYSTRUCTNAME; + ULONG64 ProcessorTime; + } DUMMYUNIONNAME; + GUID ActivityId; +} EVENT_HEADER, *PEVENT_HEADER; + + +typedef struct _EVENT_HEADER_EXTENDED_DATA_ITEM { + USHORT Reserved1; + USHORT ExtType; + struct { + USHORT Linkage : 1; + USHORT Reserved2 : 15; + }; + USHORT DataSize; + ULONGLONG DataPtr; +} EVENT_HEADER_EXTENDED_DATA_ITEM, *PEVENT_HEADER_EXTENDED_DATA_ITEM; + +typedef struct _EVENT_RECORD { + EVENT_HEADER EventHeader; + ETW_BUFFER_CONTEXT BufferContext; + USHORT ExtendedDataCount; + USHORT UserDataLength; + PEVENT_HEADER_EXTENDED_DATA_ITEM ExtendedData; + PVOID UserData; + PVOID UserContext; +} EVENT_RECORD, *PEVENT_RECORD; \ No newline at end of file diff --git a/ctypes_generation/definitions/structures/guid.txt b/ctypes_generation/definitions/structures/guid.txt index 9158dc3..f1b95dc 100644 --- a/ctypes_generation/definitions/structures/guid.txt +++ b/ctypes_generation/definitions/structures/guid.txt @@ -5,4 +5,4 @@ typedef struct _GUID { USHORT Data2; USHORT Data3; BYTE Data4[ 8 ]; -} GUID, IID, CLSID, *REFIID, *REFCLSID, *LPGUID, *REFGUID, *LPCLSID; \ No newline at end of file +} GUID, IID, CLSID, *REFIID, *REFCLSID, *LPGUID, *REFGUID, *LPCLSID, *LPCGUID; \ No newline at end of file diff --git a/ctypes_generation/definitions/structures/mitigations.txt b/ctypes_generation/definitions/structures/mitigations.txt index 90bcf34..024e77d 100644 --- a/ctypes_generation/definitions/structures/mitigations.txt +++ b/ctypes_generation/definitions/structures/mitigations.txt @@ -14,169 +14,130 @@ typedef enum _PROCESS_MITIGATION_POLICY { // DEP Policy -struct _ANON_PROCESS_MITIGATION_DEP_POLICY_BITFIELD { - DWORD Enable : 1; - DWORD DisableAtlThunkEmulation : 1; - DWORD ReservedFlags : 30; -}; - -union _ANON_PROCESS_MITIGATION_DEP_POLICY_UNION { - DWORD Flags; - _ANON_PROCESS_MITIGATION_DEP_POLICY_BITFIELD anon; -}; - typedef struct _PROCESS_MITIGATION_DEP_POLICY { - _ANON_PROCESS_MITIGATION_DEP_POLICY_UNION anon; + union { + DWORD Flags; + struct { + DWORD Enable : 1; + DWORD DisableAtlThunkEmulation : 1; + DWORD ReservedFlags : 30; + }; + }; BOOLEAN Permanent; } PROCESS_MITIGATION_DEP_POLICY, *PPROCESS_MITIGATION_DEP_POLICY; // ASLR policy -struct _ANON_PROCESS_MITIGATION_ASLR_POLICY_BITFIELD { +typedef struct _PROCESS_MITIGATION_ASLR_POLICY { + union { + DWORD Flags; + struct { DWORD EnableBottomUpRandomization : 1; DWORD EnableForceRelocateImages : 1; DWORD EnableHighEntropy : 1; DWORD DisallowStrippedImages : 1; DWORD ReservedFlags : 28; -}; - -union _ANON_PROCESS_MITIGATION_ASLR_POLICY_UNION { - DWORD Flags; - _ANON_PROCESS_MITIGATION_ASLR_POLICY_BITFIELD anon; -}; - - -typedef struct _PROCESS_MITIGATION_ASLR_POLICY { - _ANON_PROCESS_MITIGATION_ASLR_POLICY_UNION anon; + }; + }; } PROCESS_MITIGATION_ASLR_POLICY, *PPROCESS_MITIGATION_ASLR_POLICY; // Dynamic code policy -struct _ANON_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_BITFIELD { - DWORD ProhibitDynamicCode :1; - DWORD AllowThreadOptOut :1; - DWORD AllowRemoteDowngrade :1; - DWORD ReservedFlags :30; -}; - -union _ANON_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_UNION { - DWORD Flags; - _ANON_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_BITFIELD anon; -}; - typedef struct _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY { - _ANON_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_UNION anon; + union { + DWORD Flags; + struct { + DWORD ProhibitDynamicCode : 1; + DWORD AllowThreadOptOut : 1; + DWORD AllowRemoteDowngrade : 1; + DWORD AuditProhibitDynamicCode : 1; + DWORD ReservedFlags : 28; + }; + }; } PROCESS_MITIGATION_DYNAMIC_CODE_POLICY, *PPROCESS_MITIGATION_DYNAMIC_CODE_POLICY; //Strict handle policy -struct _ANON_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_BITFIELD { - DWORD RaiseExceptionOnInvalidHandleReference : 1; - DWORD HandleExceptionsPermanentlyEnabled : 1; - DWORD ReservedFlags : 30; -}; - -union _ANON_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_UNION { - DWORD Flags; - _ANON_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_BITFIELD ANON_STRUCT; -}; - - typedef struct _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY { - _ANON_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_UNION anon; + union { + DWORD Flags; + struct { + DWORD RaiseExceptionOnInvalidHandleReference : 1; + DWORD HandleExceptionsPermanentlyEnabled : 1; + DWORD ReservedFlags : 30; + }; + }; } PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, *PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY; - - // System Call policy -struct _ANON_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_BITFIELD { - DWORD DisallowWin32kSystemCalls : 1; - DWORD ReservedFlags : 31; -}; - -union _ANON_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_UNION { - DWORD Flags; - _ANON_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_BITFIELD ANON_STRUCT; -}; - typedef struct _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY { - _ANON_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_UNION anon; + union { + DWORD Flags; + struct { + DWORD DisallowWin32kSystemCalls : 1; + DWORD AuditDisallowWin32kSystemCalls : 1; + DWORD ReservedFlags : 30; + }; + }; } PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, *PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY; - // EXTENSION POINT policy -struct _ANON_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_BITFIELD { - DWORD DisableExtensionPoints : 1; - DWORD ReservedFlags : 31; -}; - -union _ANON_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_UNION { - DWORD Flags; - _ANON_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_BITFIELD ANON_STRUCT; -}; - typedef struct _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY { - _ANON_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_UNION anon; + union { + DWORD Flags; + struct { + DWORD DisableExtensionPoints : 1; + DWORD ReservedFlags : 31; + }; + }; } PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY, *PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY; - // CFG policy -struct _ANON_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_BITFIELD { - DWORD EnableControlFlowGuard :1; - DWORD EnableExportSuppression :1; - DWORD StrictMode :1; - DWORD ReservedFlags :29; -}; - -union _ANON_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_UNION { +typedef struct _PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY { + union { DWORD Flags; - _ANON_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_BITFIELD ANON_STRUCT; -}; - -typedef struct _PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY { - _ANON_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_UNION anon; + struct { + DWORD EnableControlFlowGuard : 1; + DWORD EnableExportSuppression : 1; + DWORD StrictMode : 1; + DWORD ReservedFlags : 29; + }; + }; } PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY, *PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY; - // BINARY SIGNATURE policy -struct _ANON_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_BITFIELD { - DWORD MicrosoftSignedOnly :1; - DWORD StoreSignedOnly :1; - DWORD MitigationOptIn :1; - DWORD ReservedFlags :29; -}; - -union _ANON_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_UNION { +typedef struct _PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY { + union { DWORD Flags; - _ANON_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_BITFIELD ANON_STRUCT; -}; - -typedef struct _PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY { - _ANON_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_UNION anon; + struct { + DWORD MicrosoftSignedOnly : 1; + DWORD StoreSignedOnly : 1; + DWORD MitigationOptIn : 1; + DWORD AuditMicrosoftSignedOnly : 1; + DWORD AuditStoreSignedOnly : 1; + DWORD ReservedFlags : 27; + }; + }; } PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY, *PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY; - - // Font disable policy -struct _ANON_PROCESS_MITIGATION_IMAGE_LOAD_POLICY_BITFIELD { - DWORD NoRemoteImages :1; - DWORD NoLowMandatoryLabelImages :1; - DWORD PreferSystem32Images :1; - DWORD ReservedFlags :29; -}; - -union _ANON_PROCESS_MITIGATION_IMAGE_LOAD_POLICY_UNION { +typedef struct _PROCESS_MITIGATION_IMAGE_LOAD_POLICY { + union { DWORD Flags; - _ANON_PROCESS_MITIGATION_IMAGE_LOAD_POLICY_BITFIELD ANON_STRUCT; -}; - -typedef struct _PROCESS_MITIGATION_IMAGE_LOAD_POLICY { - _ANON_PROCESS_MITIGATION_IMAGE_LOAD_POLICY_UNION anon; -} PROCESS_MITIGATION_IMAGE_LOAD_POLICY, *PPROCESS_MITIGATION_IMAGE_LOAD_POLICY; + struct { + DWORD NoRemoteImages : 1; + DWORD NoLowMandatoryLabelImages : 1; + DWORD PreferSystem32Images : 1; + DWORD AuditNoRemoteImages : 1; + DWORD AuditNoLowMandatoryLabelImages : 1; + DWORD ReservedFlags : 27; + }; + }; +} PROCESS_MITIGATION_IMAGE_LOAD_POLICY, *PPROCESS_MITIGATION_IMAGE_LOAD_POLICY; \ No newline at end of file diff --git a/ctypes_generation/definitions/structures/network.txt b/ctypes_generation/definitions/structures/network.txt new file mode 100644 index 0000000..4a6e41f --- /dev/null +++ b/ctypes_generation/definitions/structures/network.txt @@ -0,0 +1,822 @@ +typedef enum _TCP_TABLE_CLASS { + TCP_TABLE_BASIC_LISTENER, + TCP_TABLE_BASIC_CONNECTIONS, + TCP_TABLE_BASIC_ALL, + TCP_TABLE_OWNER_PID_LISTENER, + TCP_TABLE_OWNER_PID_CONNECTIONS, + TCP_TABLE_OWNER_PID_ALL, + TCP_TABLE_OWNER_MODULE_LISTENER, + TCP_TABLE_OWNER_MODULE_CONNECTIONS, + TCP_TABLE_OWNER_MODULE_ALL +} TCP_TABLE_CLASS; + +typedef enum _MIB_TCP_STATE{ + MIB_TCP_STATE_CLOSED = 1, + MIB_TCP_STATE_LISTEN = 2, + MIB_TCP_STATE_SYN_SENT = 3, + MIB_TCP_STATE_SYN_RCVD = 4, + MIB_TCP_STATE_ESTAB = 5, + MIB_TCP_STATE_FIN_WAIT1 = 6, + MIB_TCP_STATE_FIN_WAIT2 = 7, + MIB_TCP_STATE_CLOSE_WAIT = 8, + MIB_TCP_STATE_CLOSING = 9, + MIB_TCP_STATE_LAST_ACK = 10, + MIB_TCP_STATE_TIME_WAIT = 11, + MIB_TCP_STATE_DELETE_TCB = 12, +} MIB_TCP_STATE; + +typedef enum NET_FW_IP_PROTOCOL_ { + NET_FW_IP_PROTOCOL_TCP = 6, + NET_FW_IP_PROTOCOL_UDP = 17, + NET_FW_IP_PROTOCOL_ANY = 256 +} NET_FW_IP_PROTOCOL; + + +typedef struct { + ULONGLONG IP6Qword[2]; // Was QWORD +} IP6_ADDRESS, *PIP6_ADDRESS; + +typedef struct _MIB_IPADDRROW_XP { + DWORD dwAddr; + IF_INDEX dwIndex; + DWORD dwMask; + DWORD dwBCastAddr; + DWORD dwReasmSize; + USHORT unused1; + USHORT wType; +} MIB_IPADDRROW, MIB_IPADDRROW_XP, *PMIB_IPADDRROW_XP; + +typedef struct _MIB_IPADDRTABLE { + DWORD dwNumEntries; + MIB_IPADDRROW table[ANY_SIZE]; +} MIB_IPADDRTABLE, *PMIB_IPADDRTABLE; + + +typedef enum _INTERNAL_IF_OPER_STATUS { + IF_OPER_STATUS_NON_OPERATIONAL = 0, + IF_OPER_STATUS_UNREACHABLE = 1, + IF_OPER_STATUS_DISCONNECTED = 2, + IF_OPER_STATUS_CONNECTING = 3, + IF_OPER_STATUS_CONNECTED = 4, + IF_OPER_STATUS_OPERATIONAL = 5, +} INTERNAL_IF_OPER_STATUS; + +typedef struct _MIB_IFROW { + WCHAR wszName[MAX_INTERFACE_NAME_LEN]; + IF_INDEX dwIndex; + IFTYPE dwType; + DWORD dwMtu; + DWORD dwSpeed; + DWORD dwPhysAddrLen; + BYTE bPhysAddr[MAXLEN_PHYSADDR]; + DWORD dwAdminStatus; + INTERNAL_IF_OPER_STATUS dwOperStatus; + DWORD dwLastChange; + DWORD dwInOctets; + DWORD dwInUcastPkts; + DWORD dwInNUcastPkts; + DWORD dwInDiscards; + DWORD dwInErrors; + DWORD dwInUnknownProtos; + DWORD dwOutOctets; + DWORD dwOutUcastPkts; + DWORD dwOutNUcastPkts; + DWORD dwOutDiscards; + DWORD dwOutErrors; + DWORD dwOutQLen; + DWORD dwDescrLen; + UCHAR bDescr[MAXLEN_IFDESCR]; +} MIB_IFROW, *PMIB_IFROW; + +typedef struct _MIB_IFTABLE { + DWORD dwNumEntries; + MIB_IFROW table[ANY_SIZE]; +} MIB_IFTABLE, *PMIB_IFTABLE; + + +typedef struct _MIB_TCPROW_OWNER_PID { + DWORD dwState; + DWORD dwLocalAddr; + DWORD dwLocalPort; + DWORD dwRemoteAddr; + DWORD dwRemotePort; + DWORD dwOwningPid; +} MIB_TCPROW_OWNER_PID, *PMIB_TCPROW_OWNER_PID; + +typedef struct _MIB_TCPTABLE_OWNER_PID{ + DWORD dwNumEntries; + MIB_TCPROW_OWNER_PID table[ANY_SIZE]; +} MIB_TCPTABLE_OWNER_PID, *PMIB_TCPTABLE_OWNER_PID; + +typedef struct _MIB_UDPROW_OWNER_PID { + DWORD dwLocalAddr; + DWORD dwLocalPort; + DWORD dwOwningPid; +} MIB_UDPROW_OWNER_PID, *PMIB_UDPROW_OWNER_PID; + +typedef struct _MIB_UDPTABLE_OWNER_PID { + DWORD dwNumEntries; + MIB_UDPROW_OWNER_PID table[ANY_SIZE]; +} MIB_UDPTABLE_OWNER_PID, *PMIB_UDPTABLE_OWNER_PID; + + +typedef struct _MIB_UDP6ROW_OWNER_PID { + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + DWORD dwOwningPid; +} MIB_UDP6ROW_OWNER_PID, *PMIB_UDP6ROW_OWNER_PID; + +typedef struct _MIB_UDP6TABLE_OWNER_PID{ + DWORD dwNumEntries; + MIB_UDP6ROW_OWNER_PID table[ANY_SIZE]; +} MIB_UDP6TABLE_OWNER_PID, *PMIB_UDP6TABLE_OWNER_PID; + +typedef struct _MIB_TCP6ROW_OWNER_PID { + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + UCHAR ucRemoteAddr[16]; + DWORD dwRemoteScopeId; + DWORD dwRemotePort; + DWORD dwState; + DWORD dwOwningPid; +} MIB_TCP6ROW_OWNER_PID, *PMIB_TCP6ROW_OWNER_PID; + +typedef struct _MIB_TCP6TABLE_OWNER_PID { + DWORD dwNumEntries; + MIB_TCP6ROW_OWNER_PID table[ANY_SIZE]; +} MIB_TCP6TABLE_OWNER_PID, *PMIB_TCP6TABLE_OWNER_PID; + +typedef struct _MIB_TCPROW { + DWORD dwState; + DWORD dwLocalAddr; + DWORD dwLocalPort; + DWORD dwRemoteAddr; + DWORD dwRemotePort; +} MIB_TCPROW, *PMIB_TCPROW; + +typedef struct _IP_ADAPTER_INDEX_MAP { + ULONG Index; + WCHAR Name[MAX_ADAPTER_NAME]; +} IP_ADAPTER_INDEX_MAP, *PIP_ADAPTER_INDEX_MAP; + +typedef struct _IP_INTERFACE_INFO { + LONG NumAdapters; + IP_ADAPTER_INDEX_MAP Adapter[1]; +} IP_INTERFACE_INFO, *PIP_INTERFACE_INFO; + +// DNS stuff + +typedef enum +{ + DnsFreeFlat = 0, + DnsFreeRecordList, + DnsFreeParsedMessageFields +} +DNS_FREE_TYPE; + +typedef struct _DNS_CACHE_ENTRY +{ + struct _DNS_CACHE_ENTRY* pNext; + PCWSTR pszName; + USHORT wType; + USHORT wDataLength; + ULONG dwFlags; +} DNS_CACHE_ENTRY, *PDNS_CACHE_ENTRY; + + +typedef struct { + IP4_ADDRESS IpAddress; +} DNS_A_DATA, *PDNS_A_DATA; + +typedef struct +{ + PWSTR pNameHost; +} +DNS_PTR_DATAW, *PDNS_PTR_DATAW; + + +typedef struct +{ + PSTR pNameHost; +} +DNS_PTR_DATAA, *PDNS_PTR_DATAA; + + +typedef struct +{ + PWSTR pNamePrimaryServer; + PWSTR pNameAdministrator; + DWORD dwSerialNo; + DWORD dwRefresh; + DWORD dwRetry; + DWORD dwExpire; + DWORD dwDefaultTtl; +} +DNS_SOA_DATAW, *PDNS_SOA_DATAW; + +typedef struct +{ + PSTR pNamePrimaryServer; + PSTR pNameAdministrator; + DWORD dwSerialNo; + DWORD dwRefresh; + DWORD dwRetry; + DWORD dwExpire; + DWORD dwDefaultTtl; +} +DNS_SOA_DATAA, *PDNS_SOA_DATAA; + + +typedef struct +{ + PWSTR pNameMailbox; + PWSTR pNameErrorsMailbox; +} +DNS_MINFO_DATAW, *PDNS_MINFO_DATAW; + +typedef struct +{ + PSTR pNameMailbox; + PSTR pNameErrorsMailbox; +} +DNS_MINFO_DATAA, *PDNS_MINFO_DATAA; + +typedef struct +{ + PWSTR pNameExchange; + WORD wPreference; + WORD Pad; // keep ptrs DWORD aligned +} +DNS_MX_DATAW, *PDNS_MX_DATAW; + +typedef struct +{ + PSTR pNameExchange; + WORD wPreference; + WORD Pad; // keep ptrs DWORD aligned +} +DNS_MX_DATAA, *PDNS_MX_DATAA; + + + +typedef struct +{ + DWORD dwStringCount; + PWSTR pStringArray[1]; +} +DNS_TXT_DATAW, *PDNS_TXT_DATAW; + +typedef struct +{ + DWORD dwStringCount; + PSTR pStringArray[1]; +} +DNS_TXT_DATAA, *PDNS_TXT_DATAA; + + +typedef struct +{ + DWORD dwByteCount; + BYTE Data[1]; +} +DNS_NULL_DATA, *PDNS_NULL_DATA; + +typedef struct +{ + IP4_ADDRESS IpAddress; + UCHAR chProtocol; + BYTE BitMask[1]; +} +DNS_WKS_DATA, *PDNS_WKS_DATA; + +typedef struct +{ + IP6_ADDRESS Ip6Address; +} +DNS_AAAA_DATA, *PDNS_AAAA_DATA; + + +typedef struct +{ + WORD wTypeCovered; + BYTE chAlgorithm; + BYTE chLabelCount; + DWORD dwOriginalTtl; + DWORD dwExpiration; + DWORD dwTimeSigned; + WORD wKeyTag; + WORD wSignatureLength; + PWSTR pNameSigner; + BYTE Signature[1]; +} +DNS_SIG_DATAW, *PDNS_SIG_DATAW, DNS_RRSIG_DATAW, *PDNS_RRSIG_DATAW; + +typedef struct +{ + WORD wTypeCovered; + BYTE chAlgorithm; + BYTE chLabelCount; + DWORD dwOriginalTtl; + DWORD dwExpiration; + DWORD dwTimeSigned; + WORD wKeyTag; + WORD wSignatureLength; + PSTR pNameSigner; + BYTE Signature[1]; +} +DNS_SIG_DATAA, *PDNS_SIG_DATAA, DNS_RRSIG_DATAA, *PDNS_RRSIG_DATAA; + +typedef struct +{ + WORD wFlags; + BYTE chProtocol; + BYTE chAlgorithm; + WORD wKeyLength; + WORD wPad; // keep byte field aligned + BYTE Key[1]; +} +DNS_KEY_DATA, *PDNS_KEY_DATA, DNS_DNSKEY_DATA, *PDNS_DNSKEY_DATA; + + +typedef struct +{ + DWORD dwByteCount; + BYTE DHCID[1]; +} +DNS_DHCID_DATA, *PDNS_DHCID_DATA; + + +typedef struct +{ + PWSTR pNextDomainName; + WORD wTypeBitMapsLength; + WORD wPad; // keep byte field aligned + BYTE TypeBitMaps[1]; +} +DNS_NSEC_DATAW, *PDNS_NSEC_DATAW; + +typedef struct +{ + PSTR pNextDomainName; + WORD wTypeBitMapsLength; + WORD wPad; // keep byte field aligned + BYTE TypeBitMaps[1]; +} +DNS_NSEC_DATAA, *PDNS_NSEC_DATAA; + +typedef struct +{ + BYTE chAlgorithm; + BYTE bFlags; + WORD wIterations; + BYTE bSaltLength; + BYTE bHashLength; + WORD wTypeBitMapsLength; + BYTE chData[1]; +} +DNS_NSEC3_DATA, *PDNS_NSEC3_DATA; + +typedef struct +{ + BYTE chAlgorithm; + BYTE bFlags; + WORD wIterations; + BYTE bSaltLength; + BYTE bPad[3]; // keep salt field aligned + BYTE pbSalt[1]; +} +DNS_NSEC3PARAM_DATA, *PDNS_NSEC3PARAM_DATA; + + +typedef struct +{ + WORD wKeyTag; + BYTE chAlgorithm; + BYTE chDigestType; + WORD wDigestLength; + WORD wPad; // keep byte field aligned + BYTE Digest[1]; +} +DNS_DS_DATA, *PDNS_DS_DATA; + +typedef struct +{ + WORD wDataLength; + WORD wPad; // keep byte field aligned + BYTE Data[1]; +} +DNS_OPT_DATA, *PDNS_OPT_DATA; + + +typedef struct +{ + WORD wVersion; + WORD wSize; + WORD wHorPrec; + WORD wVerPrec; + DWORD dwLatitude; + DWORD dwLongitude; + DWORD dwAltitude; +} +DNS_LOC_DATA, *PDNS_LOC_DATA; + + +typedef struct +{ + PWSTR pNameNext; + WORD wNumTypes; + WORD wTypes[1]; +} +DNS_NXT_DATAW, *PDNS_NXT_DATAW; + +typedef struct +{ + PSTR pNameNext; + WORD wNumTypes; + WORD wTypes[1]; +} +DNS_NXT_DATAA, *PDNS_NXT_DATAA; + +typedef struct +{ + PWSTR pNameTarget; + WORD wPriority; + WORD wWeight; + WORD wPort; + WORD Pad; // keep ptrs DWORD aligned +} +DNS_SRV_DATAW, *PDNS_SRV_DATAW; + +typedef struct +{ + PSTR pNameTarget; + WORD wPriority; + WORD wWeight; + WORD wPort; + WORD Pad; // keep ptrs DWORD aligned +} +DNS_SRV_DATAA, *PDNS_SRV_DATAA; + +typedef struct +{ + WORD wOrder; + WORD wPreference; + PWSTR pFlags; + PWSTR pService; + PWSTR pRegularExpression; + PWSTR pReplacement; +} +DNS_NAPTR_DATAW, *PDNS_NAPTR_DATAW; + +typedef struct +{ + WORD wOrder; + WORD wPreference; + PSTR pFlags; + PSTR pService; + PSTR pRegularExpression; + PSTR pReplacement; +} +DNS_NAPTR_DATAA, *PDNS_NAPTR_DATAA; + + +typedef struct +{ + BYTE AddressType; + BYTE Address[ DNS_ATMA_MAX_ADDR_LENGTH ]; + + // E164 -- Null terminated string of less than + // DNS_ATMA_MAX_ADDR_LENGTH + // + // For NSAP (AESA) BCD encoding of exactly + // DNS_ATMA_AESA_ADDR_LENGTH +} +DNS_ATMA_DATA, *PDNS_ATMA_DATA; + +typedef struct +{ + PWSTR pNameAlgorithm; + PBYTE pAlgorithmPacket; + PBYTE pKey; + PBYTE pOtherData; + DWORD dwCreateTime; + DWORD dwExpireTime; + WORD wMode; + WORD wError; + WORD wKeyLength; + WORD wOtherLength; + UCHAR cAlgNameLength; + BOOL bPacketPointers; +} +DNS_TKEY_DATAW, *PDNS_TKEY_DATAW; + +typedef struct +{ + PSTR pNameAlgorithm; + PBYTE pAlgorithmPacket; + PBYTE pKey; + PBYTE pOtherData; + DWORD dwCreateTime; + DWORD dwExpireTime; + WORD wMode; + WORD wError; + WORD wKeyLength; + WORD wOtherLength; + UCHAR cAlgNameLength; + BOOL bPacketPointers; +} +DNS_TKEY_DATAA, *PDNS_TKEY_DATAA; + + +typedef struct +{ + PWSTR pNameAlgorithm; + PBYTE pAlgorithmPacket; + PBYTE pSignature; + PBYTE pOtherData; + LONGLONG i64CreateTime; + WORD wFudgeTime; + WORD wOriginalXid; + WORD wError; + WORD wSigLength; + WORD wOtherLength; + UCHAR cAlgNameLength; + BOOL bPacketPointers; +} +DNS_TSIG_DATAW, *PDNS_TSIG_DATAW; + +typedef struct +{ + PSTR pNameAlgorithm; + PBYTE pAlgorithmPacket; + PBYTE pSignature; + PBYTE pOtherData; + LONGLONG i64CreateTime; + WORD wFudgeTime; + WORD wOriginalXid; + WORD wError; + WORD wSigLength; + WORD wOtherLength; + UCHAR cAlgNameLength; + BOOL bPacketPointers; +} +DNS_TSIG_DATAA, *PDNS_TSIG_DATAA; + +typedef struct +{ + DWORD dwMappingFlag; + DWORD dwLookupTimeout; + DWORD dwCacheTimeout; + DWORD cWinsServerCount; + IP4_ADDRESS WinsServers[1]; +} +DNS_WINS_DATA, *PDNS_WINS_DATA; + +typedef struct +{ + DWORD dwMappingFlag; + DWORD dwLookupTimeout; + DWORD dwCacheTimeout; + PWSTR pNameResultDomain; +} +DNS_WINSR_DATAW, *PDNS_WINSR_DATAW; + +typedef struct +{ + DWORD dwMappingFlag; + DWORD dwLookupTimeout; + DWORD dwCacheTimeout; + PSTR pNameResultDomain; +} +DNS_WINSR_DATAA, *PDNS_WINSR_DATAA; + +typedef struct +{ + BYTE bCertUsage; + BYTE bSelector; + BYTE bMatchingType; + WORD bCertificateAssociationDataLength; + BYTE bPad[3]; // keep certificate association data field a ligned + BYTE bCertificateAssociationData[1]; +} DNS_TLSA_DATA, *PDNS_TLSA_DATA; + +typedef struct +{ + DWORD dwByteCount; + BYTE bData[1]; +} +DNS_UNKNOWN_DATA, *PDNS_UNKNOWN_DATA; + + +typedef struct _DnsRecordFlags +{ + DWORD Section : 2; + DWORD Delete : 1; + DWORD CharSet : 2; + DWORD Unused : 3; + + DWORD Reserved : 24; +} +DNS_RECORD_FLAGS; + + +typedef struct _DnsRecordA { + struct _DnsRecordA *pNext; + PSTR pName; + WORD wType; + WORD wDataLength; + union { + DWORD DW; + DNS_RECORD_FLAGS S; + } Flags; + DWORD dwTtl; + DWORD dwReserved; + union { + DNS_A_DATA A; + DNS_SOA_DATAA SOA; + DNS_SOA_DATAA Soa; + DNS_PTR_DATAA PTR; + DNS_PTR_DATAA Ptr; + DNS_PTR_DATAA NS; + DNS_PTR_DATAA Ns; + DNS_PTR_DATAA CNAME; + DNS_PTR_DATAA Cname; + DNS_PTR_DATAA DNAME; + DNS_PTR_DATAA Dname; + DNS_PTR_DATAA MB; + DNS_PTR_DATAA Mb; + DNS_PTR_DATAA MD; + DNS_PTR_DATAA Md; + DNS_PTR_DATAA MF; + DNS_PTR_DATAA Mf; + DNS_PTR_DATAA MG; + DNS_PTR_DATAA Mg; + DNS_PTR_DATAA MR; + DNS_PTR_DATAA Mr; + DNS_MINFO_DATAA MINFO; + DNS_MINFO_DATAA Minfo; + DNS_MINFO_DATAA RP; + DNS_MINFO_DATAA Rp; + DNS_MX_DATAA MX; + DNS_MX_DATAA Mx; + DNS_MX_DATAA AFSDB; + DNS_MX_DATAA Afsdb; + DNS_MX_DATAA RT; + DNS_MX_DATAA Rt; + DNS_TXT_DATAA HINFO; + DNS_TXT_DATAA Hinfo; + DNS_TXT_DATAA ISDN; + DNS_TXT_DATAA Isdn; + DNS_TXT_DATAA TXT; + DNS_TXT_DATAA Txt; + DNS_TXT_DATAA X25; + DNS_NULL_DATA Null; + DNS_WKS_DATA WKS; + DNS_WKS_DATA Wks; + DNS_AAAA_DATA AAAA; + DNS_KEY_DATA KEY; + DNS_KEY_DATA Key; + DNS_SIG_DATAA SIG; + DNS_SIG_DATAA Sig; + DNS_ATMA_DATA ATMA; + DNS_ATMA_DATA Atma; + DNS_NXT_DATAA NXT; + DNS_NXT_DATAA Nxt; + DNS_SRV_DATAA SRV; + DNS_SRV_DATAA Srv; + DNS_NAPTR_DATAA NAPTR; + DNS_NAPTR_DATAA Naptr; + DNS_OPT_DATA OPT; + DNS_OPT_DATA Opt; + DNS_DS_DATA DS; + DNS_DS_DATA Ds; + DNS_RRSIG_DATAA RRSIG; + DNS_RRSIG_DATAA Rrsig; + DNS_NSEC_DATAA NSEC; + DNS_NSEC_DATAA Nsec; + DNS_DNSKEY_DATA DNSKEY; + DNS_DNSKEY_DATA Dnskey; + DNS_TKEY_DATAA TKEY; + DNS_TKEY_DATAA Tkey; + DNS_TSIG_DATAA TSIG; + DNS_TSIG_DATAA Tsig; + DNS_WINS_DATA WINS; + DNS_WINS_DATA Wins; + DNS_WINSR_DATAA WINSR; + DNS_WINSR_DATAA WinsR; + DNS_WINSR_DATAA NBSTAT; + DNS_WINSR_DATAA Nbstat; + DNS_DHCID_DATA DHCID; + DNS_NSEC3_DATA NSEC3; + DNS_NSEC3_DATA Nsec3; + DNS_NSEC3PARAM_DATA NSEC3PARAM; + DNS_NSEC3PARAM_DATA Nsec3Param; + DNS_TLSA_DATA TLSA; + DNS_TLSA_DATA Tlsa; + DNS_UNKNOWN_DATA UNKNOWN; + DNS_UNKNOWN_DATA Unknown; + PBYTE pDataPtr; + } Data; +} DNS_RECORDA, *PDNS_RECORDA; + + +typedef struct _DnsRecordW { + struct _DnsRecordW *pNext; + PWSTR pName; + WORD wType; + WORD wDataLength; + union { + DWORD DW; + DNS_RECORD_FLAGS S; + } Flags; + DWORD dwTtl; + DWORD dwReserved; + union { + DNS_A_DATA A; + DNS_SOA_DATAW SOA; + DNS_SOA_DATAW Soa; + DNS_PTR_DATAW PTR; + DNS_PTR_DATAW Ptr; + DNS_PTR_DATAW NS; + DNS_PTR_DATAW Ns; + DNS_PTR_DATAW CNAME; + DNS_PTR_DATAW Cname; + DNS_PTR_DATAW DNAME; + DNS_PTR_DATAW Dname; + DNS_PTR_DATAW MB; + DNS_PTR_DATAW Mb; + DNS_PTR_DATAW MD; + DNS_PTR_DATAW Md; + DNS_PTR_DATAW MF; + DNS_PTR_DATAW Mf; + DNS_PTR_DATAW MG; + DNS_PTR_DATAW Mg; + DNS_PTR_DATAW MR; + DNS_PTR_DATAW Mr; + DNS_MINFO_DATAW MINFO; + DNS_MINFO_DATAW Minfo; + DNS_MINFO_DATAW RP; + DNS_MINFO_DATAW Rp; + DNS_MX_DATAW MX; + DNS_MX_DATAW Mx; + DNS_MX_DATAW AFSDB; + DNS_MX_DATAW Afsdb; + DNS_MX_DATAW RT; + DNS_MX_DATAW Rt; + DNS_TXT_DATAW HINFO; + DNS_TXT_DATAW Hinfo; + DNS_TXT_DATAW ISDN; + DNS_TXT_DATAW Isdn; + DNS_TXT_DATAW TXT; + DNS_TXT_DATAW Txt; + DNS_TXT_DATAW X25; + DNS_NULL_DATA Null; + DNS_WKS_DATA WKS; + DNS_WKS_DATA Wks; + DNS_AAAA_DATA AAAA; + DNS_KEY_DATA KEY; + DNS_KEY_DATA Key; + DNS_SIG_DATAW SIG; + DNS_SIG_DATAW Sig; + DNS_ATMA_DATA ATMA; + DNS_ATMA_DATA Atma; + DNS_NXT_DATAW NXT; + DNS_NXT_DATAW Nxt; + DNS_SRV_DATAW SRV; + DNS_SRV_DATAW Srv; + DNS_NAPTR_DATAW NAPTR; + DNS_NAPTR_DATAW Naptr; + DNS_OPT_DATA OPT; + DNS_OPT_DATA Opt; + DNS_DS_DATA DS; + DNS_DS_DATA Ds; + DNS_RRSIG_DATAW RRSIG; + DNS_RRSIG_DATAW Rrsig; + DNS_NSEC_DATAW NSEC; + DNS_NSEC_DATAW Nsec; + DNS_DNSKEY_DATA DNSKEY; + DNS_DNSKEY_DATA Dnskey; + DNS_TKEY_DATAW TKEY; + DNS_TKEY_DATAW Tkey; + DNS_TSIG_DATAW TSIG; + DNS_TSIG_DATAW Tsig; + DNS_WINS_DATA WINS; + DNS_WINS_DATA Wins; + DNS_WINSR_DATAW WINSR; + DNS_WINSR_DATAW WinsR; + DNS_WINSR_DATAW NBSTAT; + DNS_WINSR_DATAW Nbstat; + DNS_DHCID_DATA DHCID; + DNS_NSEC3_DATA NSEC3; + DNS_NSEC3_DATA Nsec3; + DNS_NSEC3PARAM_DATA NSEC3PARAM; + DNS_NSEC3PARAM_DATA Nsec3Param; + DNS_TLSA_DATA TLSA; + DNS_TLSA_DATA Tlsa; + DNS_UNKNOWN_DATA UNKNOWN; + DNS_UNKNOWN_DATA Unknown; + PBYTE pDataPtr; + } Data; +} DNS_RECORDW, *PDNS_RECORDW; \ No newline at end of file diff --git a/ctypes_generation/definitions/structures/ntregistry.txt b/ctypes_generation/definitions/structures/ntregistry.txt index d21e780..f736e82 100644 --- a/ctypes_generation/definitions/structures/ntregistry.txt +++ b/ctypes_generation/definitions/structures/ntregistry.txt @@ -31,4 +31,19 @@ typedef struct _KEY_VALUE_PARTIAL_INFORMATION { ULONG Type; ULONG DataLength; UCHAR Data[1]; -} KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION; \ No newline at end of file +} KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION; + + +typedef enum _KEY_INFORMATION_CLASS { + KeyBasicInformation, + KeyNodeInformation, + KeyFullInformation, + KeyNameInformation, + KeyCachedInformation, + KeyFlagsInformation, + KeyVirtualizationInformation, + KeyHandleTagsInformation, + KeyTrustInformation, + KeyLayerInformation, + MaxKeyInfoClass +} KEY_INFORMATION_CLASS; \ No newline at end of file diff --git a/ctypes_generation/definitions/structures/security.txt b/ctypes_generation/definitions/structures/security.txt index 454ab58..9118e95 100644 --- a/ctypes_generation/definitions/structures/security.txt +++ b/ctypes_generation/definitions/structures/security.txt @@ -262,4 +262,19 @@ typedef struct _SECURITY_DESCRIPTOR { PSID Group; PACL Sacl; PACL Dacl; -} SECURITY_DESCRIPTOR, *PISECURITY_DESCRIPTOR; \ No newline at end of file +} SECURITY_DESCRIPTOR, *PISECURITY_DESCRIPTOR; + + +typedef struct _GENERIC_MAPPING { + ACCESS_MASK GenericRead; + ACCESS_MASK GenericWrite; + ACCESS_MASK GenericExecute; + ACCESS_MASK GenericAll; +} GENERIC_MAPPING, *PGENERIC_MAPPING; + + +typedef struct _PRIVILEGE_SET { + DWORD PrivilegeCount; + DWORD Control; + LUID_AND_ATTRIBUTES Privilege[ANYSIZE_ARRAY]; +} PRIVILEGE_SET, *PPRIVILEGE_SET; \ No newline at end of file diff --git a/ctypes_generation/definitions/structures/time.txt b/ctypes_generation/definitions/structures/time.txt new file mode 100644 index 0000000..182c0b8 --- /dev/null +++ b/ctypes_generation/definitions/structures/time.txt @@ -0,0 +1,9 @@ +typedef struct _TIME_ZONE_INFORMATION { + LONG Bias; + WCHAR StandardName[32]; + SYSTEMTIME StandardDate; + LONG StandardBias; + WCHAR DaylightName[32]; + SYSTEMTIME DaylightDate; + LONG DaylightBias; +} TIME_ZONE_INFORMATION, *PTIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION; \ No newline at end of file diff --git a/ctypes_generation/definitions/structures/trace_data_helper.txt b/ctypes_generation/definitions/structures/trace_data_helper.txt new file mode 100644 index 0000000..012d8de --- /dev/null +++ b/ctypes_generation/definitions/structures/trace_data_helper.txt @@ -0,0 +1,12 @@ +typedef struct _TRACE_PROVIDER_INFO { + GUID ProviderGuid; + ULONG SchemaSource; + ULONG ProviderNameOffset; +} TRACE_PROVIDER_INFO; + + +typedef struct _PROVIDER_ENUMERATION_INFO { + ULONG NumberOfProviders; + ULONG Reserved; + TRACE_PROVIDER_INFO TraceProviderInfoArray[ANYSIZE_ARRAY]; +} PROVIDER_ENUMERATION_INFO, *PPROVIDER_ENUMERATION_INFO; \ No newline at end of file diff --git a/ctypes_generation/definitions/structures/winstruct.txt b/ctypes_generation/definitions/structures/winstruct.txt index b3dcf55..7fb4c35 100644 --- a/ctypes_generation/definitions/structures/winstruct.txt +++ b/ctypes_generation/definitions/structures/winstruct.txt @@ -122,7 +122,10 @@ typedef struct _PEB { _ANON_PEB_SYSTEM_DEPENDENT_02 _SYSTEM_DEPENDENT_02; _ANON_PEB_SYSTEM_DEPENDENT_03 _SYSTEM_DEPENDENT_03; PVOID _SYSTEM_DEPENDENT_04; - _ANON_PEB_UNION_1 anon_union_1; + union { + PVOID KernelCallbackTable; + PVOID UserSharedInfoPtr; + }; DWORD SystemReserved; DWORD _SYSTEM_DEPENDENT_05; _ANON_PEB_SYSTEM_DEPENDENT_06 _SYSTEM_DEPENDENT_06; @@ -157,8 +160,10 @@ typedef struct _PEB { DWORD ImageSubsystem; DWORD ImageSubsystemMajorVersion; PVOID ImageSubsystemMinorVersion; - - _ANON_PEB_UNION_2 anon_union_2; + union { + PVOID ImageProcessAffinityMask; + PVOID ActiveProcessAffinityMask; + }; PVOID GdiHandleBuffer[26]; BYTE GdiHandleBuffer2[32]; PVOID PostProcessInitRoutine; @@ -483,17 +488,7 @@ typedef enum _THREAD_INFORMATION_CLASS { ThreadHideFromDebugger } THREAD_INFORMATION_CLASS, *PTHREAD_INFORMATION_CLASS; -typedef enum _TCP_TABLE_CLASS { - TCP_TABLE_BASIC_LISTENER, - TCP_TABLE_BASIC_CONNECTIONS, - TCP_TABLE_BASIC_ALL, - TCP_TABLE_OWNER_PID_LISTENER, - TCP_TABLE_OWNER_PID_CONNECTIONS, - TCP_TABLE_OWNER_PID_ALL, - TCP_TABLE_OWNER_MODULE_LISTENER, - TCP_TABLE_OWNER_MODULE_CONNECTIONS, - TCP_TABLE_OWNER_MODULE_ALL -} TCP_TABLE_CLASS; + typedef enum _VARENUM{ VT_EMPTY = 0, @@ -569,26 +564,6 @@ typedef enum NET_FW_PROFILE_TYPE2_ { NET_FW_PROFILE2_ALL = 0x7FFFFFFF } NET_FW_PROFILE_TYPE2; -typedef enum _MIB_TCP_STATE{ - MIB_TCP_STATE_CLOSED = 1, - MIB_TCP_STATE_LISTEN = 2, - MIB_TCP_STATE_SYN_SENT = 3, - MIB_TCP_STATE_SYN_RCVD = 4, - MIB_TCP_STATE_ESTAB = 5, - MIB_TCP_STATE_FIN_WAIT1 = 6, - MIB_TCP_STATE_FIN_WAIT2 = 7, - MIB_TCP_STATE_CLOSE_WAIT = 8, - MIB_TCP_STATE_CLOSING = 9, - MIB_TCP_STATE_LAST_ACK = 10, - MIB_TCP_STATE_TIME_WAIT = 11, - MIB_TCP_STATE_DELETE_TCB = 12, -} MIB_TCP_STATE; - -typedef enum NET_FW_IP_PROTOCOL_ { - NET_FW_IP_PROTOCOL_TCP = 6, - NET_FW_IP_PROTOCOL_UDP = 17, - NET_FW_IP_PROTOCOL_ANY = 256 -} NET_FW_IP_PROTOCOL; @@ -1379,136 +1354,6 @@ typedef struct _OVERLAPPED { HANDLE hEvent; } OVERLAPPED, *LPOVERLAPPED; -typedef struct _MIB_IPADDRROW_XP { - DWORD dwAddr; - IF_INDEX dwIndex; - DWORD dwMask; - DWORD dwBCastAddr; - DWORD dwReasmSize; - USHORT unused1; - USHORT wType; -} MIB_IPADDRROW, MIB_IPADDRROW_XP, *PMIB_IPADDRROW_XP; - -typedef struct _MIB_IPADDRTABLE { - DWORD dwNumEntries; - MIB_IPADDRROW table[ANY_SIZE]; -} MIB_IPADDRTABLE, *PMIB_IPADDRTABLE; - - -typedef enum _INTERNAL_IF_OPER_STATUS { - IF_OPER_STATUS_NON_OPERATIONAL = 0, - IF_OPER_STATUS_UNREACHABLE = 1, - IF_OPER_STATUS_DISCONNECTED = 2, - IF_OPER_STATUS_CONNECTING = 3, - IF_OPER_STATUS_CONNECTED = 4, - IF_OPER_STATUS_OPERATIONAL = 5, -} INTERNAL_IF_OPER_STATUS; - -typedef struct _MIB_IFROW { - WCHAR wszName[MAX_INTERFACE_NAME_LEN]; - IF_INDEX dwIndex; - IFTYPE dwType; - DWORD dwMtu; - DWORD dwSpeed; - DWORD dwPhysAddrLen; - BYTE bPhysAddr[MAXLEN_PHYSADDR]; - DWORD dwAdminStatus; - INTERNAL_IF_OPER_STATUS dwOperStatus; - DWORD dwLastChange; - DWORD dwInOctets; - DWORD dwInUcastPkts; - DWORD dwInNUcastPkts; - DWORD dwInDiscards; - DWORD dwInErrors; - DWORD dwInUnknownProtos; - DWORD dwOutOctets; - DWORD dwOutUcastPkts; - DWORD dwOutNUcastPkts; - DWORD dwOutDiscards; - DWORD dwOutErrors; - DWORD dwOutQLen; - DWORD dwDescrLen; - UCHAR bDescr[MAXLEN_IFDESCR]; -} MIB_IFROW, *PMIB_IFROW; - -typedef struct _MIB_IFTABLE { - DWORD dwNumEntries; - MIB_IFROW table[ANY_SIZE]; -} MIB_IFTABLE, *PMIB_IFTABLE; - - -typedef struct _MIB_TCPROW_OWNER_PID { - DWORD dwState; - DWORD dwLocalAddr; - DWORD dwLocalPort; - DWORD dwRemoteAddr; - DWORD dwRemotePort; - DWORD dwOwningPid; -} MIB_TCPROW_OWNER_PID, *PMIB_TCPROW_OWNER_PID; - -typedef struct _MIB_TCPTABLE_OWNER_PID{ - DWORD dwNumEntries; - MIB_TCPROW_OWNER_PID table[ANY_SIZE]; -} MIB_TCPTABLE_OWNER_PID, *PMIB_TCPTABLE_OWNER_PID; - -typedef struct _MIB_UDPROW_OWNER_PID { - DWORD dwLocalAddr; - DWORD dwLocalPort; - DWORD dwOwningPid; -} MIB_UDPROW_OWNER_PID, *PMIB_UDPROW_OWNER_PID; - -typedef struct _MIB_UDPTABLE_OWNER_PID { - DWORD dwNumEntries; - MIB_UDPROW_OWNER_PID table[ANY_SIZE]; -} MIB_UDPTABLE_OWNER_PID, *PMIB_UDPTABLE_OWNER_PID; - - -typedef struct _MIB_UDP6ROW_OWNER_PID { - UCHAR ucLocalAddr[16]; - DWORD dwLocalScopeId; - DWORD dwLocalPort; - DWORD dwOwningPid; -} MIB_UDP6ROW_OWNER_PID, *PMIB_UDP6ROW_OWNER_PID; - -typedef struct _MIB_UDP6TABLE_OWNER_PID{ - DWORD dwNumEntries; - MIB_UDP6ROW_OWNER_PID table[ANY_SIZE]; -} MIB_UDP6TABLE_OWNER_PID, *PMIB_UDP6TABLE_OWNER_PID; - -typedef struct _MIB_TCP6ROW_OWNER_PID { - UCHAR ucLocalAddr[16]; - DWORD dwLocalScopeId; - DWORD dwLocalPort; - UCHAR ucRemoteAddr[16]; - DWORD dwRemoteScopeId; - DWORD dwRemotePort; - DWORD dwState; - DWORD dwOwningPid; -} MIB_TCP6ROW_OWNER_PID, *PMIB_TCP6ROW_OWNER_PID; - -typedef struct _MIB_TCP6TABLE_OWNER_PID { - DWORD dwNumEntries; - MIB_TCP6ROW_OWNER_PID table[ANY_SIZE]; -} MIB_TCP6TABLE_OWNER_PID, *PMIB_TCP6TABLE_OWNER_PID; - -typedef struct _MIB_TCPROW { - DWORD dwState; - DWORD dwLocalAddr; - DWORD dwLocalPort; - DWORD dwRemoteAddr; - DWORD dwRemotePort; -} MIB_TCPROW, *PMIB_TCPROW; - -typedef struct _IP_ADAPTER_INDEX_MAP { - ULONG Index; - WCHAR Name[MAX_ADAPTER_NAME]; -} IP_ADAPTER_INDEX_MAP, *PIP_ADAPTER_INDEX_MAP; - -typedef struct _IP_INTERFACE_INFO { - LONG NumAdapters; - IP_ADAPTER_INDEX_MAP Adapter[1]; -} IP_INTERFACE_INFO, *PIP_INTERFACE_INFO; - typedef struct _EXCEPTION_RECORD { DWORD ExceptionCode; @@ -2010,6 +1855,16 @@ typedef struct _SYSTEM_HANDLE } SYSTEM_HANDLE; +typedef struct _SYSTEM_HANDLE64 +{ + DWORD dwProcessId; + BYTE bObjectType; + BYTE bFlags; + WORD wValue; + ULONG64 pAddress; + DWORD GrantedAccess; +} SYSTEM_HANDLE64; + typedef struct _SYSTEM_HANDLE_INFORMATION { @@ -2017,6 +1872,13 @@ typedef struct _SYSTEM_HANDLE_INFORMATION SYSTEM_HANDLE Handles[1]; } SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION; +typedef struct _SYSTEM_HANDLE_INFORMATION64 +{ + ULONG HandleCount; + SYSTEM_HANDLE64 Handles[1]; +} SYSTEM_HANDLE_INFORMATION64, *PSYSTEM_HANDLE_INFORMATION64; + + typedef struct __PUBLIC_OBJECT_TYPE_INFORMATION { UNICODE_STRING TypeName; ULONG Reserved [22]; diff --git a/ctypes_generation/definitions/structures/winstruct_evtlog.txt b/ctypes_generation/definitions/structures/winstruct_evtlog.txt index 28f0ffb..c388535 100644 --- a/ctypes_generation/definitions/structures/winstruct_evtlog.txt +++ b/ctypes_generation/definitions/structures/winstruct_evtlog.txt @@ -50,9 +50,8 @@ typedef enum _EVT_VARIANT_TYPE { } EVT_VARIANT_TYPE; - - -union _ANON_evt_variant_sub_union { +typedef struct _EVT_VARIANT { + union { BOOL BooleanVal; INT8 SByteVal; INT16 Int16Val; @@ -72,7 +71,6 @@ union _ANON_evt_variant_sub_union { PBYTE BinaryVal; PSID SidVal; SIZE_T SizeTVal; - EVT_HANDLE EvtHandleVal; BOOL *BooleanArr; INT8 *SByteArr; INT16 *Int16Arr; @@ -91,12 +89,10 @@ union _ANON_evt_variant_sub_union { LPSTR *AnsiStringArr; PSID *SidArr; SIZE_T *SizeTArr; + EVT_HANDLE EvtHandleVal; LPCWSTR XmlVal; - LPCWSTR* XmlValArr; -}; - -typedef struct _EVT_VARIANT { - _ANON_evt_variant_sub_union _VARIANT_VALUE; + LPCWSTR *XmlValArr; + }; DWORD Count; DWORD Type; } EVT_VARIANT, *PEVT_VARIANT; diff --git a/ctypes_generation/extended_structs/_EVENT_DESCRIPTOR.py b/ctypes_generation/extended_structs/_EVENT_DESCRIPTOR.py new file mode 100644 index 0000000..786a30b --- /dev/null +++ b/ctypes_generation/extended_structs/_EVENT_DESCRIPTOR.py @@ -0,0 +1,3 @@ +class _EVENT_DESCRIPTOR(_EVENT_DESCRIPTOR): + def __repr__(self): + return "<{0} Id={self.Id} Opcode={self.Opcode} Version={self.Version} Level={self.Level}>".format(type(self).__name__, self=self) \ No newline at end of file diff --git a/ctypes_generation/extended_structs/_EVENT_HEADER_EXTENDED_DATA_ITEM.py b/ctypes_generation/extended_structs/_EVENT_HEADER_EXTENDED_DATA_ITEM.py new file mode 100644 index 0000000..12b8af9 --- /dev/null +++ b/ctypes_generation/extended_structs/_EVENT_HEADER_EXTENDED_DATA_ITEM.py @@ -0,0 +1,6 @@ +_OLD_EVENT_HEADER_EXTENDED_DATA_ITEM = _EVENT_HEADER_EXTENDED_DATA_ITEM +class _EVENT_HEADER_EXTENDED_DATA_ITEM(_OLD_EVENT_HEADER_EXTENDED_DATA_ITEM): + @property + def data(self): + bdata = (ctypes.c_char * self.DataSize).from_address(self.DataPtr) + return bdata[:] \ No newline at end of file diff --git a/ctypes_generation/extended_structs/_EVENT_RECORD.py b/ctypes_generation/extended_structs/_EVENT_RECORD.py new file mode 100644 index 0000000..d4e3bd9 --- /dev/null +++ b/ctypes_generation/extended_structs/_EVENT_RECORD.py @@ -0,0 +1,3 @@ +_OLD_EVENT_RECORD = _EVENT_RECORD +class _EVENT_RECORD(_OLD_EVENT_RECORD): + pass \ No newline at end of file diff --git a/ctypes_generation/extended_structs/_GUID.py b/ctypes_generation/extended_structs/_GUID.py index 88dbd6b..b6865ec 100644 --- a/ctypes_generation/extended_structs/_GUID.py +++ b/ctypes_generation/extended_structs/_GUID.py @@ -45,6 +45,7 @@ class _GUID(INITIAL_GUID): datas.append(int(part_iid[4][i * 2:(i + 1) * 2], 16)) return cls.from_raw(*datas, strid=iid) + @classmethod def from_raw(cls, Data1, Data2, Data3, Data41, Data42, Data43, Data44, Data45, Data46, Data47, Data48, **kwargs): return cls(Data1, Data2, Data3, (BYTE*8)(Data41, Data42, Data43, Data44, Data45, Data46, Data47, Data48), **kwargs) diff --git a/ctypes_generation/extended_structs/_OBJECT_ATTRIBUTES.py b/ctypes_generation/extended_structs/_OBJECT_ATTRIBUTES.py new file mode 100644 index 0000000..f708c8f --- /dev/null +++ b/ctypes_generation/extended_structs/_OBJECT_ATTRIBUTES.py @@ -0,0 +1,16 @@ +class _OBJECT_ATTRIBUTES(_OBJECT_ATTRIBUTES): + @classmethod + def from_string(cls, path, attributes=OBJ_CASE_INSENSITIVE): # Directly on constructor ? + self = cls() + self.Length = ctypes.sizeof(self) + self.RootDirectory = 0 + self.ObjectName = ctypes.pointer(LSA_UNICODE_STRING.from_string(path)) + self.Attributes = attributes + self.SecurityDescriptor = 0 + self.SecurityQualityOfService = 0 + return self + + def __repr__(self): + if not self.ObjectName: + return super(_OBJECT_ATTRIBUTES, self).__repr__() + return """<{0} ObjectName="{1}">""".format(type(self).__name__, self.ObjectName[0].str) \ No newline at end of file diff --git a/ctypes_generation/extended_structs/_SYMBOL_INFO.py b/ctypes_generation/extended_structs/_SYMBOL_INFO.py new file mode 100644 index 0000000..ee02a38 --- /dev/null +++ b/ctypes_generation/extended_structs/_SYMBOL_INFO.py @@ -0,0 +1,5 @@ +old_SYMBOL_INFO = _SYMBOL_INFO +class _SYMBOL_INFO(old_SYMBOL_INFO): + @property + def tag(self): + return SymTagEnum.mapper[self.Tag] \ No newline at end of file diff --git a/ctypes_generation/generate.py b/ctypes_generation/generate.py index 6109c36..3ac9b33 100644 --- a/ctypes_generation/generate.py +++ b/ctypes_generation/generate.py @@ -66,20 +66,29 @@ class StructureParsedFile(ParsedFile): self.add_exports(enum.name) self.add_exports(*enum.typedef) for struct in structs: - self.asser_struct_not_already_in_import(struct) - if any(x in self.imports for x in [struct.name] + struct.typedef.keys()): - print("Export <{0}> defined after first use".format(struct.name)) - raise ValueError("LOL") + self.compute_imports_exports_for_struct(struct) + + + def compute_imports_exports_for_struct(self, struct): + self.asser_struct_not_already_in_import(struct) + if any(x in self.imports for x in [struct.name] + struct.typedef.keys()): + print("Export <{0}> defined after first use".format(struct.name)) + raise ValueError("LOL") + if struct.name is not None: # Anonymous structs self.add_exports(struct.name) - self.add_exports(*struct.typedef) - for field_type, field_name, nb_rep in struct.fields: - if field_type.name not in self.exports: - self.add_imports(field_type.name) - self.imports_by_struct[field_type.name] = struct.name - try: - int(nb_rep) - except: - self.add_imports(nb_rep) + self.add_exports(*struct.typedef) + for field_type, field_name, nb_rep in struct.fields: + if field_name is None: + # Anon sub-struct/union + self.compute_imports_exports_for_struct(field_type) + continue + if field_type.name not in self.exports: + self.add_imports(field_type.name) + self.imports_by_struct[field_type.name] = struct.name + try: + int(nb_rep) + except: + self.add_imports(nb_rep) def asser_struct_not_already_in_import(self, struct): for sname in [struct.name] + struct.typedef.keys(): diff --git a/ctypes_generation/struct_parser.py b/ctypes_generation/struct_parser.py index e0004c8..f40606d 100644 --- a/ctypes_generation/struct_parser.py +++ b/ctypes_generation/struct_parser.py @@ -30,9 +30,7 @@ class WinStructParser(Parser): # Not a name. Anon union/struct ? subdef_type = self.next_token() # union / struct if type(self.peek()) == OpenBracketToken: - print("<{0}> ANON START WITH <{1}>".format(self._yolo, self.peek())) sub = self.parse_winstruct(anonymous=True, anon_type=subdef_type) - print("Anon is <{0}>".format(sub)) return (sub, NameToken(None), 1) else: # struct _MYNAME_ -> no anon juste the name of the struct. @@ -137,9 +135,8 @@ class WinStructParser(Parser): # Anonymous structure def: check if we are ina typedef if not is_typedef and not anonymous: raise ValueError("Anonymous structure/union not in a typedef") - struct_name = "anon" + struct_name = None self.assert_token_type(OpenBracketToken) - self._yolo = struct_name result = WinDefType(struct_name, self.pack) while type(self.peek()) != CloseBracketToken: @@ -148,6 +145,10 @@ class WinStructParser(Parser): self.assert_token_type(CloseBracketToken) if is_typedef: self.parse_typedef(result) + elif anonymous: + if type(self.peek()) == NameToken: + result.add_typedef(self.assert_token_type(NameToken).value) + self.assert_token_type(SemiColonToken) else: self.assert_token_type(SemiColonToken) return result diff --git a/ctypes_generation/winstruct.py b/ctypes_generation/winstruct.py index 76c0e2e..5ff815f 100644 --- a/ctypes_generation/winstruct.py +++ b/ctypes_generation/winstruct.py @@ -83,11 +83,17 @@ class WinStruct(object): continue i += 1 # Should begin by "_ANON_" to trigger + if type.typedef: + assert len(type.typedef) == 1, "Anonymous structure should have only one name" + field_name = list(type.typedef)[0] + type.typedef = {} # Remove typedef so that there is no use of it when genering the code for this anon-struct + else: + field_name = "anon_{0:02}".format(i) type.name = "_ANON_{0}_SUB_{1}_{2}".format(self.name, type.ctypes_type, i).upper() code.append(type.generate_ctypes()) # Generate class for the code # Replace the type name + field name in fields list - new_fields.append((WinStructType(type.name), "anon_{0:02}".format(i), nb)) + new_fields.append((WinStructType(type.name), field_name, nb)) self.fields = new_fields return "\n".join(code) @@ -157,11 +163,7 @@ class WinStruct(object): if self.is_self_referencing(): print("{0} is self referencing".format(self.name)) - return self.generate_selfref_ctypes_class() + "\n" - - - import pdb;pdb.set_trace() - print("LOL") + return anon_code + self.generate_selfref_ctypes_class() + "\n" ctypes_class = self.generate_ctypes_class() ctypes_typedef = self.generate_typedef_ctypes() diff --git a/windows/generated_def/interfaces.py b/windows/generated_def/interfaces.py index c7804b8..ccd6596 100644 --- a/windows/generated_def/interfaces.py +++ b/windows/generated_def/interfaces.py @@ -57,21 +57,6 @@ class COMInterface(ctypes.c_void_p): -class IBackgroundCopyCallback(COMInterface): - IID = generate_IID(0x97EA99C7, 0x0186, 0x4AD4, 0x8D, 0xF9, 0xC5, 0xB4, 0xE0, 0xED, 0x6B, 0x22, name="IBackgroundCopyCallback", strid="97EA99C7-0186-4AD4-8DF9-C5B4E0ED6B22") - -class IBackgroundCopyError(COMInterface): - IID = generate_IID(0x19C613A0, 0xFCB8, 0x4F28, 0x81, 0xAE, 0x89, 0x7C, 0x3D, 0x07, 0x8F, 0x81, name="IBackgroundCopyError", strid="19C613A0-FCB8-4F28-81AE-897C3D078F81") - -class IBackgroundCopyFile(COMInterface): - IID = generate_IID(0x01B7BD23, 0xFB88, 0x4A77, 0x84, 0x90, 0x58, 0x91, 0xD3, 0xE4, 0x65, 0x3A, name="IBackgroundCopyFile", strid="01B7BD23-FB88-4A77-8490-5891D3E4653A") - -class IBackgroundCopyJob(COMInterface): - IID = generate_IID(0x37668D37, 0x507E, 0x4160, 0x93, 0x16, 0x26, 0x30, 0x6D, 0x15, 0x0B, 0x12, name="IBackgroundCopyJob", strid="37668D37-507E-4160-9316-26306D150B12") - -class IBackgroundCopyManager(COMInterface): - IID = generate_IID(0x5CE34C0D, 0x0DC9, 0x4C1F, 0x89, 0x7C, 0xDA, 0xA1, 0xB7, 0x8C, 0xEE, 0x7C, name="IBackgroundCopyManager", strid="5CE34C0D-0DC9-4C1F-897C-DAA1B78CEE7C") - class ICallFrame(COMInterface): IID = generate_IID(0xD573B4B0, 0x894E, 0x11D2, 0xB8, 0xB6, 0x00, 0xC0, 0x4F, 0xB9, 0x61, 0x8A, name="ICallFrame", strid="D573B4B0-894E-11D2-B8B6-00C04FB9618A") @@ -87,18 +72,9 @@ class ICallInterceptor(COMInterface): class IDispatch(COMInterface): IID = generate_IID(0x00020400, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, name="IDispatch", strid="00020400-0000-0000-C000-000000000046") -class IEnumBackgroundCopyFiles(COMInterface): - IID = generate_IID(0xCA51E165, 0xC365, 0x424C, 0x8D, 0x41, 0x24, 0xAA, 0xA4, 0xFF, 0x3C, 0x40, name="IEnumBackgroundCopyFiles", strid="CA51E165-C365-424C-8D41-24AAA4FF3C40") - -class IEnumBackgroundCopyJobs(COMInterface): - IID = generate_IID(0x1AF4F612, 0x3B71, 0x466F, 0x8F, 0x58, 0x7B, 0x6F, 0x73, 0xAC, 0x57, 0xAD, name="IEnumBackgroundCopyJobs", strid="1AF4F612-3B71-466F-8F58-7B6F73AC57AD") - class IEnumVARIANT(COMInterface): IID = generate_IID(0x00020404, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, name="IEnumVARIANT", strid="00020404-0000-0000-C000-000000000046") -class IEnumWbemClassObject(COMInterface): - IID = generate_IID(0x027947E1, 0xD731, 0x11CE, 0xA3, 0x57, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, name="IEnumWbemClassObject", strid="027947E1-D731-11CE-A357-000000000001") - class INetFwPolicy2(COMInterface): IID = generate_IID(0x98325047, 0xC671, 0x4174, 0x8D, 0x81, 0xDE, 0xFC, 0xD3, 0xF0, 0x31, 0x86, name="INetFwPolicy2", strid="98325047-C671-4174-8D81-DEFCD3F03186") @@ -111,6 +87,9 @@ class INetFwRule(COMInterface): class INetFwServiceRestriction(COMInterface): IID = generate_IID(0x8267BBE3, 0xF890, 0x491C, 0xB7, 0xB6, 0x2D, 0xB1, 0xEF, 0x0E, 0x5D, 0x2B, name="INetFwServiceRestriction", strid="8267BBE3-F890-491C-B7B6-2DB1EF0E5D2B") +class IPersist(COMInterface): + IID = generate_IID(0x0000010C, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, name="IPersist", strid="0000010C-0000-0000-C000-000000000046") + class IPersistFile(COMInterface): IID = generate_IID(0x0000010B, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, name="IPersistFile", strid="0000010B-0000-0000-C000-000000000046") @@ -132,26 +111,35 @@ class ITypeLib(COMInterface): class IUnknown(COMInterface): IID = generate_IID(0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, name="IUnknown", strid="00000000-0000-0000-C000-000000000046") -class IWbemCallResult(COMInterface): - IID = generate_IID(0x44ACA675, 0xE8FC, 0x11D0, 0xA0, 0x7C, 0x00, 0xC0, 0x4F, 0xB6, 0x88, 0x20, name="IWbemCallResult", strid="44ACA675-E8FC-11D0-A07C-00C04FB68820") +class IBackgroundCopyCallback(COMInterface): + IID = generate_IID(0x97EA99C7, 0x0186, 0x4AD4, 0x8D, 0xF9, 0xC5, 0xB4, 0xE0, 0xED, 0x6B, 0x22, name="IBackgroundCopyCallback", strid="97EA99C7-0186-4AD4-8DF9-C5B4E0ED6B22") -class IWbemClassObject(COMInterface): - IID = generate_IID(0xDC12A681, 0x737F, 0x11CF, 0x88, 0x4D, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24, name="IWbemClassObject", strid="DC12A681-737F-11CF-884D-00AA004B2E24") +class IBackgroundCopyError(COMInterface): + IID = generate_IID(0x19C613A0, 0xFCB8, 0x4F28, 0x81, 0xAE, 0x89, 0x7C, 0x3D, 0x07, 0x8F, 0x81, name="IBackgroundCopyError", strid="19C613A0-FCB8-4F28-81AE-897C3D078F81") -class IWbemContext(COMInterface): - IID = generate_IID(0x44ACA674, 0xE8FC, 0x11D0, 0xA0, 0x7C, 0x00, 0xC0, 0x4F, 0xB6, 0x88, 0x20, name="IWbemContext", strid="44ACA674-E8FC-11D0-A07C-00C04FB68820") +class IBackgroundCopyFile(COMInterface): + IID = generate_IID(0x01B7BD23, 0xFB88, 0x4A77, 0x84, 0x90, 0x58, 0x91, 0xD3, 0xE4, 0x65, 0x3A, name="IBackgroundCopyFile", strid="01B7BD23-FB88-4A77-8490-5891D3E4653A") -class IWbemLocator(COMInterface): - IID = generate_IID(0xDC12A687, 0x737F, 0x11CF, 0x88, 0x4D, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24, name="IWbemLocator", strid="DC12A687-737F-11CF-884D-00AA004B2E24") +class IBackgroundCopyFile2(COMInterface): + IID = generate_IID(0x83E81B93, 0x0873, 0x474D, 0x8A, 0x8C, 0xF2, 0x01, 0x8B, 0x1A, 0x93, 0x9C, name="IBackgroundCopyFile2", strid="83E81B93-0873-474D-8A8C-F2018B1A939C") -class IWbemObjectSink(COMInterface): - IID = generate_IID(0x7C857801, 0x7381, 0x11CF, 0x88, 0x4D, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24, name="IWbemObjectSink", strid="7C857801-7381-11CF-884D-00AA004B2E24") +class IBackgroundCopyFile3(COMInterface): + IID = generate_IID(0x659CDEAA, 0x489E, 0x11D9, 0xA9, 0xCD, 0x00, 0x0D, 0x56, 0x96, 0x52, 0x51, name="IBackgroundCopyFile3", strid="659CDEAA-489E-11D9-A9CD-000D56965251") -class IWbemQualifierSet(COMInterface): - IID = generate_IID(0xDC12A680, 0x737F, 0x11CF, 0x88, 0x4D, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24, name="IWbemQualifierSet", strid="DC12A680-737F-11CF-884D-00AA004B2E24") +class IBackgroundCopyJob(COMInterface): + IID = generate_IID(0x37668D37, 0x507E, 0x4160, 0x93, 0x16, 0x26, 0x30, 0x6D, 0x15, 0x0B, 0x12, name="IBackgroundCopyJob", strid="37668D37-507E-4160-9316-26306D150B12") -class IWbemServices(COMInterface): - IID = generate_IID(0x9556DC99, 0x828C, 0x11CF, 0xA3, 0x7E, 0x00, 0xAA, 0x00, 0x32, 0x40, 0xC7, name="IWbemServices", strid="9556DC99-828C-11CF-A37E-00AA003240C7") +class IBackgroundCopyJob2(COMInterface): + IID = generate_IID(0x54B50739, 0x686F, 0x45EB, 0x9D, 0xFF, 0xD6, 0xA9, 0xA0, 0xFA, 0xA9, 0xAF, name="IBackgroundCopyJob2", strid="54B50739-686F-45EB-9DFF-D6A9A0FAA9AF") + +class IBackgroundCopyManager(COMInterface): + IID = generate_IID(0x5CE34C0D, 0x0DC9, 0x4C1F, 0x89, 0x7C, 0xDA, 0xA1, 0xB7, 0x8C, 0xEE, 0x7C, name="IBackgroundCopyManager", strid="5CE34C0D-0DC9-4C1F-897C-DAA1B78CEE7C") + +class IEnumBackgroundCopyFiles(COMInterface): + IID = generate_IID(0xCA51E165, 0xC365, 0x424C, 0x8D, 0x41, 0x24, 0xAA, 0xA4, 0xFF, 0x3C, 0x40, name="IEnumBackgroundCopyFiles", strid="CA51E165-C365-424C-8D41-24AAA4FF3C40") + +class IEnumBackgroundCopyJobs(COMInterface): + IID = generate_IID(0x1AF4F612, 0x3B71, 0x466F, 0x8F, 0x58, 0x7B, 0x6F, 0x73, 0xAC, 0x57, 0xAD, name="IEnumBackgroundCopyJobs", strid="1AF4F612-3B71-466F-8F58-7B6F73AC57AD") class IAction(COMInterface): IID = generate_IID(0xBAE54997, 0x48B1, 0x4CBE, 0x99, 0x65, 0xD6, 0xBE, 0x26, 0x3E, 0xBE, 0xA4, name="IAction", strid="BAE54997-48B1-4CBE-9965-D6BE263EBEA4") @@ -225,144 +213,32 @@ class ITrigger(COMInterface): class ITriggerCollection(COMInterface): IID = generate_IID(0x85DF5081, 0x1B24, 0x4F32, 0x87, 0x8A, 0xD9, 0xD1, 0x4D, 0xF4, 0xCB, 0x77, name="ITriggerCollection", strid="85DF5081-1B24-4F32-878A-D9D14DF4CB77") -IBackgroundCopyCallback._functions_ = { - # QueryInterface -> riid:REFIID, ppvObject:**void - "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), - # AddRef -> - "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), - # Release -> - "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # JobTransferred -> pJob:*IBackgroundCopyJob - "JobTransferred": ctypes.WINFUNCTYPE(HRESULT, IBackgroundCopyJob)(3, "JobTransferred"), - # JobError -> pJob:*IBackgroundCopyJob, pError:*IBackgroundCopyError - "JobError": ctypes.WINFUNCTYPE(HRESULT, IBackgroundCopyJob, IBackgroundCopyError)(4, "JobError"), - # JobModification -> pJob:*IBackgroundCopyJob, dwReserved:DWORD - "JobModification": ctypes.WINFUNCTYPE(HRESULT, IBackgroundCopyJob, DWORD)(5, "JobModification"), - } +class IWebBrowser2(COMInterface): + IID = generate_IID(0xD30C1661, 0xCDAF, 0x11D0, 0x8A, 0x3E, 0x00, 0xC0, 0x4F, 0xC9, 0xE2, 0x6E, name="IWebBrowser2", strid="D30C1661-CDAF-11D0-8A3E-00C04FC9E26E") -IBackgroundCopyError._functions_ = { - # QueryInterface -> riid:REFIID, ppvObject:**void - "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), - # AddRef -> - "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), - # Release -> - "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # GetError -> pContext:*BG_ERROR_CONTEXT, pCode:*HRESULT - "GetError": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_ERROR_CONTEXT), POINTER(HRESULT))(3, "GetError"), - # GetFile -> pVal:**IBackgroundCopyFile - "GetFile": ctypes.WINFUNCTYPE(HRESULT, POINTER(IBackgroundCopyFile))(4, "GetFile"), - # GetErrorDescription -> LanguageId:DWORD, pErrorDescription:*LPWSTR - "GetErrorDescription": ctypes.WINFUNCTYPE(HRESULT, DWORD, POINTER(LPWSTR))(5, "GetErrorDescription"), - # GetErrorContextDescription -> LanguageId:DWORD, pContextDescription:*LPWSTR - "GetErrorContextDescription": ctypes.WINFUNCTYPE(HRESULT, DWORD, POINTER(LPWSTR))(6, "GetErrorContextDescription"), - # GetProtocol -> pProtocol:*LPWSTR - "GetProtocol": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(7, "GetProtocol"), - } +class IEnumWbemClassObject(COMInterface): + IID = generate_IID(0x027947E1, 0xD731, 0x11CE, 0xA3, 0x57, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, name="IEnumWbemClassObject", strid="027947E1-D731-11CE-A357-000000000001") -IBackgroundCopyFile._functions_ = { - # QueryInterface -> riid:REFIID, ppvObject:**void - "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), - # AddRef -> - "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), - # Release -> - "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # GetRemoteName -> pVal:*LPWSTR - "GetRemoteName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(3, "GetRemoteName"), - # GetLocalName -> pVal:*LPWSTR - "GetLocalName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(4, "GetLocalName"), - # GetProgress -> pVal:*BG_FILE_PROGRESS - "GetProgress": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_FILE_PROGRESS))(5, "GetProgress"), - } +class IWbemCallResult(COMInterface): + IID = generate_IID(0x44ACA675, 0xE8FC, 0x11D0, 0xA0, 0x7C, 0x00, 0xC0, 0x4F, 0xB6, 0x88, 0x20, name="IWbemCallResult", strid="44ACA675-E8FC-11D0-A07C-00C04FB68820") -IBackgroundCopyJob._functions_ = { - # QueryInterface -> riid:REFIID, ppvObject:**void - "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), - # AddRef -> - "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), - # Release -> - "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # AddFileSet -> cFileCount:ULONG, pFileSet:*BG_FILE_INFO - "AddFileSet": ctypes.WINFUNCTYPE(HRESULT, ULONG, POINTER(BG_FILE_INFO))(3, "AddFileSet"), - # AddFile -> RemoteUrl:LPCWSTR, LocalName:LPCWSTR - "AddFile": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LPCWSTR)(4, "AddFile"), - # EnumFiles -> pEnum:**IEnumBackgroundCopyFiles - "EnumFiles": ctypes.WINFUNCTYPE(HRESULT, POINTER(IEnumBackgroundCopyFiles))(5, "EnumFiles"), - # Suspend -> - "Suspend": ctypes.WINFUNCTYPE(HRESULT)(6, "Suspend"), - # Resume -> - "Resume": ctypes.WINFUNCTYPE(HRESULT)(7, "Resume"), - # Cancel -> - "Cancel": ctypes.WINFUNCTYPE(HRESULT)(8, "Cancel"), - # Complete -> - "Complete": ctypes.WINFUNCTYPE(HRESULT)(9, "Complete"), - # GetId -> pVal:*GUID - "GetId": ctypes.WINFUNCTYPE(HRESULT, POINTER(GUID))(10, "GetId"), - # GetType -> pVal:*BG_JOB_TYPE - "GetType": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_TYPE))(11, "GetType"), - # GetProgress -> pVal:*BG_JOB_PROGRESS - "GetProgress": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_PROGRESS))(12, "GetProgress"), - # GetTimes -> pVal:*BG_JOB_TIMES - "GetTimes": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_TIMES))(13, "GetTimes"), - # GetState -> pVal:*BG_JOB_STATE - "GetState": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_STATE))(14, "GetState"), - # GetError -> ppError:**IBackgroundCopyError - "GetError": ctypes.WINFUNCTYPE(HRESULT, POINTER(IBackgroundCopyError))(15, "GetError"), - # GetOwner -> pVal:*LPWSTR - "GetOwner": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(16, "GetOwner"), - # SetDisplayName -> Val:LPCWSTR - "SetDisplayName": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(17, "SetDisplayName"), - # GetDisplayName -> pVal:*LPWSTR - "GetDisplayName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(18, "GetDisplayName"), - # SetDescription -> Val:LPCWSTR - "SetDescription": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(19, "SetDescription"), - # GetDescription -> pVal:*LPWSTR - "GetDescription": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(20, "GetDescription"), - # SetPriority -> Val:BG_JOB_PRIORITY - "SetPriority": ctypes.WINFUNCTYPE(HRESULT, BG_JOB_PRIORITY)(21, "SetPriority"), - # GetPriority -> pVal:*BG_JOB_PRIORITY - "GetPriority": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_PRIORITY))(22, "GetPriority"), - # SetNotifyFlags -> Val:ULONG - "SetNotifyFlags": ctypes.WINFUNCTYPE(HRESULT, ULONG)(23, "SetNotifyFlags"), - # GetNotifyFlags -> pVal:*ULONG - "GetNotifyFlags": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(24, "GetNotifyFlags"), - # SetNotifyInterface -> Val:*IUnknown - "SetNotifyInterface": ctypes.WINFUNCTYPE(HRESULT, IUnknown)(25, "SetNotifyInterface"), - # GetNotifyInterface -> pVal:**IUnknown - "GetNotifyInterface": ctypes.WINFUNCTYPE(HRESULT, POINTER(IUnknown))(26, "GetNotifyInterface"), - # SetMinimumRetryDelay -> Seconds:ULONG - "SetMinimumRetryDelay": ctypes.WINFUNCTYPE(HRESULT, ULONG)(27, "SetMinimumRetryDelay"), - # GetMinimumRetryDelay -> Seconds:*ULONG - "GetMinimumRetryDelay": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(28, "GetMinimumRetryDelay"), - # SetNoProgressTimeout -> Seconds:ULONG - "SetNoProgressTimeout": ctypes.WINFUNCTYPE(HRESULT, ULONG)(29, "SetNoProgressTimeout"), - # GetNoProgressTimeout -> Seconds:*ULONG - "GetNoProgressTimeout": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(30, "GetNoProgressTimeout"), - # GetErrorCount -> Errors:*ULONG - "GetErrorCount": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(31, "GetErrorCount"), - # SetProxySettings -> ProxyUsage:BG_JOB_PROXY_USAGE, ProxyList:*WCHAR, ProxyBypassList:*WCHAR - "SetProxySettings": ctypes.WINFUNCTYPE(HRESULT, BG_JOB_PROXY_USAGE, POINTER(WCHAR), POINTER(WCHAR))(32, "SetProxySettings"), - # GetProxySettings -> pProxyUsage:*BG_JOB_PROXY_USAGE, pProxyList:*LPWSTR, pProxyBypassList:*LPWSTR - "GetProxySettings": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_PROXY_USAGE), POINTER(LPWSTR), POINTER(LPWSTR))(33, "GetProxySettings"), - # TakeOwnership -> - "TakeOwnership": ctypes.WINFUNCTYPE(HRESULT)(34, "TakeOwnership"), - } +class IWbemClassObject(COMInterface): + IID = generate_IID(0xDC12A681, 0x737F, 0x11CF, 0x88, 0x4D, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24, name="IWbemClassObject", strid="DC12A681-737F-11CF-884D-00AA004B2E24") -IBackgroundCopyManager._functions_ = { - # QueryInterface -> riid:REFIID, ppvObject:**void - "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), - # AddRef -> - "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), - # Release -> - "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # CreateJob -> DisplayName:LPCWSTR, Type:BG_JOB_TYPE, pJobId:*GUID, ppJob:**IBackgroundCopyJob - "CreateJob": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, BG_JOB_TYPE, POINTER(GUID), POINTER(IBackgroundCopyJob))(3, "CreateJob"), - # GetJob -> jobID:REFGUID, ppJob:**IBackgroundCopyJob - "GetJob": ctypes.WINFUNCTYPE(HRESULT, REFGUID, POINTER(IBackgroundCopyJob))(4, "GetJob"), - # EnumJobs -> dwFlags:DWORD, ppEnum:**IEnumBackgroundCopyJobs - "EnumJobs": ctypes.WINFUNCTYPE(HRESULT, DWORD, POINTER(IEnumBackgroundCopyJobs))(5, "EnumJobs"), - # GetErrorDescription -> hResult:HRESULT, LanguageId:DWORD, pErrorDescription:*LPWSTR - "GetErrorDescription": ctypes.WINFUNCTYPE(HRESULT, HRESULT, DWORD, POINTER(LPWSTR))(6, "GetErrorDescription"), - } +class IWbemContext(COMInterface): + IID = generate_IID(0x44ACA674, 0xE8FC, 0x11D0, 0xA0, 0x7C, 0x00, 0xC0, 0x4F, 0xB6, 0x88, 0x20, name="IWbemContext", strid="44ACA674-E8FC-11D0-A07C-00C04FB68820") + +class IWbemLocator(COMInterface): + IID = generate_IID(0xDC12A687, 0x737F, 0x11CF, 0x88, 0x4D, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24, name="IWbemLocator", strid="DC12A687-737F-11CF-884D-00AA004B2E24") + +class IWbemObjectSink(COMInterface): + IID = generate_IID(0x7C857801, 0x7381, 0x11CF, 0x88, 0x4D, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24, name="IWbemObjectSink", strid="7C857801-7381-11CF-884D-00AA004B2E24") + +class IWbemQualifierSet(COMInterface): + IID = generate_IID(0xDC12A680, 0x737F, 0x11CF, 0x88, 0x4D, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24, name="IWbemQualifierSet", strid="DC12A680-737F-11CF-884D-00AA004B2E24") + +class IWbemServices(COMInterface): + IID = generate_IID(0x9556DC99, 0x828C, 0x11CF, 0xA3, 0x7E, 0x00, 0xAA, 0x00, 0x32, 0x40, 0xC7, name="IWbemServices", strid="9556DC99-828C-11CF-A37E-00AA003240C7") ICallFrame._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void @@ -471,44 +347,6 @@ IDispatch._functions_ = { "Invoke": ctypes.WINFUNCTYPE(HRESULT, DISPID, REFIID, LCID, WORD, POINTER(DISPPARAMS), POINTER(VARIANT), POINTER(EXCEPINFO), POINTER(UINT))(6, "Invoke"), } -IEnumBackgroundCopyFiles._functions_ = { - # QueryInterface -> riid:REFIID, ppvObject:**void - "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), - # AddRef -> - "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), - # Release -> - "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # Next -> celt:ULONG, rgelt:**IBackgroundCopyFile, pceltFetched:*ULONG - "Next": ctypes.WINFUNCTYPE(HRESULT, ULONG, POINTER(IBackgroundCopyFile), POINTER(ULONG))(3, "Next"), - # Skip -> celt:ULONG - "Skip": ctypes.WINFUNCTYPE(HRESULT, ULONG)(4, "Skip"), - # Reset -> - "Reset": ctypes.WINFUNCTYPE(HRESULT)(5, "Reset"), - # Clone -> ppenum:**IEnumBackgroundCopyFiles - "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IEnumBackgroundCopyFiles))(6, "Clone"), - # GetCount -> puCount:*ULONG - "GetCount": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(7, "GetCount"), - } - -IEnumBackgroundCopyJobs._functions_ = { - # QueryInterface -> riid:REFIID, ppvObject:**void - "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), - # AddRef -> - "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), - # Release -> - "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # Next -> celt:ULONG, rgelt:**IBackgroundCopyJob, pceltFetched:*ULONG - "Next": ctypes.WINFUNCTYPE(HRESULT, ULONG, POINTER(IBackgroundCopyJob), POINTER(ULONG))(3, "Next"), - # Skip -> celt:ULONG - "Skip": ctypes.WINFUNCTYPE(HRESULT, ULONG)(4, "Skip"), - # Reset -> - "Reset": ctypes.WINFUNCTYPE(HRESULT)(5, "Reset"), - # Clone -> ppenum:**IEnumBackgroundCopyJobs - "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IEnumBackgroundCopyJobs))(6, "Clone"), - # GetCount -> puCount:*ULONG - "GetCount": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(7, "GetCount"), - } - IEnumVARIANT._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), @@ -526,25 +364,6 @@ IEnumVARIANT._functions_ = { "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IEnumVARIANT))(6, "Clone"), } -IEnumWbemClassObject._functions_ = { - # QueryInterface -> riid:REFIID, ppvObject:**void - "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), - # AddRef -> - "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), - # Release -> - "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # Reset -> - "Reset": ctypes.WINFUNCTYPE(HRESULT)(3, "Reset"), - # Next -> lTimeout:LONG, uCount:ULONG, apObjects:**IWbemClassObject, puReturned:*ULONG - "Next": ctypes.WINFUNCTYPE(HRESULT, LONG, ULONG, POINTER(IWbemClassObject), POINTER(ULONG))(4, "Next"), - # NextAsync -> uCount:ULONG, pSink:*IWbemObjectSink - "NextAsync": ctypes.WINFUNCTYPE(HRESULT, ULONG, IWbemObjectSink)(5, "NextAsync"), - # Clone -> ppEnum:**IEnumWbemClassObject - "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IEnumWbemClassObject))(6, "Clone"), - # Skip -> lTimeout:LONG, nCount:ULONG - "Skip": ctypes.WINFUNCTYPE(HRESULT, LONG, ULONG)(7, "Skip"), - } - INetFwPolicy2._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), @@ -745,6 +564,17 @@ INetFwServiceRestriction._functions_ = { "get_Rules": ctypes.WINFUNCTYPE(HRESULT, POINTER(INetFwRules))(9, "get_Rules"), } +IPersist._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # GetClassID -> pClassID:*CLSID + "GetClassID": ctypes.WINFUNCTYPE(HRESULT, POINTER(CLSID))(3, "GetClassID"), + } + IPersistFile._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), @@ -954,207 +784,316 @@ IUnknown._functions_ = { "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), } -IWbemCallResult._functions_ = { +IBackgroundCopyCallback._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), # AddRef -> "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), # Release -> "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # GetResultObject -> lTimeout:LONG, ppResultObject:**IWbemClassObject - "GetResultObject": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemClassObject))(3, "GetResultObject"), - # GetResultString -> lTimeout:LONG, pstrResultString:*BSTR - "GetResultString": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR))(4, "GetResultString"), - # GetResultServices -> lTimeout:LONG, ppServices:**IWbemServices - "GetResultServices": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemServices))(5, "GetResultServices"), - # GetCallStatus -> lTimeout:LONG, plStatus:*LONG - "GetCallStatus": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(LONG))(6, "GetCallStatus"), + # JobTransferred -> pJob:*IBackgroundCopyJob + "JobTransferred": ctypes.WINFUNCTYPE(HRESULT, IBackgroundCopyJob)(3, "JobTransferred"), + # JobError -> pJob:*IBackgroundCopyJob, pError:*IBackgroundCopyError + "JobError": ctypes.WINFUNCTYPE(HRESULT, IBackgroundCopyJob, IBackgroundCopyError)(4, "JobError"), + # JobModification -> pJob:*IBackgroundCopyJob, dwReserved:DWORD + "JobModification": ctypes.WINFUNCTYPE(HRESULT, IBackgroundCopyJob, DWORD)(5, "JobModification"), } -IWbemClassObject._functions_ = { +IBackgroundCopyError._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), # AddRef -> "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), # Release -> "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # GetQualifierSet -> ppQualSet:**IWbemQualifierSet - "GetQualifierSet": ctypes.WINFUNCTYPE(HRESULT, POINTER(IWbemQualifierSet))(3, "GetQualifierSet"), - # Get -> wszName:LPCWSTR, lFlags:LONG, pVal:*VARIANT, pType:*CIMTYPE, plFlavor:*LONG - "Get": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT), POINTER(CIMTYPE), POINTER(LONG))(4, "Get"), - # Put -> wszName:LPCWSTR, lFlags:LONG, pVal:*VARIANT, Type:CIMTYPE - "Put": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT), CIMTYPE)(5, "Put"), - # Delete -> wszName:LPCWSTR - "Delete": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(6, "Delete"), - # GetNames -> wszQualifierName:LPCWSTR, lFlags:LONG, pQualifierVal:*VARIANT, pNames:**SAFEARRAY - "GetNames": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT), POINTER(POINTER(SAFEARRAY)))(7, "GetNames"), - # BeginEnumeration -> lEnumFlags:LONG - "BeginEnumeration": ctypes.WINFUNCTYPE(HRESULT, LONG)(8, "BeginEnumeration"), - # Next -> lFlags:LONG, strName:*BSTR, pVal:*VARIANT, pType:*CIMTYPE, plFlavor:*LONG - "Next": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR), POINTER(VARIANT), POINTER(CIMTYPE), POINTER(LONG))(9, "Next"), - # EndEnumeration -> - "EndEnumeration": ctypes.WINFUNCTYPE(HRESULT)(10, "EndEnumeration"), - # GetPropertyQualifierSet -> wszProperty:LPCWSTR, ppQualSet:**IWbemQualifierSet - "GetPropertyQualifierSet": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, POINTER(IWbemQualifierSet))(11, "GetPropertyQualifierSet"), - # Clone -> ppCopy:**IWbemClassObject - "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IWbemClassObject))(12, "Clone"), - # GetObjectText -> lFlags:LONG, pstrObjectText:*BSTR - "GetObjectText": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR))(13, "GetObjectText"), - # SpawnDerivedClass -> lFlags:LONG, ppNewClass:**IWbemClassObject - "SpawnDerivedClass": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemClassObject))(14, "SpawnDerivedClass"), - # SpawnInstance -> lFlags:LONG, ppNewInstance:**IWbemClassObject - "SpawnInstance": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemClassObject))(15, "SpawnInstance"), - # CompareTo -> lFlags:LONG, pCompareTo:*IWbemClassObject - "CompareTo": ctypes.WINFUNCTYPE(HRESULT, LONG, IWbemClassObject)(16, "CompareTo"), - # GetPropertyOrigin -> wszName:LPCWSTR, pstrClassName:*BSTR - "GetPropertyOrigin": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, POINTER(BSTR))(17, "GetPropertyOrigin"), - # InheritsFrom -> strAncestor:LPCWSTR - "InheritsFrom": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(18, "InheritsFrom"), - # GetMethod -> wszName:LPCWSTR, lFlags:LONG, ppInSignature:**IWbemClassObject, ppOutSignature:**IWbemClassObject - "GetMethod": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(IWbemClassObject), POINTER(IWbemClassObject))(19, "GetMethod"), - # PutMethod -> wszName:LPCWSTR, lFlags:LONG, pInSignature:*IWbemClassObject, pOutSignature:*IWbemClassObject - "PutMethod": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, IWbemClassObject, IWbemClassObject)(20, "PutMethod"), - # DeleteMethod -> wszName:LPCWSTR - "DeleteMethod": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(21, "DeleteMethod"), - # BeginMethodEnumeration -> lEnumFlags:LONG - "BeginMethodEnumeration": ctypes.WINFUNCTYPE(HRESULT, LONG)(22, "BeginMethodEnumeration"), - # NextMethod -> lFlags:LONG, pstrName:*BSTR, ppInSignature:**IWbemClassObject, ppOutSignature:**IWbemClassObject - "NextMethod": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR), POINTER(IWbemClassObject), POINTER(IWbemClassObject))(23, "NextMethod"), - # EndMethodEnumeration -> - "EndMethodEnumeration": ctypes.WINFUNCTYPE(HRESULT)(24, "EndMethodEnumeration"), - # GetMethodQualifierSet -> wszMethod:LPCWSTR, ppQualSet:**IWbemQualifierSet - "GetMethodQualifierSet": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, POINTER(IWbemQualifierSet))(25, "GetMethodQualifierSet"), - # GetMethodOrigin -> wszMethodName:LPCWSTR, pstrClassName:*BSTR - "GetMethodOrigin": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, POINTER(BSTR))(26, "GetMethodOrigin"), + # GetError -> pContext:*BG_ERROR_CONTEXT, pCode:*HRESULT + "GetError": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_ERROR_CONTEXT), POINTER(HRESULT))(3, "GetError"), + # GetFile -> pVal:**IBackgroundCopyFile + "GetFile": ctypes.WINFUNCTYPE(HRESULT, POINTER(IBackgroundCopyFile))(4, "GetFile"), + # GetErrorDescription -> LanguageId:DWORD, pErrorDescription:*LPWSTR + "GetErrorDescription": ctypes.WINFUNCTYPE(HRESULT, DWORD, POINTER(LPWSTR))(5, "GetErrorDescription"), + # GetErrorContextDescription -> LanguageId:DWORD, pContextDescription:*LPWSTR + "GetErrorContextDescription": ctypes.WINFUNCTYPE(HRESULT, DWORD, POINTER(LPWSTR))(6, "GetErrorContextDescription"), + # GetProtocol -> pProtocol:*LPWSTR + "GetProtocol": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(7, "GetProtocol"), } -IWbemContext._functions_ = { +IBackgroundCopyFile._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), # AddRef -> "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), # Release -> "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # Clone -> ppNewCopy:**IWbemContext - "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IWbemContext))(3, "Clone"), - # GetNames -> lFlags:LONG, pNames:**SAFEARRAY - "GetNames": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(POINTER(SAFEARRAY)))(4, "GetNames"), - # BeginEnumeration -> lFlags:LONG - "BeginEnumeration": ctypes.WINFUNCTYPE(HRESULT, LONG)(5, "BeginEnumeration"), - # Next -> lFlags:LONG, pstrName:*BSTR, pValue:*VARIANT - "Next": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR), POINTER(VARIANT))(6, "Next"), - # EndEnumeration -> - "EndEnumeration": ctypes.WINFUNCTYPE(HRESULT)(7, "EndEnumeration"), - # SetValue -> wszName:LPCWSTR, lFlags:LONG, pValue:*VARIANT - "SetValue": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT))(8, "SetValue"), - # GetValue -> wszName:LPCWSTR, lFlags:LONG, pValue:*VARIANT - "GetValue": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT))(9, "GetValue"), - # DeleteValue -> wszName:LPCWSTR, lFlags:LONG - "DeleteValue": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG)(10, "DeleteValue"), - # DeleteAll -> - "DeleteAll": ctypes.WINFUNCTYPE(HRESULT)(11, "DeleteAll"), + # GetRemoteName -> pVal:*LPWSTR + "GetRemoteName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(3, "GetRemoteName"), + # GetLocalName -> pVal:*LPWSTR + "GetLocalName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(4, "GetLocalName"), + # GetProgress -> pVal:*BG_FILE_PROGRESS + "GetProgress": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_FILE_PROGRESS))(5, "GetProgress"), } -IWbemLocator._functions_ = { +IBackgroundCopyFile2._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), # AddRef -> "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), # Release -> "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # ConnectServer -> strNetworkResource:BSTR, strUser:BSTR, strPassword:BSTR, strLocale:BSTR, lSecurityFlags:LONG, strAuthority:BSTR, pCtx:*IWbemContext, ppNamespace:**IWbemServices - "ConnectServer": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, BSTR, BSTR, LONG, BSTR, IWbemContext, POINTER(IWbemServices))(3, "ConnectServer"), + # GetRemoteName -> pVal:*LPWSTR + "GetRemoteName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(3, "GetRemoteName"), + # GetLocalName -> pVal:*LPWSTR + "GetLocalName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(4, "GetLocalName"), + # GetProgress -> pVal:*BG_FILE_PROGRESS + "GetProgress": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_FILE_PROGRESS))(5, "GetProgress"), + # GetFileRanges -> RangeCount:*DWORD, Ranges:**BG_FILE_RANGE + "GetFileRanges": ctypes.WINFUNCTYPE(HRESULT, POINTER(DWORD), POINTER(POINTER(BG_FILE_RANGE)))(6, "GetFileRanges"), + # SetRemoteName -> Val:LPCWSTR + "SetRemoteName": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(7, "SetRemoteName"), } -IWbemObjectSink._functions_ = { +IBackgroundCopyFile3._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), # AddRef -> "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), # Release -> "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # Indicate -> lObjectCount:LONG, apObjArray:**IWbemClassObject - "Indicate": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemClassObject))(3, "Indicate"), - # SetStatus -> lFlags:LONG, hResult:HRESULT, strParam:BSTR, pObjParam:*IWbemClassObject - "SetStatus": ctypes.WINFUNCTYPE(HRESULT, LONG, HRESULT, BSTR, IWbemClassObject)(4, "SetStatus"), + # GetRemoteName -> pVal:*LPWSTR + "GetRemoteName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(3, "GetRemoteName"), + # GetLocalName -> pVal:*LPWSTR + "GetLocalName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(4, "GetLocalName"), + # GetProgress -> pVal:*BG_FILE_PROGRESS + "GetProgress": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_FILE_PROGRESS))(5, "GetProgress"), + # GetFileRanges -> RangeCount:*DWORD, Ranges:**BG_FILE_RANGE + "GetFileRanges": ctypes.WINFUNCTYPE(HRESULT, POINTER(DWORD), POINTER(POINTER(BG_FILE_RANGE)))(6, "GetFileRanges"), + # SetRemoteName -> Val:LPCWSTR + "SetRemoteName": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(7, "SetRemoteName"), + # GetTemporaryName -> pFilename:*LPWSTR + "GetTemporaryName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(8, "GetTemporaryName"), + # SetValidationState -> state:BOOL + "SetValidationState": ctypes.WINFUNCTYPE(HRESULT, BOOL)(9, "SetValidationState"), + # GetValidationState -> pState:*BOOL + "GetValidationState": ctypes.WINFUNCTYPE(HRESULT, POINTER(BOOL))(10, "GetValidationState"), + # IsDownloadedFromPeer -> pVal:*BOOL + "IsDownloadedFromPeer": ctypes.WINFUNCTYPE(HRESULT, POINTER(BOOL))(11, "IsDownloadedFromPeer"), } -IWbemQualifierSet._functions_ = { +IBackgroundCopyJob._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), # AddRef -> "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), # Release -> "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # Get -> wszName:LPCWSTR, lFlags:LONG, pVal:*VARIANT, plFlavor:*LONG - "Get": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT), POINTER(LONG))(3, "Get"), - # Put -> wszName:LPCWSTR, pVal:*VARIANT, lFlavor:LONG - "Put": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, POINTER(VARIANT), LONG)(4, "Put"), - # Delete -> wszName:LPCWSTR - "Delete": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(5, "Delete"), - # GetNames -> lFlags:LONG, pNames:**SAFEARRAY - "GetNames": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(POINTER(SAFEARRAY)))(6, "GetNames"), - # BeginEnumeration -> lFlags:LONG - "BeginEnumeration": ctypes.WINFUNCTYPE(HRESULT, LONG)(7, "BeginEnumeration"), - # Next -> lFlags:LONG, pstrName:*BSTR, pVal:*VARIANT, plFlavor:*LONG - "Next": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR), POINTER(VARIANT), POINTER(LONG))(8, "Next"), - # EndEnumeration -> - "EndEnumeration": ctypes.WINFUNCTYPE(HRESULT)(9, "EndEnumeration"), + # AddFileSet -> cFileCount:ULONG, pFileSet:*BG_FILE_INFO + "AddFileSet": ctypes.WINFUNCTYPE(HRESULT, ULONG, POINTER(BG_FILE_INFO))(3, "AddFileSet"), + # AddFile -> RemoteUrl:LPCWSTR, LocalName:LPCWSTR + "AddFile": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LPCWSTR)(4, "AddFile"), + # EnumFiles -> pEnum:**IEnumBackgroundCopyFiles + "EnumFiles": ctypes.WINFUNCTYPE(HRESULT, POINTER(IEnumBackgroundCopyFiles))(5, "EnumFiles"), + # Suspend -> + "Suspend": ctypes.WINFUNCTYPE(HRESULT)(6, "Suspend"), + # Resume -> + "Resume": ctypes.WINFUNCTYPE(HRESULT)(7, "Resume"), + # Cancel -> + "Cancel": ctypes.WINFUNCTYPE(HRESULT)(8, "Cancel"), + # Complete -> + "Complete": ctypes.WINFUNCTYPE(HRESULT)(9, "Complete"), + # GetId -> pVal:*GUID + "GetId": ctypes.WINFUNCTYPE(HRESULT, POINTER(GUID))(10, "GetId"), + # GetType -> pVal:*BG_JOB_TYPE + "GetType": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_TYPE))(11, "GetType"), + # GetProgress -> pVal:*BG_JOB_PROGRESS + "GetProgress": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_PROGRESS))(12, "GetProgress"), + # GetTimes -> pVal:*BG_JOB_TIMES + "GetTimes": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_TIMES))(13, "GetTimes"), + # GetState -> pVal:*BG_JOB_STATE + "GetState": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_STATE))(14, "GetState"), + # GetError -> ppError:**IBackgroundCopyError + "GetError": ctypes.WINFUNCTYPE(HRESULT, POINTER(IBackgroundCopyError))(15, "GetError"), + # GetOwner -> pVal:*LPWSTR + "GetOwner": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(16, "GetOwner"), + # SetDisplayName -> Val:LPCWSTR + "SetDisplayName": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(17, "SetDisplayName"), + # GetDisplayName -> pVal:*LPWSTR + "GetDisplayName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(18, "GetDisplayName"), + # SetDescription -> Val:LPCWSTR + "SetDescription": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(19, "SetDescription"), + # GetDescription -> pVal:*LPWSTR + "GetDescription": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(20, "GetDescription"), + # SetPriority -> Val:BG_JOB_PRIORITY + "SetPriority": ctypes.WINFUNCTYPE(HRESULT, BG_JOB_PRIORITY)(21, "SetPriority"), + # GetPriority -> pVal:*BG_JOB_PRIORITY + "GetPriority": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_PRIORITY))(22, "GetPriority"), + # SetNotifyFlags -> Val:ULONG + "SetNotifyFlags": ctypes.WINFUNCTYPE(HRESULT, ULONG)(23, "SetNotifyFlags"), + # GetNotifyFlags -> pVal:*ULONG + "GetNotifyFlags": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(24, "GetNotifyFlags"), + # SetNotifyInterface -> Val:*IUnknown + "SetNotifyInterface": ctypes.WINFUNCTYPE(HRESULT, IUnknown)(25, "SetNotifyInterface"), + # GetNotifyInterface -> pVal:**IUnknown + "GetNotifyInterface": ctypes.WINFUNCTYPE(HRESULT, POINTER(IUnknown))(26, "GetNotifyInterface"), + # SetMinimumRetryDelay -> Seconds:ULONG + "SetMinimumRetryDelay": ctypes.WINFUNCTYPE(HRESULT, ULONG)(27, "SetMinimumRetryDelay"), + # GetMinimumRetryDelay -> Seconds:*ULONG + "GetMinimumRetryDelay": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(28, "GetMinimumRetryDelay"), + # SetNoProgressTimeout -> Seconds:ULONG + "SetNoProgressTimeout": ctypes.WINFUNCTYPE(HRESULT, ULONG)(29, "SetNoProgressTimeout"), + # GetNoProgressTimeout -> Seconds:*ULONG + "GetNoProgressTimeout": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(30, "GetNoProgressTimeout"), + # GetErrorCount -> Errors:*ULONG + "GetErrorCount": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(31, "GetErrorCount"), + # SetProxySettings -> ProxyUsage:BG_JOB_PROXY_USAGE, ProxyList:*WCHAR, ProxyBypassList:*WCHAR + "SetProxySettings": ctypes.WINFUNCTYPE(HRESULT, BG_JOB_PROXY_USAGE, POINTER(WCHAR), POINTER(WCHAR))(32, "SetProxySettings"), + # GetProxySettings -> pProxyUsage:*BG_JOB_PROXY_USAGE, pProxyList:*LPWSTR, pProxyBypassList:*LPWSTR + "GetProxySettings": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_PROXY_USAGE), POINTER(LPWSTR), POINTER(LPWSTR))(33, "GetProxySettings"), + # TakeOwnership -> + "TakeOwnership": ctypes.WINFUNCTYPE(HRESULT)(34, "TakeOwnership"), } -IWbemServices._functions_ = { +IBackgroundCopyJob2._functions_ = { # QueryInterface -> riid:REFIID, ppvObject:**void "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), # AddRef -> "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), # Release -> "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), - # OpenNamespace -> strNamespace:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppWorkingNamespace:**IWbemServices, ppResult:**IWbemCallResult - "OpenNamespace": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IWbemServices), POINTER(IWbemCallResult))(3, "OpenNamespace"), - # CancelAsyncCall -> pSink:*IWbemObjectSink - "CancelAsyncCall": ctypes.WINFUNCTYPE(HRESULT, IWbemObjectSink)(4, "CancelAsyncCall"), - # QueryObjectSink -> lFlags:LONG, ppResponseHandler:**IWbemObjectSink - "QueryObjectSink": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemObjectSink))(5, "QueryObjectSink"), - # GetObject -> strObjectPath:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppObject:**IWbemClassObject, ppCallResult:**IWbemCallResult - "GetObject": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IWbemClassObject), POINTER(IWbemCallResult))(6, "GetObject"), - # GetObjectAsync -> strObjectPath:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink - "GetObjectAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, IWbemObjectSink)(7, "GetObjectAsync"), - # PutClass -> pObject:*IWbemClassObject, lFlags:LONG, pCtx:*IWbemContext, ppCallResult:**IWbemCallResult - "PutClass": ctypes.WINFUNCTYPE(HRESULT, IWbemClassObject, LONG, IWbemContext, POINTER(IWbemCallResult))(8, "PutClass"), - # PutClassAsync -> pObject:*IWbemClassObject, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink - "PutClassAsync": ctypes.WINFUNCTYPE(HRESULT, IWbemClassObject, LONG, IWbemContext, IWbemObjectSink)(9, "PutClassAsync"), - # DeleteClass -> strClass:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppCallResult:**IWbemCallResult - "DeleteClass": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IWbemCallResult))(10, "DeleteClass"), - # DeleteClassAsync -> strClass:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink - "DeleteClassAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, IWbemObjectSink)(11, "DeleteClassAsync"), - # CreateClassEnum -> strSuperclass:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppEnum:**IEnumWbemClassObject - "CreateClassEnum": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IEnumWbemClassObject))(12, "CreateClassEnum"), - # CreateClassEnumAsync -> strSuperclass:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink - "CreateClassEnumAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, IWbemObjectSink)(13, "CreateClassEnumAsync"), - # PutInstance -> pInst:*IWbemClassObject, lFlags:LONG, pCtx:*IWbemContext, ppCallResult:**IWbemCallResult - "PutInstance": ctypes.WINFUNCTYPE(HRESULT, IWbemClassObject, LONG, IWbemContext, POINTER(IWbemCallResult))(14, "PutInstance"), - # PutInstanceAsync -> pInst:*IWbemClassObject, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink - "PutInstanceAsync": ctypes.WINFUNCTYPE(HRESULT, IWbemClassObject, LONG, IWbemContext, IWbemObjectSink)(15, "PutInstanceAsync"), - # DeleteInstance -> strObjectPath:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppCallResult:**IWbemCallResult - "DeleteInstance": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IWbemCallResult))(16, "DeleteInstance"), - # DeleteInstanceAsync -> strObjectPath:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink - "DeleteInstanceAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, IWbemObjectSink)(17, "DeleteInstanceAsync"), - # CreateInstanceEnum -> strFilter:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppEnum:**IEnumWbemClassObject - "CreateInstanceEnum": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IEnumWbemClassObject))(18, "CreateInstanceEnum"), - # CreateInstanceEnumAsync -> strFilter:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink - "CreateInstanceEnumAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, IWbemObjectSink)(19, "CreateInstanceEnumAsync"), - # ExecQuery -> strQueryLanguage:BSTR, strQuery:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppEnum:**IEnumWbemClassObject - "ExecQuery": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, POINTER(IEnumWbemClassObject))(20, "ExecQuery"), - # ExecQueryAsync -> strQueryLanguage:BSTR, strQuery:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink - "ExecQueryAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, IWbemObjectSink)(21, "ExecQueryAsync"), - # ExecNotificationQuery -> strQueryLanguage:BSTR, strQuery:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppEnum:**IEnumWbemClassObject - "ExecNotificationQuery": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, POINTER(IEnumWbemClassObject))(22, "ExecNotificationQuery"), - # ExecNotificationQueryAsync -> strQueryLanguage:BSTR, strQuery:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink - "ExecNotificationQueryAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, IWbemObjectSink)(23, "ExecNotificationQueryAsync"), - # ExecMethod -> strObjectPath:BSTR, strMethodName:BSTR, lFlags:LONG, pCtx:*IWbemContext, pInParams:*IWbemClassObject, ppOutParams:**IWbemClassObject, ppCallResult:**IWbemCallResult - "ExecMethod": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, IWbemClassObject, POINTER(IWbemClassObject), POINTER(IWbemCallResult))(24, "ExecMethod"), - # ExecMethodAsync -> strObjectPath:BSTR, strMethodName:BSTR, lFlags:LONG, pCtx:*IWbemContext, pInParams:*IWbemClassObject, pResponseHandler:*IWbemObjectSink - "ExecMethodAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, IWbemClassObject, IWbemObjectSink)(25, "ExecMethodAsync"), + # AddFileSet -> cFileCount:ULONG, pFileSet:*BG_FILE_INFO + "AddFileSet": ctypes.WINFUNCTYPE(HRESULT, ULONG, POINTER(BG_FILE_INFO))(3, "AddFileSet"), + # AddFile -> RemoteUrl:LPCWSTR, LocalName:LPCWSTR + "AddFile": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LPCWSTR)(4, "AddFile"), + # EnumFiles -> pEnum:**IEnumBackgroundCopyFiles + "EnumFiles": ctypes.WINFUNCTYPE(HRESULT, POINTER(IEnumBackgroundCopyFiles))(5, "EnumFiles"), + # Suspend -> + "Suspend": ctypes.WINFUNCTYPE(HRESULT)(6, "Suspend"), + # Resume -> + "Resume": ctypes.WINFUNCTYPE(HRESULT)(7, "Resume"), + # Cancel -> + "Cancel": ctypes.WINFUNCTYPE(HRESULT)(8, "Cancel"), + # Complete -> + "Complete": ctypes.WINFUNCTYPE(HRESULT)(9, "Complete"), + # GetId -> pVal:*GUID + "GetId": ctypes.WINFUNCTYPE(HRESULT, POINTER(GUID))(10, "GetId"), + # GetType -> pVal:*BG_JOB_TYPE + "GetType": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_TYPE))(11, "GetType"), + # GetProgress -> pVal:*BG_JOB_PROGRESS + "GetProgress": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_PROGRESS))(12, "GetProgress"), + # GetTimes -> pVal:*BG_JOB_TIMES + "GetTimes": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_TIMES))(13, "GetTimes"), + # GetState -> pVal:*BG_JOB_STATE + "GetState": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_STATE))(14, "GetState"), + # GetError -> ppError:**IBackgroundCopyError + "GetError": ctypes.WINFUNCTYPE(HRESULT, POINTER(IBackgroundCopyError))(15, "GetError"), + # GetOwner -> pVal:*LPWSTR + "GetOwner": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(16, "GetOwner"), + # SetDisplayName -> Val:LPCWSTR + "SetDisplayName": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(17, "SetDisplayName"), + # GetDisplayName -> pVal:*LPWSTR + "GetDisplayName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(18, "GetDisplayName"), + # SetDescription -> Val:LPCWSTR + "SetDescription": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(19, "SetDescription"), + # GetDescription -> pVal:*LPWSTR + "GetDescription": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(20, "GetDescription"), + # SetPriority -> Val:BG_JOB_PRIORITY + "SetPriority": ctypes.WINFUNCTYPE(HRESULT, BG_JOB_PRIORITY)(21, "SetPriority"), + # GetPriority -> pVal:*BG_JOB_PRIORITY + "GetPriority": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_PRIORITY))(22, "GetPriority"), + # SetNotifyFlags -> Val:ULONG + "SetNotifyFlags": ctypes.WINFUNCTYPE(HRESULT, ULONG)(23, "SetNotifyFlags"), + # GetNotifyFlags -> pVal:*ULONG + "GetNotifyFlags": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(24, "GetNotifyFlags"), + # SetNotifyInterface -> Val:*IUnknown + "SetNotifyInterface": ctypes.WINFUNCTYPE(HRESULT, IUnknown)(25, "SetNotifyInterface"), + # GetNotifyInterface -> pVal:**IUnknown + "GetNotifyInterface": ctypes.WINFUNCTYPE(HRESULT, POINTER(IUnknown))(26, "GetNotifyInterface"), + # SetMinimumRetryDelay -> Seconds:ULONG + "SetMinimumRetryDelay": ctypes.WINFUNCTYPE(HRESULT, ULONG)(27, "SetMinimumRetryDelay"), + # GetMinimumRetryDelay -> Seconds:*ULONG + "GetMinimumRetryDelay": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(28, "GetMinimumRetryDelay"), + # SetNoProgressTimeout -> Seconds:ULONG + "SetNoProgressTimeout": ctypes.WINFUNCTYPE(HRESULT, ULONG)(29, "SetNoProgressTimeout"), + # GetNoProgressTimeout -> Seconds:*ULONG + "GetNoProgressTimeout": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(30, "GetNoProgressTimeout"), + # GetErrorCount -> Errors:*ULONG + "GetErrorCount": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(31, "GetErrorCount"), + # SetProxySettings -> ProxyUsage:BG_JOB_PROXY_USAGE, ProxyList:*WCHAR, ProxyBypassList:*WCHAR + "SetProxySettings": ctypes.WINFUNCTYPE(HRESULT, BG_JOB_PROXY_USAGE, POINTER(WCHAR), POINTER(WCHAR))(32, "SetProxySettings"), + # GetProxySettings -> pProxyUsage:*BG_JOB_PROXY_USAGE, pProxyList:*LPWSTR, pProxyBypassList:*LPWSTR + "GetProxySettings": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_PROXY_USAGE), POINTER(LPWSTR), POINTER(LPWSTR))(33, "GetProxySettings"), + # TakeOwnership -> + "TakeOwnership": ctypes.WINFUNCTYPE(HRESULT)(34, "TakeOwnership"), + # SetNotifyCmdLine -> Program:LPCWSTR, Parameters:LPCWSTR + "SetNotifyCmdLine": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LPCWSTR)(35, "SetNotifyCmdLine"), + # GetNotifyCmdLine -> pProgram:*LPWSTR, pParameters:*LPWSTR + "GetNotifyCmdLine": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR), POINTER(LPWSTR))(36, "GetNotifyCmdLine"), + # GetReplyProgress -> pProgress:*BG_JOB_REPLY_PROGRESS + "GetReplyProgress": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_JOB_REPLY_PROGRESS))(37, "GetReplyProgress"), + # GetReplyData -> ppBuffer:**BYTE, pLength:*UINT64 + "GetReplyData": ctypes.WINFUNCTYPE(HRESULT, POINTER(POINTER(BYTE)), POINTER(UINT64))(38, "GetReplyData"), + # SetReplyFileName -> ReplyFileName:LPCWSTR + "SetReplyFileName": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(39, "SetReplyFileName"), + # GetReplyFileName -> pReplyFileName:*LPWSTR + "GetReplyFileName": ctypes.WINFUNCTYPE(HRESULT, POINTER(LPWSTR))(40, "GetReplyFileName"), + # SetCredentials -> credentials:*BG_AUTH_CREDENTIALS + "SetCredentials": ctypes.WINFUNCTYPE(HRESULT, POINTER(BG_AUTH_CREDENTIALS))(41, "SetCredentials"), + # RemoveCredentials -> Target:BG_AUTH_TARGET, Scheme:BG_AUTH_SCHEME + "RemoveCredentials": ctypes.WINFUNCTYPE(HRESULT, BG_AUTH_TARGET, BG_AUTH_SCHEME)(42, "RemoveCredentials"), + } + +IBackgroundCopyManager._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # CreateJob -> DisplayName:LPCWSTR, Type:BG_JOB_TYPE, pJobId:*GUID, ppJob:**IBackgroundCopyJob + "CreateJob": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, BG_JOB_TYPE, POINTER(GUID), POINTER(IBackgroundCopyJob))(3, "CreateJob"), + # GetJob -> jobID:REFGUID, ppJob:**IBackgroundCopyJob + "GetJob": ctypes.WINFUNCTYPE(HRESULT, REFGUID, POINTER(IBackgroundCopyJob))(4, "GetJob"), + # EnumJobs -> dwFlags:DWORD, ppEnum:**IEnumBackgroundCopyJobs + "EnumJobs": ctypes.WINFUNCTYPE(HRESULT, DWORD, POINTER(IEnumBackgroundCopyJobs))(5, "EnumJobs"), + # GetErrorDescription -> hResult:HRESULT, LanguageId:DWORD, pErrorDescription:*LPWSTR + "GetErrorDescription": ctypes.WINFUNCTYPE(HRESULT, HRESULT, DWORD, POINTER(LPWSTR))(6, "GetErrorDescription"), + } + +IEnumBackgroundCopyFiles._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # Next -> celt:ULONG, rgelt:**IBackgroundCopyFile, pceltFetched:*ULONG + "Next": ctypes.WINFUNCTYPE(HRESULT, ULONG, POINTER(IBackgroundCopyFile), POINTER(ULONG))(3, "Next"), + # Skip -> celt:ULONG + "Skip": ctypes.WINFUNCTYPE(HRESULT, ULONG)(4, "Skip"), + # Reset -> + "Reset": ctypes.WINFUNCTYPE(HRESULT)(5, "Reset"), + # Clone -> ppenum:**IEnumBackgroundCopyFiles + "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IEnumBackgroundCopyFiles))(6, "Clone"), + # GetCount -> puCount:*ULONG + "GetCount": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(7, "GetCount"), + } + +IEnumBackgroundCopyJobs._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # Next -> celt:ULONG, rgelt:**IBackgroundCopyJob, pceltFetched:*ULONG + "Next": ctypes.WINFUNCTYPE(HRESULT, ULONG, POINTER(IBackgroundCopyJob), POINTER(ULONG))(3, "Next"), + # Skip -> celt:ULONG + "Skip": ctypes.WINFUNCTYPE(HRESULT, ULONG)(4, "Skip"), + # Reset -> + "Reset": ctypes.WINFUNCTYPE(HRESULT)(5, "Reset"), + # Clone -> ppenum:**IEnumBackgroundCopyJobs + "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IEnumBackgroundCopyJobs))(6, "Clone"), + # GetCount -> puCount:*ULONG + "GetCount": ctypes.WINFUNCTYPE(HRESULT, POINTER(ULONG))(7, "GetCount"), } IAction._functions_ = { @@ -2059,3 +1998,370 @@ ITriggerCollection._functions_ = { "Clear": ctypes.WINFUNCTYPE(HRESULT)(12, "Clear"), } +IWebBrowser2._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # GetTypeInfoCount -> pctinfo:*UINT + "GetTypeInfoCount": ctypes.WINFUNCTYPE(HRESULT, POINTER(UINT))(3, "GetTypeInfoCount"), + # GetTypeInfo -> iTInfo:UINT, lcid:LCID, ppTInfo:**ITypeInfo + "GetTypeInfo": ctypes.WINFUNCTYPE(HRESULT, UINT, LCID, POINTER(ITypeInfo))(4, "GetTypeInfo"), + # GetIDsOfNames -> riid:REFIID, rgszNames:*LPOLESTR, cNames:UINT, lcid:LCID, rgDispId:*DISPID + "GetIDsOfNames": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(LPOLESTR), UINT, LCID, POINTER(DISPID))(5, "GetIDsOfNames"), + # Invoke -> dispIdMember:DISPID, riid:REFIID, lcid:LCID, wFlags:WORD, pDispParams:*DISPPARAMS, pVarResult:*VARIANT, pExcepInfo:*EXCEPINFO, puArgErr:*UINT + "Invoke": ctypes.WINFUNCTYPE(HRESULT, DISPID, REFIID, LCID, WORD, POINTER(DISPPARAMS), POINTER(VARIANT), POINTER(EXCEPINFO), POINTER(UINT))(6, "Invoke"), + # GoBack -> + "GoBack": ctypes.WINFUNCTYPE(HRESULT)(7, "GoBack"), + # GoForward -> + "GoForward": ctypes.WINFUNCTYPE(HRESULT)(8, "GoForward"), + # GoHome -> + "GoHome": ctypes.WINFUNCTYPE(HRESULT)(9, "GoHome"), + # GoSearch -> + "GoSearch": ctypes.WINFUNCTYPE(HRESULT)(10, "GoSearch"), + # Navigate -> URL:BSTR, Flags:*VARIANT, TargetFrameName:*VARIANT, PostData:*VARIANT, Headers:*VARIANT + "Navigate": ctypes.WINFUNCTYPE(HRESULT, BSTR, POINTER(VARIANT), POINTER(VARIANT), POINTER(VARIANT), POINTER(VARIANT))(11, "Navigate"), + # Refresh -> + "Refresh": ctypes.WINFUNCTYPE(HRESULT)(12, "Refresh"), + # Refresh2 -> Level:*VARIANT + "Refresh2": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT))(13, "Refresh2"), + # Stop -> + "Stop": ctypes.WINFUNCTYPE(HRESULT)(14, "Stop"), + # get_Application -> ppDisp:**IDispatch + "get_Application": ctypes.WINFUNCTYPE(HRESULT, POINTER(IDispatch))(15, "get_Application"), + # get_Parent -> ppDisp:**IDispatch + "get_Parent": ctypes.WINFUNCTYPE(HRESULT, POINTER(IDispatch))(16, "get_Parent"), + # get_Container -> ppDisp:**IDispatch + "get_Container": ctypes.WINFUNCTYPE(HRESULT, POINTER(IDispatch))(17, "get_Container"), + # get_Document -> ppDisp:**IDispatch + "get_Document": ctypes.WINFUNCTYPE(HRESULT, POINTER(IDispatch))(18, "get_Document"), + # get_TopLevelContainer -> pBool:*VARIANT_BOOL + "get_TopLevelContainer": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(19, "get_TopLevelContainer"), + # get_Type -> Type:*BSTR + "get_Type": ctypes.WINFUNCTYPE(HRESULT, POINTER(BSTR))(20, "get_Type"), + # get_Left -> pl:*LONG + "get_Left": ctypes.WINFUNCTYPE(HRESULT, POINTER(LONG))(21, "get_Left"), + # put_Left -> Left:LONG + "put_Left": ctypes.WINFUNCTYPE(HRESULT, LONG)(22, "put_Left"), + # get_Top -> pl:*LONG + "get_Top": ctypes.WINFUNCTYPE(HRESULT, POINTER(LONG))(23, "get_Top"), + # put_Top -> Top:LONG + "put_Top": ctypes.WINFUNCTYPE(HRESULT, LONG)(24, "put_Top"), + # get_Width -> pl:*LONG + "get_Width": ctypes.WINFUNCTYPE(HRESULT, POINTER(LONG))(25, "get_Width"), + # put_Width -> Width:LONG + "put_Width": ctypes.WINFUNCTYPE(HRESULT, LONG)(26, "put_Width"), + # get_Height -> pl:*LONG + "get_Height": ctypes.WINFUNCTYPE(HRESULT, POINTER(LONG))(27, "get_Height"), + # put_Height -> Height:LONG + "put_Height": ctypes.WINFUNCTYPE(HRESULT, LONG)(28, "put_Height"), + # get_LocationName -> LocationName:*BSTR + "get_LocationName": ctypes.WINFUNCTYPE(HRESULT, POINTER(BSTR))(29, "get_LocationName"), + # get_LocationURL -> LocationURL:*BSTR + "get_LocationURL": ctypes.WINFUNCTYPE(HRESULT, POINTER(BSTR))(30, "get_LocationURL"), + # get_Busy -> pBool:*VARIANT_BOOL + "get_Busy": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(31, "get_Busy"), + # Quit -> + "Quit": ctypes.WINFUNCTYPE(HRESULT)(32, "Quit"), + # ClientToWindow -> pcx:*INT, pcy:*INT + "ClientToWindow": ctypes.WINFUNCTYPE(HRESULT, POINTER(INT), POINTER(INT))(33, "ClientToWindow"), + # PutProperty -> Property:BSTR, vtValue:VARIANT + "PutProperty": ctypes.WINFUNCTYPE(HRESULT, BSTR, VARIANT)(34, "PutProperty"), + # GetProperty -> Property:BSTR, pvtValue:*VARIANT + "GetProperty": ctypes.WINFUNCTYPE(HRESULT, BSTR, POINTER(VARIANT))(35, "GetProperty"), + # get_Name -> Name:*BSTR + "get_Name": ctypes.WINFUNCTYPE(HRESULT, POINTER(BSTR))(36, "get_Name"), + # get_HWND -> pHWND:*PVOID + "get_HWND": ctypes.WINFUNCTYPE(HRESULT, POINTER(PVOID))(37, "get_HWND"), + # get_FullName -> FullName:*BSTR + "get_FullName": ctypes.WINFUNCTYPE(HRESULT, POINTER(BSTR))(38, "get_FullName"), + # get_Path -> Path:*BSTR + "get_Path": ctypes.WINFUNCTYPE(HRESULT, POINTER(BSTR))(39, "get_Path"), + # get_Visible -> pBool:*VARIANT_BOOL + "get_Visible": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(40, "get_Visible"), + # put_Visible -> Value:VARIANT_BOOL + "put_Visible": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(41, "put_Visible"), + # get_StatusBar -> pBool:*VARIANT_BOOL + "get_StatusBar": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(42, "get_StatusBar"), + # put_StatusBar -> Value:VARIANT_BOOL + "put_StatusBar": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(43, "put_StatusBar"), + # get_StatusText -> StatusText:*BSTR + "get_StatusText": ctypes.WINFUNCTYPE(HRESULT, POINTER(BSTR))(44, "get_StatusText"), + # put_StatusText -> StatusText:BSTR + "put_StatusText": ctypes.WINFUNCTYPE(HRESULT, BSTR)(45, "put_StatusText"), + # get_ToolBar -> Value:*INT + "get_ToolBar": ctypes.WINFUNCTYPE(HRESULT, POINTER(INT))(46, "get_ToolBar"), + # put_ToolBar -> Value:INT + "put_ToolBar": ctypes.WINFUNCTYPE(HRESULT, INT)(47, "put_ToolBar"), + # get_MenuBar -> Value:*VARIANT_BOOL + "get_MenuBar": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(48, "get_MenuBar"), + # put_MenuBar -> Value:VARIANT_BOOL + "put_MenuBar": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(49, "put_MenuBar"), + # get_FullScreen -> pbFullScreen:*VARIANT_BOOL + "get_FullScreen": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(50, "get_FullScreen"), + # put_FullScreen -> bFullScreen:VARIANT_BOOL + "put_FullScreen": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(51, "put_FullScreen"), + # Navigate2 -> URL:*VARIANT, Flags:*VARIANT, TargetFrameName:*VARIANT, PostData:*VARIANT, Headers:*VARIANT + "Navigate2": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT), POINTER(VARIANT), POINTER(VARIANT), POINTER(VARIANT), POINTER(VARIANT))(52, "Navigate2"), + # QueryStatusWB -> cmdID:DWORD, pcmdf:*DWORD + "QueryStatusWB": ctypes.WINFUNCTYPE(HRESULT, DWORD, POINTER(DWORD))(53, "QueryStatusWB"), + # ExecWB -> cmdID:DWORD, cmdexecopt:DWORD, pvaIn:*VARIANT, pvaOut:*VARIANT + "ExecWB": ctypes.WINFUNCTYPE(HRESULT, DWORD, DWORD, POINTER(VARIANT), POINTER(VARIANT))(54, "ExecWB"), + # ShowBrowserBar -> pvaClsid:*VARIANT, pvarShow:*VARIANT, pvarSize:*VARIANT + "ShowBrowserBar": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT), POINTER(VARIANT), POINTER(VARIANT))(55, "ShowBrowserBar"), + # get_ReadyState -> plReadyState:*DWORD + "get_ReadyState": ctypes.WINFUNCTYPE(HRESULT, POINTER(DWORD))(56, "get_ReadyState"), + # get_Offline -> pbOffline:*VARIANT_BOOL + "get_Offline": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(57, "get_Offline"), + # put_Offline -> bOffline:VARIANT_BOOL + "put_Offline": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(58, "put_Offline"), + # get_Silent -> pbSilent:*VARIANT_BOOL + "get_Silent": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(59, "get_Silent"), + # put_Silent -> bSilent:VARIANT_BOOL + "put_Silent": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(60, "put_Silent"), + # get_RegisterAsBrowser -> pbRegister:*VARIANT_BOOL + "get_RegisterAsBrowser": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(61, "get_RegisterAsBrowser"), + # put_RegisterAsBrowser -> bRegister:VARIANT_BOOL + "put_RegisterAsBrowser": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(62, "put_RegisterAsBrowser"), + # get_RegisterAsDropTarget -> pbRegister:*VARIANT_BOOL + "get_RegisterAsDropTarget": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(63, "get_RegisterAsDropTarget"), + # put_RegisterAsDropTarget -> bRegister:VARIANT_BOOL + "put_RegisterAsDropTarget": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(64, "put_RegisterAsDropTarget"), + # get_TheaterMode -> pbRegister:*VARIANT_BOOL + "get_TheaterMode": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(65, "get_TheaterMode"), + # put_TheaterMode -> bRegister:VARIANT_BOOL + "put_TheaterMode": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(66, "put_TheaterMode"), + # get_AddressBar -> Value:*VARIANT_BOOL + "get_AddressBar": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(67, "get_AddressBar"), + # put_AddressBar -> Value:VARIANT_BOOL + "put_AddressBar": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(68, "put_AddressBar"), + # get_Resizable -> Value:*VARIANT_BOOL + "get_Resizable": ctypes.WINFUNCTYPE(HRESULT, POINTER(VARIANT_BOOL))(69, "get_Resizable"), + # put_Resizable -> Value:VARIANT_BOOL + "put_Resizable": ctypes.WINFUNCTYPE(HRESULT, VARIANT_BOOL)(70, "put_Resizable"), + } + +IEnumWbemClassObject._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # Reset -> + "Reset": ctypes.WINFUNCTYPE(HRESULT)(3, "Reset"), + # Next -> lTimeout:LONG, uCount:ULONG, apObjects:**IWbemClassObject, puReturned:*ULONG + "Next": ctypes.WINFUNCTYPE(HRESULT, LONG, ULONG, POINTER(IWbemClassObject), POINTER(ULONG))(4, "Next"), + # NextAsync -> uCount:ULONG, pSink:*IWbemObjectSink + "NextAsync": ctypes.WINFUNCTYPE(HRESULT, ULONG, IWbemObjectSink)(5, "NextAsync"), + # Clone -> ppEnum:**IEnumWbemClassObject + "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IEnumWbemClassObject))(6, "Clone"), + # Skip -> lTimeout:LONG, nCount:ULONG + "Skip": ctypes.WINFUNCTYPE(HRESULT, LONG, ULONG)(7, "Skip"), + } + +IWbemCallResult._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # GetResultObject -> lTimeout:LONG, ppResultObject:**IWbemClassObject + "GetResultObject": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemClassObject))(3, "GetResultObject"), + # GetResultString -> lTimeout:LONG, pstrResultString:*BSTR + "GetResultString": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR))(4, "GetResultString"), + # GetResultServices -> lTimeout:LONG, ppServices:**IWbemServices + "GetResultServices": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemServices))(5, "GetResultServices"), + # GetCallStatus -> lTimeout:LONG, plStatus:*LONG + "GetCallStatus": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(LONG))(6, "GetCallStatus"), + } + +IWbemClassObject._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # GetQualifierSet -> ppQualSet:**IWbemQualifierSet + "GetQualifierSet": ctypes.WINFUNCTYPE(HRESULT, POINTER(IWbemQualifierSet))(3, "GetQualifierSet"), + # Get -> wszName:LPCWSTR, lFlags:LONG, pVal:*VARIANT, pType:*CIMTYPE, plFlavor:*LONG + "Get": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT), POINTER(CIMTYPE), POINTER(LONG))(4, "Get"), + # Put -> wszName:LPCWSTR, lFlags:LONG, pVal:*VARIANT, Type:CIMTYPE + "Put": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT), CIMTYPE)(5, "Put"), + # Delete -> wszName:LPCWSTR + "Delete": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(6, "Delete"), + # GetNames -> wszQualifierName:LPCWSTR, lFlags:LONG, pQualifierVal:*VARIANT, pNames:**SAFEARRAY + "GetNames": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT), POINTER(POINTER(SAFEARRAY)))(7, "GetNames"), + # BeginEnumeration -> lEnumFlags:LONG + "BeginEnumeration": ctypes.WINFUNCTYPE(HRESULT, LONG)(8, "BeginEnumeration"), + # Next -> lFlags:LONG, strName:*BSTR, pVal:*VARIANT, pType:*CIMTYPE, plFlavor:*LONG + "Next": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR), POINTER(VARIANT), POINTER(CIMTYPE), POINTER(LONG))(9, "Next"), + # EndEnumeration -> + "EndEnumeration": ctypes.WINFUNCTYPE(HRESULT)(10, "EndEnumeration"), + # GetPropertyQualifierSet -> wszProperty:LPCWSTR, ppQualSet:**IWbemQualifierSet + "GetPropertyQualifierSet": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, POINTER(IWbemQualifierSet))(11, "GetPropertyQualifierSet"), + # Clone -> ppCopy:**IWbemClassObject + "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IWbemClassObject))(12, "Clone"), + # GetObjectText -> lFlags:LONG, pstrObjectText:*BSTR + "GetObjectText": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR))(13, "GetObjectText"), + # SpawnDerivedClass -> lFlags:LONG, ppNewClass:**IWbemClassObject + "SpawnDerivedClass": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemClassObject))(14, "SpawnDerivedClass"), + # SpawnInstance -> lFlags:LONG, ppNewInstance:**IWbemClassObject + "SpawnInstance": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemClassObject))(15, "SpawnInstance"), + # CompareTo -> lFlags:LONG, pCompareTo:*IWbemClassObject + "CompareTo": ctypes.WINFUNCTYPE(HRESULT, LONG, IWbemClassObject)(16, "CompareTo"), + # GetPropertyOrigin -> wszName:LPCWSTR, pstrClassName:*BSTR + "GetPropertyOrigin": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, POINTER(BSTR))(17, "GetPropertyOrigin"), + # InheritsFrom -> strAncestor:LPCWSTR + "InheritsFrom": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(18, "InheritsFrom"), + # GetMethod -> wszName:LPCWSTR, lFlags:LONG, ppInSignature:**IWbemClassObject, ppOutSignature:**IWbemClassObject + "GetMethod": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(IWbemClassObject), POINTER(IWbemClassObject))(19, "GetMethod"), + # PutMethod -> wszName:LPCWSTR, lFlags:LONG, pInSignature:*IWbemClassObject, pOutSignature:*IWbemClassObject + "PutMethod": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, IWbemClassObject, IWbemClassObject)(20, "PutMethod"), + # DeleteMethod -> wszName:LPCWSTR + "DeleteMethod": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(21, "DeleteMethod"), + # BeginMethodEnumeration -> lEnumFlags:LONG + "BeginMethodEnumeration": ctypes.WINFUNCTYPE(HRESULT, LONG)(22, "BeginMethodEnumeration"), + # NextMethod -> lFlags:LONG, pstrName:*BSTR, ppInSignature:**IWbemClassObject, ppOutSignature:**IWbemClassObject + "NextMethod": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR), POINTER(IWbemClassObject), POINTER(IWbemClassObject))(23, "NextMethod"), + # EndMethodEnumeration -> + "EndMethodEnumeration": ctypes.WINFUNCTYPE(HRESULT)(24, "EndMethodEnumeration"), + # GetMethodQualifierSet -> wszMethod:LPCWSTR, ppQualSet:**IWbemQualifierSet + "GetMethodQualifierSet": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, POINTER(IWbemQualifierSet))(25, "GetMethodQualifierSet"), + # GetMethodOrigin -> wszMethodName:LPCWSTR, pstrClassName:*BSTR + "GetMethodOrigin": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, POINTER(BSTR))(26, "GetMethodOrigin"), + } + +IWbemContext._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # Clone -> ppNewCopy:**IWbemContext + "Clone": ctypes.WINFUNCTYPE(HRESULT, POINTER(IWbemContext))(3, "Clone"), + # GetNames -> lFlags:LONG, pNames:**SAFEARRAY + "GetNames": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(POINTER(SAFEARRAY)))(4, "GetNames"), + # BeginEnumeration -> lFlags:LONG + "BeginEnumeration": ctypes.WINFUNCTYPE(HRESULT, LONG)(5, "BeginEnumeration"), + # Next -> lFlags:LONG, pstrName:*BSTR, pValue:*VARIANT + "Next": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR), POINTER(VARIANT))(6, "Next"), + # EndEnumeration -> + "EndEnumeration": ctypes.WINFUNCTYPE(HRESULT)(7, "EndEnumeration"), + # SetValue -> wszName:LPCWSTR, lFlags:LONG, pValue:*VARIANT + "SetValue": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT))(8, "SetValue"), + # GetValue -> wszName:LPCWSTR, lFlags:LONG, pValue:*VARIANT + "GetValue": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT))(9, "GetValue"), + # DeleteValue -> wszName:LPCWSTR, lFlags:LONG + "DeleteValue": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG)(10, "DeleteValue"), + # DeleteAll -> + "DeleteAll": ctypes.WINFUNCTYPE(HRESULT)(11, "DeleteAll"), + } + +IWbemLocator._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # ConnectServer -> strNetworkResource:BSTR, strUser:BSTR, strPassword:BSTR, strLocale:BSTR, lSecurityFlags:LONG, strAuthority:BSTR, pCtx:*IWbemContext, ppNamespace:**IWbemServices + "ConnectServer": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, BSTR, BSTR, LONG, BSTR, IWbemContext, POINTER(IWbemServices))(3, "ConnectServer"), + } + +IWbemObjectSink._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # Indicate -> lObjectCount:LONG, apObjArray:**IWbemClassObject + "Indicate": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemClassObject))(3, "Indicate"), + # SetStatus -> lFlags:LONG, hResult:HRESULT, strParam:BSTR, pObjParam:*IWbemClassObject + "SetStatus": ctypes.WINFUNCTYPE(HRESULT, LONG, HRESULT, BSTR, IWbemClassObject)(4, "SetStatus"), + } + +IWbemQualifierSet._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # Get -> wszName:LPCWSTR, lFlags:LONG, pVal:*VARIANT, plFlavor:*LONG + "Get": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, LONG, POINTER(VARIANT), POINTER(LONG))(3, "Get"), + # Put -> wszName:LPCWSTR, pVal:*VARIANT, lFlavor:LONG + "Put": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR, POINTER(VARIANT), LONG)(4, "Put"), + # Delete -> wszName:LPCWSTR + "Delete": ctypes.WINFUNCTYPE(HRESULT, LPCWSTR)(5, "Delete"), + # GetNames -> lFlags:LONG, pNames:**SAFEARRAY + "GetNames": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(POINTER(SAFEARRAY)))(6, "GetNames"), + # BeginEnumeration -> lFlags:LONG + "BeginEnumeration": ctypes.WINFUNCTYPE(HRESULT, LONG)(7, "BeginEnumeration"), + # Next -> lFlags:LONG, pstrName:*BSTR, pVal:*VARIANT, plFlavor:*LONG + "Next": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(BSTR), POINTER(VARIANT), POINTER(LONG))(8, "Next"), + # EndEnumeration -> + "EndEnumeration": ctypes.WINFUNCTYPE(HRESULT)(9, "EndEnumeration"), + } + +IWbemServices._functions_ = { + # QueryInterface -> riid:REFIID, ppvObject:**void + "QueryInterface": ctypes.WINFUNCTYPE(HRESULT, REFIID, POINTER(PVOID))(0, "QueryInterface"), + # AddRef -> + "AddRef": ctypes.WINFUNCTYPE(ULONG)(1, "AddRef"), + # Release -> + "Release": ctypes.WINFUNCTYPE(ULONG)(2, "Release"), + # OpenNamespace -> strNamespace:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppWorkingNamespace:**IWbemServices, ppResult:**IWbemCallResult + "OpenNamespace": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IWbemServices), POINTER(IWbemCallResult))(3, "OpenNamespace"), + # CancelAsyncCall -> pSink:*IWbemObjectSink + "CancelAsyncCall": ctypes.WINFUNCTYPE(HRESULT, IWbemObjectSink)(4, "CancelAsyncCall"), + # QueryObjectSink -> lFlags:LONG, ppResponseHandler:**IWbemObjectSink + "QueryObjectSink": ctypes.WINFUNCTYPE(HRESULT, LONG, POINTER(IWbemObjectSink))(5, "QueryObjectSink"), + # GetObject -> strObjectPath:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppObject:**IWbemClassObject, ppCallResult:**IWbemCallResult + "GetObject": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IWbemClassObject), POINTER(IWbemCallResult))(6, "GetObject"), + # GetObjectAsync -> strObjectPath:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink + "GetObjectAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, IWbemObjectSink)(7, "GetObjectAsync"), + # PutClass -> pObject:*IWbemClassObject, lFlags:LONG, pCtx:*IWbemContext, ppCallResult:**IWbemCallResult + "PutClass": ctypes.WINFUNCTYPE(HRESULT, IWbemClassObject, LONG, IWbemContext, POINTER(IWbemCallResult))(8, "PutClass"), + # PutClassAsync -> pObject:*IWbemClassObject, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink + "PutClassAsync": ctypes.WINFUNCTYPE(HRESULT, IWbemClassObject, LONG, IWbemContext, IWbemObjectSink)(9, "PutClassAsync"), + # DeleteClass -> strClass:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppCallResult:**IWbemCallResult + "DeleteClass": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IWbemCallResult))(10, "DeleteClass"), + # DeleteClassAsync -> strClass:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink + "DeleteClassAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, IWbemObjectSink)(11, "DeleteClassAsync"), + # CreateClassEnum -> strSuperclass:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppEnum:**IEnumWbemClassObject + "CreateClassEnum": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IEnumWbemClassObject))(12, "CreateClassEnum"), + # CreateClassEnumAsync -> strSuperclass:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink + "CreateClassEnumAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, IWbemObjectSink)(13, "CreateClassEnumAsync"), + # PutInstance -> pInst:*IWbemClassObject, lFlags:LONG, pCtx:*IWbemContext, ppCallResult:**IWbemCallResult + "PutInstance": ctypes.WINFUNCTYPE(HRESULT, IWbemClassObject, LONG, IWbemContext, POINTER(IWbemCallResult))(14, "PutInstance"), + # PutInstanceAsync -> pInst:*IWbemClassObject, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink + "PutInstanceAsync": ctypes.WINFUNCTYPE(HRESULT, IWbemClassObject, LONG, IWbemContext, IWbemObjectSink)(15, "PutInstanceAsync"), + # DeleteInstance -> strObjectPath:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppCallResult:**IWbemCallResult + "DeleteInstance": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IWbemCallResult))(16, "DeleteInstance"), + # DeleteInstanceAsync -> strObjectPath:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink + "DeleteInstanceAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, IWbemObjectSink)(17, "DeleteInstanceAsync"), + # CreateInstanceEnum -> strFilter:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppEnum:**IEnumWbemClassObject + "CreateInstanceEnum": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, POINTER(IEnumWbemClassObject))(18, "CreateInstanceEnum"), + # CreateInstanceEnumAsync -> strFilter:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink + "CreateInstanceEnumAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, LONG, IWbemContext, IWbemObjectSink)(19, "CreateInstanceEnumAsync"), + # ExecQuery -> strQueryLanguage:BSTR, strQuery:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppEnum:**IEnumWbemClassObject + "ExecQuery": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, POINTER(IEnumWbemClassObject))(20, "ExecQuery"), + # ExecQueryAsync -> strQueryLanguage:BSTR, strQuery:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink + "ExecQueryAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, IWbemObjectSink)(21, "ExecQueryAsync"), + # ExecNotificationQuery -> strQueryLanguage:BSTR, strQuery:BSTR, lFlags:LONG, pCtx:*IWbemContext, ppEnum:**IEnumWbemClassObject + "ExecNotificationQuery": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, POINTER(IEnumWbemClassObject))(22, "ExecNotificationQuery"), + # ExecNotificationQueryAsync -> strQueryLanguage:BSTR, strQuery:BSTR, lFlags:LONG, pCtx:*IWbemContext, pResponseHandler:*IWbemObjectSink + "ExecNotificationQueryAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, IWbemObjectSink)(23, "ExecNotificationQueryAsync"), + # ExecMethod -> strObjectPath:BSTR, strMethodName:BSTR, lFlags:LONG, pCtx:*IWbemContext, pInParams:*IWbemClassObject, ppOutParams:**IWbemClassObject, ppCallResult:**IWbemCallResult + "ExecMethod": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, IWbemClassObject, POINTER(IWbemClassObject), POINTER(IWbemCallResult))(24, "ExecMethod"), + # ExecMethodAsync -> strObjectPath:BSTR, strMethodName:BSTR, lFlags:LONG, pCtx:*IWbemContext, pInParams:*IWbemClassObject, pResponseHandler:*IWbemObjectSink + "ExecMethodAsync": ctypes.WINFUNCTYPE(HRESULT, BSTR, BSTR, LONG, IWbemContext, IWbemClassObject, IWbemObjectSink)(25, "ExecMethodAsync"), + } + diff --git a/windows/generated_def/meta.py b/windows/generated_def/meta.py index 7f77e81..e2cab56 100644 --- a/windows/generated_def/meta.py +++ b/windows/generated_def/meta.py @@ -1,8 +1,8 @@ -windef = set(['STATUS_SUSPEND_COUNT_EXCEEDED', 'ERROR_BAD_NET_NAME', 'CMSG_ENVELOPED', 'STANDARD_RIGHTS_WRITE', 'RRF_RT_REG_QWORD', 'ERROR_SYSTEM_SHUTDOWN', 'PROV_FORTEZZA', 'STATUS_TRANSPORT_FULL', 'STATUS_ACPI_INCORRECT_ARGUMENT_COUNT', 'DBG_REPLY_LATER', 'AF_HYLINK', 'ERROR_INVALID_VARIANT', 'CMSG_HASH_DATA_PARAM', 'CMSG_CTRL_ADD_CRL', 'IMAGE_SCN_LNK_REMOVE', 'STGM_TRANSACTED', 'STATUS_BAD_REMOTE_ADAPTER', 'STATUS_DS_SAM_INIT_FAILURE', 'STATUS_VDM_DISALLOWED', 'CONTEXT_FULL', 'RPC_NT_BAD_STUB_DATA', 'ERROR_CANTOPEN', 'STATUS_SXS_KEY_NOT_FOUND', 'CRYPT_ASN_ENCODING', 'EXCEPTION_FLT_UNDERFLOW', 'CMSG_CMS_RECIPIENT_INDEX_PARAM', 'ERROR_BAD_NETPATH', 'OS_NT4ORGREATER', 'SYMBOLIC_LINK_ALL_ACCESS', 'STATUS_PIPE_BUSY', 'CERT_X500_NAME_STR', 'KEY_QUERY_VALUE', 'STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE', 'ERROR_EVT_INVALID_EVENT_DATA', 'STATUS_EVENT_PENDING', 'STATUS_PENDING', 'STATUS_TRANSACTION_FREEZE_IN_PROGRESS', 'ERROR_NO_SPOOL_SPACE', 'STATUS_LOG_CORRUPTION_DETECTED', 'ERROR_CARDBUS_NOT_SUPPORTED', 'NTE_PROVIDER_DLL_FAIL', 'STATUS_NOINTERFACE', 'SYSTEM_MANDATORY_LABEL_NO_WRITE_UP', 'CERT_QUERY_CONTENT_FLAG_PKCS10', 'ANYSIZE_ARRAY', 'PRODUCT_STANDARD_EVALUATION_SERVER', 'RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH', 'CLUSAPI_CHANGE_ACCESS', 'szOID_OIWSEC_desEDE', 'IMAGE_REL_BASED_DIR64', 'STATUS_MAGAZINE_NOT_PRESENT', 'STATUS_TRANSACTIONS_NOT_FROZEN', 'STATUS_SXS_COMPONENT_STORE_CORRUPT', 'STATUS_FLT_INSTANCE_NAME_COLLISION', 'OS_WIN95_GOLD', 'STATUS_NOT_SNAPSHOT_VOLUME', 'STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64', 'STATUS_TOO_MANY_SECRETS', 'ERROR_EVT_MESSAGE_NOT_FOUND', 'STATUS_GRAPHICS_CANT_LOCK_MEMORY', 'AF_NS', 'SDDL_REVISION_1', 'STATUS_FILES_OPEN', 'STATUS_NO_BROWSER_SERVERS_FOUND', 'STATUS_THREADPOOL_RELEASED_DURING_OPERATION', 'CERT_STORE_SHARE_CONTEXT_FLAG', 'DIGSIG_E_CRYPTO', 'ERROR_DBG_TERMINATE_THREAD', 'ERROR_EVT_FILTER_UNSUPPORTEDOP', 'PAGE_EXECUTE_READ', 'ERROR_CURRENT_DIRECTORY', 'STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE', 'CONTEXT_INTEGER', 'SID_HASH_SIZE', 'STATUS_AGENTS_EXHAUSTED', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_INT64', 'SE_GROUP_INTEGRITY_ENABLED', 'ERROR_BAD_UNIT', 'STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER', 'SM_CXDOUBLECLK', 'ERROR_PAGE_FAULT_TRANSITION', 'ERROR_HANDLE_DISK_FULL', 'CERT_PUBKEY_ALG_PARA_PROP_ID', 'ERROR_PWD_HISTORY_CONFLICT', 'CMSG_CTRL_ADD_CMS_SIGNER_INFO', 'STATUS_LOG_NOT_ENOUGH_CONTAINERS', 'RPC_NT_ZERO_DIVIDE', 'SERVICE_TRIGGER_TYPE_CUSTOM', 'STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED', 'STATUS_DISK_RESET_FAILED', 'CERT_TRUST_HAS_KEY_MATCH_ISSUER', 'STATUS_INTERNAL_ERROR', 'STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER', 'szOID_OIWSEC_mdc2RSA', 'STATUS_FWP_SUBLAYER_NOT_FOUND', 'STATUS_INVALID_DOMAIN_ROLE', 'STATUS_LOG_POLICY_ALREADY_INSTALLED', 'ERROR_REGISTRY_CORRUPT', 'ERROR_PROCESS_NOT_IN_JOB', 'STATUS_HOPLIMIT_EXCEEDED', 'RPC_NT_INVALID_NET_ADDR', 'CMSG_SIGNED_AND_ENVELOPED', 'STATUS_TRANSACTION_NOT_FOUND', 'OS_TERMINALSERVER', 'STATUS_NO_CALLBACK_ACTIVE', 'SERVICE_STOP_PENDING', 'SERVICE_TRIGGER_TYPE_FIREWALL_PORT_EVENT', 'szOID_RSA_certExtensions', 'ERROR_INVALID_OPLOCK_PROTOCOL', 'EXCEPTION_ARRAY_BOUNDS_EXCEEDED', 'STATUS_CANT_WAIT', 'KEY_WOW64_32KEY', 'STATUS_WMI_GUID_NOT_FOUND', 'TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY', 'szOID_OIWSEC_desMAC', 'SM_IMMENABLED', 'STATUS_CLUSTER_NETWORK_NOT_INTERNAL', 'CERT_E_VALIDITYPERIODNESTING', 'IMAGE_DLLCHARACTERISTICS_NO_BIND', 'STATUS_NO_SUCH_DOMAIN', 'STATUS_FILE_CLOSED', 'ERROR_NOTIFY_CLEANUP', 'FILE_OPEN_REQUIRING_OPLOCK', 'ERROR_RESOURCE_REQUIREMENTS_CHANGED', 'IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA', 'STATUS_DATA_LATE_ERROR', 'PAGE_WRITECOPY', 'STATUS_GRAPHICS_ALLOCATION_BUSY', 'PRODUCT_ULTIMATE_E', 'CERT_SYSTEM_STORE_USERS_ID', 'STATUS_VIRUS_DELETED', 'RPC_NT_INVALID_ASYNC_CALL', 'STATUS_FLT_NOT_SAFE_TO_POST_OPERATION', 'CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE', 'EXCEPTION_BREAKPOINT', 'RPC_NT_ENTRY_NOT_FOUND', 'STATUS_PASSWORD_EXPIRED', 'STATUS_DATA_OVERRUN', 'STATUS_INVALID_EA_FLAG', 'PIPE_CLIENT_END', 'STATUS_INVALID_TASK_INDEX', 'STATUS_CONNECTION_ABORTED', 'STATUS_WMI_READ_ONLY', 'CERT_MD5_HASH_PROP_ID', 'CMSG_DATA', 'STATUS_LOG_PINNED_RESERVATION', 'STATUS_LICENSE_VIOLATION', 'szOID_X957_SHA1DSA', 'ERROR_INVALID_AT_INTERRUPT_TIME', 'STATUS_PKINIT_NAME_MISMATCH', 'TRUST_E_EXPLICIT_DISTRUST', 'STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED', 'STATUS_NO_TRUST_LSA_SECRET', 'FILE_FLAG_POSIX_SEMANTICS', 'STATUS_PORT_DISCONNECTED', 'SERVICE_CONTROL_DEVICEEVENT', 'ERROR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED', 'STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP', 'PROCESS_SET_LIMITED_INFORMATION', 'STATUS_INVALID_VOLUME_LABEL', 'RPC_RESPONSE_TYPE_BIND_OK', 'STATUS_REQUEST_OUT_OF_SEQUENCE', 'STATUS_CLUSTER_NODE_ALREADY_MEMBER', 'FAX_PORT_QUERY', 'szOID_PKCS_8', 'szOID_PKCS_9', 'CERT_SYSTEM_STORE_LOCAL_MACHINE', 'szOID_PKCS_4', 'szOID_PKCS_5', 'szOID_PKCS_6', 'szOID_PKCS_7', 'NTE_INTERNAL_ERROR', 'szOID_PKCS_1', 'szOID_PKCS_2', 'szOID_PKCS_3', 'FILE_ATTRIBUTE_REPARSE_POINT', 'STATUS_PNP_IRQ_TRANSLATION_FAILED', 'ACCESS_MAX_MS_V4_ACE_TYPE', 'CERT_SYSTEM_STORE_LOCATION_SHIFT', 'SM_CXDLGFRAME', 'DEBUG_PROCESS', 'STATUS_FVE_BAD_METADATA_POINTER', 'ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE', 'szOID_RSA_envelopedData', 'STATUS_WX86_EXCEPTION_CHAIN', 'DEBUG_EVENT_CHANGE_DEBUGGEE_STATE', 'STATUS_DUPLICATE_OBJECTID', 'ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE', 'STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY', 'STATUS_VERIFIER_STOP', 'ERROR_NETNAME_DELETED', 'PORT_ALL_ACCESS', 'szOID_OIWDIR_HASH', 'STATUS_CONNECTION_REFUSED', 'STATUS_FILE_IDENTITY_NOT_PERSISTENT', 'STATUS_BAD_DESCRIPTOR_FORMAT', 'STATUS_FVE_TPM_NO_VMK', 'STATUS_APP_INIT_FAILURE', 'STATUS_NOT_A_REPARSE_POINT', 'STATUS_MP_PROCESSOR_MISMATCH', 'STATUS_NDIS_DOT11_MEDIA_IN_USE', 'CERT_NAME_EMAIL_TYPE', 'SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE', 'STATUS_PROCESS_IS_PROTECTED', 'szOID_RSA_SMIMECapabilities', 'RPC_NT_OUT_OF_RESOURCES', 'STATUS_GRAPHICS_INVALID_TOTAL_REGION', 'CERT_QUERY_CONTENT_FLAG_CERT_PAIR', 'ERROR_WAIT_63', 'STATUS_EVENTLOG_FILE_CORRUPT', 'ERROR_TIMER_RESUME_IGNORED', 'TXFS_MINIVERSION_DEFAULT_VIEW', 'STATUS_NDIS_ERROR_READING_FILE', 'STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER', 'IMAGE_SCN_MEM_WRITE', 'CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED', 'STATUS_FILE_LOCKED_WITH_WRITERS', 'SE_CREATE_PAGEFILE_NAME', 'STATUS_CONTENT_BLOCKED', 'STATUS_NOT_MAPPED_VIEW', 'STATUS_INVALID_HW_PROFILE', 'ERROR_INSUFFICIENT_LOGON_INFO', 'STATUS_FAILED_DRIVER_ENTRY', 'MS_DEF_PROV_A', 'STATUS_LOG_HARD_ERROR', 'ERROR_TRANSLATION_COMPLETE', 'IMAGE_FILE_MACHINE_EBC', 'STATUS_FVE_OLD_METADATA_COPY', 'FILE_CREATE_PIPE_INSTANCE', 'szOID_OIWSEC_desCFB', 'IMAGE_SCN_MEM_DISCARDABLE', 'MS_DEF_PROV_W', 'STATUS_DLL_MIGHT_BE_INCOMPATIBLE', 'FILE_SUPPORTS_TRANSACTIONS', 'STATUS_CTX_NOT_CONSOLE', 'MEM_4MB_PAGES', 'STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS', 'STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS', 'STATUS_HANDLES_CLOSED', 'STATUS_INCOMPATIBLE_FILE_MAP', 'STATUS_NO_RANGES_PROCESSED', 'NTE_PROV_TYPE_NO_MATCH', 'PKCS_7_NDR_ENCODING', 'STATUS_SMARTCARD_IO_ERROR', 'ERROR_IO_PENDING', 'CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY', 'API_SET_SCHEMA_ENTRY_FLAGS_SEALED', 'STATUS_NDIS_OFFLOAD_POLICY', 'STATUS_GRAPHICS_PVP_HFS_FAILED', 'ERROR_DBG_EXCEPTION_HANDLED', 'ERROR_SIGNAL_PENDING', 'RPC_NT_INVALID_PIPE_OPERATION', 'STATUS_FWP_DUPLICATE_KEYMOD', 'STATUS_REMOTE_STORAGE_MEDIA_ERROR', 'STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES', 'STATUS_LAST_ADMIN', 'X509_CERT_CRL_TO_BE_SIGNED', 'STATUS_SYSTEM_DEVICE_NOT_FOUND', 'EXCEPTION_INVALID_DISPOSITION', 'NTE_BUFFER_TOO_SMALL', 'STATUS_CALLBACK_RETURNED_THREAD_AFFINITY', 'IO_COMPLETION_MODIFY_STATE', 'CMSG_ENCRYPTED_DIGEST', 'CERT_FIND_SUBJECT_INFO_ACCESS', 'PRODUCT_MEDIUMBUSINESS_SERVER_SECURITY', 'STATUS_FLT_DO_NOT_DETACH', 'STATUS_CLUSTER_NO_SECURITY_CONTEXT', 'NTE_BAD_DATA', 'LPC_CLIENT_DIED', 'AT_KEYEXCHANGE', 'STATUS_NO_MEDIA_IN_DEVICE', 'OS_WIN2000DATACENTER', 'PRODUCT_ESSENTIALBUSINESS_SERVER_MGMTSVC', 'CERT_IE30_RESERVED_PROP_ID', 'STATUS_TRANSACTION_NO_RELEASE', 'STATUS_ACPI_INVALID_ARGUMENT', 'CMSG_MAX_LENGTH_FLAG', 'CMSG_CTRL_ENABLE_STRONG_SIGNATURE', 'ERROR_RELOC_CHAIN_XEEDS_SEGLIM', 'STATUS_DEVICE_ALREADY_ATTACHED', 'STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED', 'STATUS_DATATYPE_MISALIGNMENT_ERROR', 'STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND', 'THREAD_SUSPEND_RESUME', 'LPC_ERROR_EVENT', 'TH32CS_INHERIT', 'STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET', 'COM_EXECUTE_REMOTE', 'IMAGE_SCN_LNK_NRELOC_OVFL', 'STATUS_INVALID_FILE_FOR_SECTION', 'TOKEN_SECURITY_ATTRIBUTE_MANDATORY', 'SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE', 'NTE_KEYSET_ENTRY_BAD', 'szOID_RSA_DH', 'ERROR_ACPI_ERROR', 'STATUS_INVALID_MESSAGE', 'STATUS_CTX_SHADOW_INVALID', 'szOID_RSA_HASH', 'STATUS_OBJECT_NAME_EXISTS', 'FC_DONT_FREE', 'IMAGE_SCN_MEM_SHARED', 'EXCEPTION_FLT_INEXACT_RESULT', 'ERROR_TRANSACTION_NOT_REQUESTED', 'STATUS_LOG_BLOCK_INCOMPLETE', 'FILE_SHARE_READ', 'PRODUCT_CORE_COUNTRYSPECIFIC', 'ACCESS_DENIED_OBJECT_ACE_TYPE', 'RPC_NT_SS_CANNOT_GET_CALL_HANDLE', 'INHERIT_PARENT_AFFINITY', 'STATUS_LOG_POLICY_INVALID', 'PRODUCT_ENTERPRISE_SERVER', 'OS_DOMAINMEMBER', 'OBJ_KERNEL_HANDLE', 'CMSG_INDEFINITE_LENGTH', 'ERROR_VOLSNAP_HIBERNATE_READY', 'ALPC_MSGFLG_SYNC_REQUEST', 'SE_PRIVILEGE_ENABLED_BY_DEFAULT', 'CERT_OID_NAME_STR', 'STATUS_CALLBACK_RETURNED_LDR_LOCK', 'ERROR_FAIL_NOACTION_REBOOT', 'STATUS_EXPIRED_HANDLE', 'STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET', 'EVT_VARIANT_TYPE_ARRAY', 'STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED', 'BIND_IF_SYNTAX_NDR64', 'CERT_FORTEZZA_DATA_PROP_ID', 'szOID_RSA_counterSign', 'STATUS_CTX_INVALID_MODEMNAME', 'CERT_STORE_ENUM_ARCHIVED_FLAG', 'STATUS_DS_CROSS_DOM_MOVE_FAILED', 'STATUS_FWP_INVALID_ACTION_TYPE', 'X509_CERT', 'STATUS_STREAM_MINIVERSION_NOT_FOUND', 'ERROR_CACHE_PAGE_LOCKED', 'STATUS_THREAD_NOT_IN_PROCESS', 'CERT_KEY_CONTEXT_PROP_ID', 'STATUS_TOO_LATE', 'STATUS_NDIS_MULTICAST_NOT_FOUND', 'ANY_SIZE', 'NTE_SILENT_CONTEXT', 'ERROR_WRITE_PROTECT', 'CERT_NAME_RDN_TYPE', 'szOID_INFOSEC_SuiteAConfidentiality', 'STATUS_INVALID_LOGON_HOURS', 'ERROR_LOST_WRITEBEHIND_DATA', 'STATUS_REQUEST_ABORTED', 'CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID', 'SM_CYKANJIWINDOW', 'STATUS_UNWIND_CONSOLIDATE', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_FQBN', 'ERROR_SYSTEM_POWERSTATE_TRANSITION', 'SM_CYMIN', 'ERROR_WOW_ASSERTION', 'SEC_WRITECOMBINE', 'STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP', 'DIRECTORY_TRAVERSE', 'STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED', 'SM_CYVIRTUALSCREEN', 'CERT_TRUST_HAS_PREFERRED_ISSUER', 'AF_IPX', 'FILE_EXISTS', 'OS_WELCOMELOGONUI', 'X509_KEY_USAGE_RESTRICTION', 'SE_SACL_PROTECTED', 'SM_CYMAXTRACK', 'STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET', 'STATUS_INVALID_LOCK_SEQUENCE', 'WTD_STATEACTION_IGNORE', 'STATUS_GRAPHICS_TRY_AGAIN_NOW', 'CERT_TRUST_IS_EXPLICIT_DISTRUST', 'STATUS_IO_REPARSE_TAG_MISMATCH', 'CERT_INFO_NOT_BEFORE_FLAG', 'API_SET_SCHEMA_FLAGS_SEALED', 'STATUS_WX86_SINGLE_STEP', 'DIGSIG_E_DECODE', 'ERROR_TOO_MANY_CMDS', 'STATUS_BAD_TOKEN_TYPE', 'OBJ_CASE_INSENSITIVE', 'STATUS_DS_INIT_FAILURE_CONSOLE', 'STATUS_REDIRECTOR_STARTED', 'STG_TOEND', 'THREAD_GET_CONTEXT', 'CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID', 'STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG', 'STATUS_DEBUG_ATTACH_FAILED', 'REG_RESOURCE_REQUIREMENTS_LIST', 'STATUS_VALIDATE_CONTINUE', 'AF_INET', 'STATUS_NO_GUID_TRANSLATION', 'STATUS_FVE_REBOOT_REQUIRED', 'AF_NETDES', 'ERROR_FAIL_RESTART', 'STATUS_ISSUING_CA_UNTRUSTED', 'ERROR_EA_TABLE_FULL', 'STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY', 'CERT_SYSTEM_STORE_SERVICES', 'STATUS_FVE_FS_NOT_EXTENDED', 'STATUS_IPSEC_CLEAR_TEXT_DROP', 'STATUS_PRIVILEGED_INSTRUCTION', 'STATUS_INVALID_BLOCK_LENGTH', 'STATUS_INVALID_PAGE_PROTECTION', 'STATUS_FVE_TPM_DISABLED', 'STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED', 'MEM_RESET', 'DIGSIG_E_EXTENSIBILITY', 'EXCEPTION_FLT_INVALID_OPERATION', 'API_SET_LOOKUP_ORDINAL', 'FILE_FLAG_OPEN_REPARSE_POINT', 'STATUS_LOGON_SESSION_EXISTS', 'STATUS_BAD_WORKING_SET_LIMIT', 'RPC_NT_PIPE_CLOSED', 'SEC_COMMIT', 'STATUS_INVALID_PORT_HANDLE', 'RPC_S_UNSUPPORTED_TRANS_SYN', 'STATUS_END_OF_FILE', 'ERROR_DUP_NAME', 'ERROR_TIMER_NOT_CANCELED', 'RPC_NT_NO_BINDINGS', 'STATUS_LOG_NO_RESTART', 'FILE_ATTRIBUTE_ARCHIVE', 'ERROR_INVALID_UNWIND_TARGET', 'IMAGE_SCN_ALIGN_512BYTES', 'FAX_CONFIG_SET', 'NMPWAIT_WAIT_FOREVER', 'CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID', 'STATUS_IMPLEMENTATION_LIMIT', 'ERROR_NOT_TINY_STREAM', 'ERROR_SECTOR_NOT_FOUND', 'STATUS_PIPE_CONNECTED', 'ERROR_INVALID_ACCESS', 'RPC_C_AUTHN_LEVEL_DEFAULT', 'STATUS_UNHANDLED_EXCEPTION', 'STATUS_LOCAL_USER_SESSION_KEY', 'HKEY_USERS', 'STATUS_SECTION_NOT_EXTENDED', 'NTE_UI_REQUIRED', 'szOID_RSA_MD2', 'STATUS_IPSEC_BAD_SPI', 'szOID_RSA_MD5', 'szOID_RSA_MD4', 'OS_WEBSERVER', 'DEBUG_EVENT_EXIT_THREAD', 'SM_CYDOUBLECLK', 'STGFMT_FILE', 'STATUS_NOT_SUPPORTED', 'STATUS_RECEIVE_PARTIAL', 'STATUS_ENLISTMENT_NOT_SUPERIOR', 'STATUS_MONITOR_NO_DESCRIPTOR', 'szOID_RSA_SMIMEalgCMS3DESwrap', 'CMSG_ENCRYPTED', 'CERT_COMPARE_SHA1_HASH', 'FILE_VALID_PIPE_OPTION_FLAGS', 'WTD_UI_NOBAD', 'CERT_FIND_ISSUER_STR_A', 'szOID_NIST_AES256_CBC', 'ERROR_BUSY', 'szOID_INFOSEC_SuiteASignature', 'SM_CYVSCROLL', 'ERROR_USER_PROFILE_LOAD', 'STATUS_TOO_MANY_SESSIONS', 'CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED', 'STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES', 'STATUS_LOG_FILE_FULL', 'STD_INPUT_HANDLE', 'ERROR_SYSTEM_PROCESS_TERMINATED', 'ERROR_INVALID_IMAGE_HASH', 'ERROR_DOMAIN_CTRLR_CONFIG_ERROR', 'CMSG_ENCODED_MESSAGE', 'ERROR_NET_WRITE_FAULT', 'EXCEPTION_FLT_DENORMAL_OPERAND', 'STATUS_BAD_SERVICE_ENTRYPOINT', 'STATUS_PARAMETER_QUOTA_EXCEEDED', 'IMAGE_FILE_MACHINE_ARM', 'CREATE_DEFAULT_ERROR_MODE', 'IMAGE_SCN_ALIGN_4096BYTES', 'STATUS_TRANSACTION_NO_MATCH', 'CERT_SOURCE_LOCATION_PROP_ID', 'ERROR_SYNCHRONIZATION_REQUIRED', 'STATUS_PRIVILEGE_NOT_HELD', 'STATUS_FWP_INJECT_HANDLE_STALE', 'PRODUCT_ULTIMATE', 'ERROR_DISK_CHANGE', 'SERVICE_START_PENDING', 'STATUS_RESOURCE_DATA_NOT_FOUND', 'SERVICE_START', 'IMAGE_SCN_ALIGN_128BYTES', 'STATUS_CONVERT_TO_LARGE', 'STATUS_EVALUATION_EXPIRATION', 'SW_SHOWMAXIMIZED', 'STATUS_PAGEFILE_QUOTA', 'STATUS_WX86_CREATEWX86TIB', 'ERROR_PREDEFINED_HANDLE', 'STATUS_GRAPHICS_OPM_INVALID_POINTER', 'ERROR_BADSTARTPOSITION', 'CERT_INFO_SERIAL_NUMBER_FLAG', 'STATUS_FWP_IN_USE', 'CERT_FIND_PUBLIC_KEY', 'RPC_NT_INCOMPLETE_NAME', 'STATUS_NONEXISTENT_EA_ENTRY', 'CERT_COMPARE_SHIFT', 'STATUS_FVE_PARTIAL_METADATA', 'PRODUCT_ENTERPRISE_SERVER_IA64', 'STATUS_WRONG_VOLUME', 'PROV_RSA_AES', 'STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH', 'PROV_RSA_FULL', 'STATUS_DEVICE_CONFIGURATION_ERROR', 'STATUS_INVALID_LABEL', 'STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH', 'CERT_COMPARE_MASK', 'ERROR_WAIT_3', 'ERROR_WAIT_2', 'ERROR_WAIT_1', 'ALPC_MESSAGE_TOKEN_ATTRIBUTE', 'szOID_NIST_sha256', 'COMPRESSION_ENGINE_MAXIMUM', 'STATUS_CTX_MODEM_RESPONSE_TIMEOUT', 'CERT_QUERY_OBJECT_BLOB', 'STATUS_NOT_A_DIRECTORY', 'STATUS_FLOAT_INVALID_OPERATION', 'IMAGE_DLLCHARACTERISTICS_NX_COMPAT', 'ERROR_DRIVER_CANCEL_TIMEOUT', 'ERROR_INVALID_TRANSACTION', 'ALPC_VIEWFLG_NOT_SECURE', 'STATUS_MFT_TOO_FRAGMENTED', 'PRODUCT_SB_SOLUTION_SERVER', 'STATUS_INVALID_PARAMETER_8', 'FILE_ACTION_RENAMED_NEW_NAME', 'STATUS_NDIS_ADAPTER_NOT_READY', 'STATUS_DISK_QUOTA_EXCEEDED', 'STATUS_PAGE_FAULT_COPY_ON_WRITE', 'DIRECTORY_QUERY', 'STATUS_FWP_CALLOUT_NOTIFICATION_FAILED', 'COM_ACTIVATE_LOCAL', 'ERROR_DBG_PRINTEXCEPTION_C', 'STATUS_TOO_MANY_CONTEXT_IDS', 'STATUS_BUFFER_ALL_ZEROS', 'AF_IRDA', 'CERT_ARCHIVED_PROP_ID', 'DIRECTORY_ALL_ACCESS', 'GROUP_SECURITY_INFORMATION', 'RPC_C_AUTHN_LEVEL_PKT', 'PIPE_WAIT', 'STATUS_INVALID_READ_MODE', 'PRODUCT_ENTERPRISE_SERVER_V', 'MAXIMUM_ALLOWED', 'SERVICE_TRIGGER_TYPE_CUSTOM_SYSTEM_STATE_CHANGE', 'ERROR_REDIR_PAUSED', 'FILE_VOLUME_IS_COMPRESSED', 'COMPRESSION_FORMAT_NONE', 'HIGH_PRIORITY_CLASS', 'STATUS_DOMAIN_LIMIT_EXCEEDED', 'PRODUCT_HOME_PREMIUM', 'STATUS_FLOAT_MULTIPLE_FAULTS', 'STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM', 'STATUS_PARTITION_FAILURE', 'STATUS_FLT_FILTER_NOT_READY', 'NORMAL_PRIORITY_CLASS', 'ERROR_FAIL_SHUTDOWN', 'STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET', 'STATUS_DRIVER_UNABLE_TO_LOAD', 'ASYNC_MODE_COMPATIBILITY', 'X509_CERT_TO_BE_SIGNED', 'szOID_RSA_RC4', 'STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO', 'szOID_DSALG_SIGN', 'FC_POINTER_DEREF', 'STATUS_FILE_IS_A_DIRECTORY', 'STATUS_CRASH_DUMP', 'STATUS_ACPI_INVALID_ARGTYPE', 'NTE_EXISTS', 'STATUS_FLT_IO_COMPLETE', 'ERROR_REPARSE', 'SERVICE_PAUSED', 'CERT_E_INVALID_POLICY', 'CMSG_RECIPIENT_COUNT_PARAM', 'szOID_RSA_challengePwd', 'SERVICE_ACCEPT_SESSIONCHANGE', 'STATUS_HIBERNATION_FAILURE', 'CMSG_ENCODING_TYPE_MASK', 'IMAGE_SCN_ALIGN_64BYTES', 'ERROR_EA_LIST_INCONSISTENT', 'STATUS_RXACT_COMMIT_FAILURE', 'STATUS_RANGE_LIST_CONFLICT', 'ERROR_CANT_ENABLE_DENY_ONLY', 'SE_DACL_DEFAULTED', 'STATUS_JOURNAL_ENTRY_DELETED', 'SE_OWNER_DEFAULTED', 'ERROR_EVALUATION_EXPIRATION', 'STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED', 'szOID_RSA_ENCRYPT', 'CERT_COMPARE_PUBKEY_MD5_HASH', 'STATUS_CLUSTER_INVALID_REQUEST', 'PRODUCT_ESSENTIALBUSINESS_SERVER_ADDL', 'PRODUCT_DATACENTER_SERVER', 'STATUS_TM_IDENTITY_MISMATCH', 'STARTF_USESHOWWINDOW', 'ERROR_GUID_SUBSTITUTION_MADE', 'DEBUG_EVENT_CREATE_PROCESS', 'STATUS_LOG_METADATA_CORRUPT', 'STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED', 'IMAGE_SCN_ALIGN_1BYTES', 'STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME', 'SC_MANAGER_ENUMERATE_SERVICE', 'ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE', 'STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED', 'STATUS_CLUSTER_INVALID_NETWORK_PROVIDER', 'NTE_PROV_TYPE_ENTRY_BAD', 'EXCEPTION_CONTINUE_SEARCH', 'EVENTLOG_SEEK_READ', 'REG_FULL_RESOURCE_DESCRIPTOR', 'MEM_MAPPED', 'STATUS_FWP_DUPLICATE_CONDITION', 'STATUS_FVE_KEYFILE_NOT_FOUND', 'STATUS_DRIVER_BLOCKED_CRITICAL', 'JOB_OBJECT_TERMINATE', 'STATUS_CANNOT_ACCEPT_TRANSACTED_WORK', 'STATUS_IO_TIMEOUT', 'CERT_FIND_EXISTING', 'STATUS_NO_LOG_SPACE', 'KEY_ALL_ACCESS', 'ERROR_INVALID_LEVEL', 'ERROR_THREAD_WAS_SUSPENDED', 'CERT_COMPARE_HASH', 'RRF_RT_REG_DWORD', 'STATUS_FWP_TIMEOUT', 'SYSTEM_PROCESS_TRUST_LABEL_ACE_TYPE', 'ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND', 'STATUS_NDIS_MULTICAST_EXISTS', 'STATUS_LOG_POLICY_NOT_INSTALLED', 'RPC_C_IMP_LEVEL_IMPERSONATE', 'ERROR_FAILED_DRIVER_ENTRY', 'CRYPT_VERIFYCONTEXT', 'NTE_BAD_PUBLIC_KEY', 'STATUS_LINK_TIMEOUT', 'IMAGE_REL_BASED_LOW', 'STATUS_MESSAGE_LOST', 'CERT_INFO_NOT_AFTER_FLAG', 'SERVICE_STATE_ALL', 'STATUS_INVALID_ID_AUTHORITY', 'SERVICE_ACCEPT_PAUSE_CONTINUE', 'STATUS_GRAPHICS_START_DEFERRED', 'STATUS_INVALID_IMAGE_NOT_MZ', 'ERROR_ATOMIC_LOCKS_NOT_SUPPORTED', 'STATUS_FLOPPY_ID_MARK_NOT_FOUND', 'STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER', 'STATUS_HASH_NOT_SUPPORTED', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID', 'IMAGE_SCN_ALIGN_256BYTES', 'STATUS_LICENSE_QUOTA_EXCEEDED', 'STATUS_UNABLE_TO_DECOMMIT_VM', 'STATUS_MEDIA_CHANGED', 'STATUS_COULD_NOT_RESIZE_LOG', 'SERVICE_TRIGGER_DATA_TYPE_LEVEL', 'STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE', 'FILE_NAMED_STREAMS', 'STATUS_VOLSNAP_PREPARE_HIBERNATE', 'STATUS_FVE_OVERLAPPED_UPDATE', 'SYSTEM_AUDIT_ACE_TYPE', 'STATUS_VHD_PARENT_VHD_ACCESS_DENIED', 'RPC_C_QOS_CAPABILITIES_DEFAULT', 'SE_BACKUP_NAME', 'IMAGE_FILE_BYTES_REVERSED_HI', 'STATUS_CTX_INVALID_PD', 'STATUS_RESUME_HIBERNATION', 'STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET', 'FILE_SUPPORTS_SPARSE_FILES', 'ERROR_MEDIA_CHECK', 'PKCS_ATTRIBUTE', 'STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY', 'ERROR_EVT_FILTER_UNEXPECTEDTOKEN', 'STATUS_LPC_REQUESTS_NOT_ALLOWED', 'IMAGE_DIRECTORY_ENTRY_BASERELOC', 'STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE', 'SM_CXEDGE', 'STATUS_NO_DATA_DETECTED', 'CRYPT_ACQUIRE_SILENT_FLAG', 'CERT_COMPARE_ISSUER_OF', 'SEMAPHORE_MODIFY_STATE', 'STATUS_REMOTE_SESSION_LIMIT', 'STATUS_LOG_FULL_HANDLER_IN_PROGRESS', 'CRYPT_ACQUIRE_NO_HEALING', 'SE_AUDIT_NAME', 'STATUS_SERVER_UNAVAILABLE', 'ERROR_EVT_INVALID_QUERY', 'STATUS_NTLM_BLOCKED', 'STATUS_FLT_INVALID_CONTEXT_REGISTRATION', 'STATUS_THREAD_WAS_SUSPENDED', 'GENERIC_ALL', 'CERT_STORE_CERTIFICATE_CONTEXT', 'szOID_RSA_hashedData', 'STATUS_PNP_TRANSLATION_FAILED', 'RPC_NT_ENUM_VALUE_OUT_OF_RANGE', 'CERT_E_MALFORMED', 'WTD_UI_ALL', 'STATUS_IO_REISSUE_AS_CACHED', 'RPC_NT_INVALID_OBJECT', 'STATUS_DUPLICATE_NAME', 'CERT_STORE_PROV_SYSTEM_REGISTRY_W', 'CERT_SYSTEM_STORE_CURRENT_SERVICE', 'ERROR_STOPPED_ON_SYMLINK', 'RPC_NT_ENTRY_ALREADY_EXISTS', 'AF_PUP', 'CERT_STORE_PROV_SYSTEM_REGISTRY_A', 'STATUS_PROCESS_NOT_IN_JOB', 'ERROR_DLL_INIT_FAILED_LOGOFF', 'STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED', 'IMAGE_FILE_MACHINE_ARMNT', 'MEM_PRIVATE', 'STATUS_NO_MATCH', 'szOID_RSA_extCertAttrs', 'PRODUCT_STANDARD_SERVER_CORE', 'szOID_ECC_CURVE_P521', 'SE_PRIVILEGE_REMOVED', 'STATUS_PROFILING_NOT_STOPPED', 'TRUST_E_FAIL', 'STATUS_NOLOGON_SERVER_TRUST_ACCOUNT', 'STATUS_IPSEC_WRONG_SA', 'PRODUCT_MULTIPOINT_PREMIUM_SERVER', 'STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS', 'STATUS_LOG_ARCHIVE_IN_PROGRESS', 'STATUS_NOT_MAPPED_DATA', 'WTD_CHOICE_FILE', 'IMAGE_DIRECTORY_ENTRY_TLS', 'STATUS_PATH_NOT_COVERED', 'CMSG_SIGNER_COUNT_PARAM', 'ERROR_TOO_MANY_SESS', 'OS_XPORGREATER', 'CERT_INFO_EXTENSION_FLAG', 'szOID_RSA_SHA384RSA', 'STATUS_WORKING_SET_QUOTA', 'ALPC_PORFLG_ALLOW_LPC_REQUESTS', 'STATUS_NOTHING_TO_TERMINATE', 'STG_LAYOUT_SEQUENTIAL', 'STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG', 'STATUS_INVALID_LOCK_RANGE', 'SERVICE_ACCEPT_HARDWAREPROFILECHANGE', 'NTE_BAD_KEYSET', 'ERROR_EVT_FILTER_INVTYPE', 'CERT_STORE_ADD_REPLACE_EXISTING', 'CMSG_COMPUTED_HASH_PARAM', 'ERROR_TRANSACTION_REQUEST_NOT_VALID', 'AF_UNSPEC', 'CMSG_SIGNER_UNAUTH_ATTR_PARAM', 'ATTRIBUTE_SECURITY_INFORMATION', 'ALPC_HANDLEFLG_DUPLICATE_SAME_ACCESS', 'ERROR_NOT_SAME_DEVICE', 'ERROR_EVT_PUBLISHER_DISABLED', 'ERROR_REQ_NOT_ACCEP', 'STATUS_ALREADY_COMMITTED', 'USAGE_MATCH_TYPE_AND', 'SE_ENABLE_DELEGATION_NAME', 'STATUS_NOT_REGISTRY_FILE', 'DRIVE_FIXED', 'SECTION_QUERY', 'SERVICE_TRIGGER_DATA_TYPE_BINARY', 'ERROR_BUFFER_ALL_ZEROS', 'STATUS_NDIS_INVALID_PACKET', 'ERROR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE', 'STARTF_USESTDHANDLES', 'PROV_SPYRUS_LYNKS', 'STATUS_CLUSTER_NO_NET_ADAPTERS', 'STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET', 'AF_DECnet', 'STATUS_IO_PRIVILEGE_FAILED', 'PROCESS_CREATE_PROCESS', 'RPC_NT_OBJECT_NOT_FOUND', 'CERT_DATE_STAMP_PROP_ID', 'ERROR_EVT_FILTER_PARSEERR', 'szOID_RSA_unstructName', 'ACCESS_MIN_MS_ACE_TYPE', 'STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED', 'STATUS_UNSUCCESSFUL', 'ERROR_NOT_READY', 'STATUS_ILLEGAL_FUNCTION', 'STATUS_FVE_CONV_WRITE_ERROR', 'SM_MENUDROPALIGNMENT', 'CRYPT_E_INVALID_MSG_TYPE', 'STATUS_IPSEC_DOSP_MAX_ENTRIES', 'RRF_RT_REG_SZ', 'STATUS_FLT_INTERNAL_ERROR', 'STATUS_OBJECT_NAME_COLLISION', 'STATUS_DS_RIDMGR_INIT_ERROR', 'ERROR_BAD_FUNCTION_TABLE', 'SEC_IMAGE', 'STATUS_FT_READ_RECOVERY_FROM_BACKUP', 'STATUS_SERIAL_MORE_WRITES', 'SEC_PROTECTED_IMAGE', 'SERVICE_RUNS_IN_SYSTEM_PROCESS', 'STATUS_SYSTEM_SHUTDOWN', 'STATUS_LOGON_SESSION_COLLISION', 'CMSG_LENGTH_ONLY_FLAG', 'ACCESS_MAX_MS_V2_ACE_TYPE', 'ERROR_INVALID_HW_PROFILE', 'IMAGE_FILE_MACHINE_M32R', 'PRODUCT_WEB_SERVER', 'STATUS_SYSTEM_HIVE_TOO_LARGE', 'STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED', 'IMAGE_SCN_MEM_NOT_PAGED', 'STATUS_INVALID_CONNECTION', 'SM_CXMENUCHECK', 'CALLBACK_MODIFY_STATE', 'SE_GROUP_INTEGRITY', 'ERROR_BAD_SERVICE_ENTRYPOINT', 'STATUS_KEY_HAS_CHILDREN', 'ERROR_OPLOCK_SWITCHED_TO_NEW_HANDLE', 'ERROR_DBG_UNABLE_TO_PROVIDE_HANDLE', 'CERT_COMPARE_SUBJECT_INFO_ACCESS', 'IMAGE_SCN_ALIGN_16BYTES', 'CERT_COMPARE_NAME_STR_A', 'STATUS_INVALID_LEVEL', 'ERROR_INVALID_EXE_SIGNATURE', 'STATUS_IP_ADDRESS_CONFLICT1', 'ERROR_TOO_MANY_OPEN_FILES', 'IMAGE_SIZEOF_SHORT_NAME', 'STATUS_SXS_MANIFEST_PARSE_ERROR', 'ERROR_BROKEN_PIPE', 'CREATE_IGNORE_SYSTEM_DEFAULT', 'CERT_TRUST_INVALID_POLICY_CONSTRAINTS', 'STATUS_GRACEFUL_DISCONNECT', 'EVENTLOG_AUDIT_SUCCESS', 'CERT_COMPARE_NAME_STR_W', 'FILE_ACTION_MODIFIED', 'ERROR_NETWORK_BUSY', 'STATUS_BAD_MASTER_BOOT_RECORD', 'IMAGE_DLLCHARACTERISTICS_APPCONTAINER', 'STATUS_NO_SUCH_PRIVILEGE', 'ERROR_SEM_USER_LIMIT', 'STATUS_BAD_INHERITANCE_ACL', 'szOID_INFOSEC_mosaicKMandSig', 'STATUS_SMARTCARD_NO_CARD', 'ERROR_SYSTEM_POWERSTATE_COMPLEX_TRANSITION', 'FILE_FLAG_OPEN_NO_RECALL', 'SM_MOUSEHORIZONTALWHEELPRESENT', 'ERROR_ADAP_HDW_ERR', 'ERROR_PIPE_LOCAL', 'X509_NAME_VALUE', 'ERROR_FILE_SYSTEM_LIMITATION', 'STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED', 'CERT_STORE_PROV_MEMORY', 'STATUS_INVALID_USER_BUFFER', 'TOKEN_MANDATORY_POLICY_OFF', 'STATUS_NONCONTINUABLE_EXCEPTION', 'STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY', 'STATUS_MAPPED_ALIGNMENT', 'STATUS_DEVICE_OFF_LINE', 'STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE', 'STATUS_RECOVERY_FAILURE', 'IMAGE_SCN_TYPE_NOLOAD', 'ALPC_PORFLG_SYSTEM_PROCESS', 'szOID_OIWSEC_keyHashSeal', 'STATUS_FWP_INCOMPATIBLE_TXN', 'ERROR_PAGE_FAULT_COPY_ON_WRITE', 'STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY', 'STATUS_SOURCE_ELEMENT_EMPTY', 'ERROR_EXE_MACHINE_TYPE_MISMATCH', 'LABEL_SECURITY_INFORMATION', 'STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION', 'STATUS_REPARSE_OBJECT', 'RPC_C_IMP_LEVEL_ANONYMOUS', 'STATUS_CTX_SHADOW_DENIED', 'ERROR_INVALID_DRIVE', 'STATUS_ILL_FORMED_SERVICE_ENTRY', 'STATUS_ADDRESS_ALREADY_EXISTS', 'STATUS_FWP_INVALID_ENUMERATOR', 'SE_GROUP_MANDATORY', 'RPC_NT_NO_MORE_BINDINGS', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN', 'CERT_KEY_PROV_HANDLE_PROP_ID', 'STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN', 'IMAGE_SCN_MEM_FARDATA', 'TOKEN_ALL_ACCESS_P', 'STATUS_INVALID_GROUP_ATTRIBUTES', 'STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST', 'STATUS_SECTION_PROTECTION', 'GENERIC_READ', 'STATUS_WMI_TRY_AGAIN', 'szOID_RSA_RC5_CBCPad', 'IO_COMPLETION_ALL_ACCESS', 'STATUS_CTX_CLIENT_LICENSE_IN_USE', 'STATUS_WAIT_63', 'OS_WIN2000PRO', 'STATUS_MUI_FILE_NOT_FOUND', 'CMSG_CMS_SIGNER_INFO_PARAM', 'ERROR_EVT_CONFIGURATION_ERROR', 'SM_DIGITIZER', 'RPC_NT_INTERFACE_NOT_FOUND', 'CMSG_TYPE_PARAM', 'SE_INC_BASE_PRIORITY_NAME', 'MS_STRONG_PROV', 'JOB_OBJECT_ALL_ACCESS', 'SEC_NOCACHE', 'STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN', 'STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER', 'ERROR_IP_ADDRESS_CONFLICT2', 'ERROR_IP_ADDRESS_CONFLICT1', 'STATUS_ASSERTION_FAILURE', 'REG_QWORD', 'RPC_NT_INVALID_NETWORK_OPTIONS', 'ERROR_USER_APC', 'SM_CXMIN', 'CMSG_VERSION_PARAM', 'ERROR_CANNOT_MAKE', 'EVENTLOG_INFORMATION_TYPE', 'STATUS_SXS_ASSEMBLY_MISSING', 'STATUS_NO_MORE_ENTRIES', 'STATUS_FWP_PROVIDER_NOT_FOUND', 'STATUS_SXS_IDENTITIES_DIFFERENT', 'RPC_NT_INVALID_ASYNC_HANDLE', 'FILE_OPEN_IF', 'STATUS_ORDINAL_NOT_FOUND', 'ERROR_UNEXPECTED_MM_MAP_ERROR', 'STATUS_PORT_UNREACHABLE', 'IMAGE_SCN_CNT_INITIALIZED_DATA', 'STATUS_VOLUME_MOUNTED', 'STATUS_JOURNAL_DELETE_IN_PROGRESS', 'PRODUCT_ENTERPRISE', 'STATUS_GRAPHICS_INVALID_CLIENT_TYPE', 'STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE', 'STATUS_INVALID_DOMAIN_STATE', 'STATUS_INSUFFICIENT_RESOURCES', 'IMAGE_DLLCHARACTERISTICS_NO_ISOLATION', 'STATUS_PORT_ALREADY_SET', 'STATUS_SXS_CORRUPTION', 'STATUS_DATA_NOT_ACCEPTED', 'X509_EXTENSIONS', 'RPC_C_AUTHN_LEVEL_NONE', 'STATUS_SERIAL_COUNTER_TIMEOUT', 'STATUS_ABANDONED', 'STATUS_UNDEFINED_CHARACTER', 'ERROR_ASSERTION_FAILURE', 'STATUS_GRAPHICS_INVALID_STRIDE', 'STATUS_INVALID_CID', 'STATUS_NDIS_ALREADY_MAPPED', 'STATUS_TRANSACTION_INTEGRITY_VIOLATED', 'STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION', 'STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR', 'szOID_INFOSEC_sdnsIntegrity', 'CERT_NAME_FRIENDLY_DISPLAY_TYPE', 'SM_CXFOCUSBORDER', 'STATUS_CLUSTER_NODE_UNREACHABLE', 'STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST', 'ERROR_REM_NOT_LIST', 'STATUS_FILE_INVALID', 'STATUS_TRANSACTION_SUPERIOR_EXISTS', 'STATUS_WAIT_0', 'SM_CXSMICON', 'STATUS_ONLY_IF_CONNECTED', 'STATUS_FLT_BUFFER_TOO_SMALL', 'STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY', 'STATUS_ISSUING_CA_UNTRUSTED_KDC', 'ERROR_NO_ACE_CONDITION', 'REPORT_NO_PRIVATE_KEY', 'STATUS_TRANSACTIONMANAGER_NOT_FOUND', 'STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED', 'STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT', 'STGM_CREATE', 'CRYPT_E_OID_FORMAT', 'STATUS_REPLY_MESSAGE_MISMATCH', 'STATUS_GRAPHICS_INVALID_DRIVER_MODEL', 'STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME', 'STATUS_GRAPHICS_OPM_INVALID_HANDLE', 'CERT_STORE_PROV_SYSTEM_REGISTRY', 'MEM_IMAGE', 'CRYPT_USER_KEYSET', 'STATUS_FWP_NO_TXN_IN_PROGRESS', 'STATUS_EFS_ALG_BLOB_TOO_BIG', 'CMSG_BARE_CONTENT_FLAG', 'ERROR_SEGMENT_NOTIFICATION', 'szOID_RSA_preferSignedData', 'ERROR_SAME_DRIVE', 'ERROR_NOACCESS', 'X509_PUBLIC_KEY_INFO', 'ERROR_EVT_CHANNEL_NOT_FOUND', 'SE_INC_WORKING_SET_NAME', 'KEY_EXECUTE', 'EXCEPTION_INVALID_HANDLE', 'RPC_NT_UNKNOWN_AUTHN_LEVEL', 'MS_DEF_RSA_SIG_PROV', 'EXCEPTION_INT_DIVIDE_BY_ZERO', 'RPC_S_UNKNOWN_IF', 'STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG', 'FILE_OPEN_BY_FILE_ID', 'RPC_NT_UNSUPPORTED_NAME_SYNTAX', 'STATUS_NOT_TINY_STREAM', 'SW_SHOWNA', 'IMAGE_FILE_SYSTEM', 'STATUS_FS_DRIVER_REQUIRED', 'szOID_OIWSEC_md4RSA', 'CERT_CHAIN_REVOCATION_CHECK_END_CERT', 'S_OK', 'AF_DLI', 'IMAGE_FILE_MACHINE_MIPS16', 'ERROR_INSUFFICIENT_POWER', 'STATUS_AUDITING_DISABLED', 'STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY', 'FILE_ADD_FILE', 'STATUS_FLT_NO_HANDLER_DEFINED', 'IMAGE_FILE_LOCAL_SYMS_STRIPPED', 'CMSG_BARE_CONTENT_PARAM', 'FILE_NOTIFY_CHANGE_SECURITY', 'STATUS_SERVER_DISABLED', 'MS_DEF_RSA_SIG_PROV_W', 'SERVICE_DEMAND_START', 'STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED', 'RPC_NT_SS_HANDLES_MISMATCH', 'STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION', 'CONTROL_C_EXIT', 'STATUS_REGISTRY_CORRUPT', 'MS_DEF_RSA_SIG_PROV_A', 'STATUS_NDIS_UNSUPPORTED_REVISION', 'CERT_ENCODING_TYPE_MASK', 'ERROR_MAX_SESSIONS_REACHED', 'STATUS_RESOURCEMANAGER_READ_ONLY', 'SE_RELABEL_NAME', 'ERROR_QUOTA_LIST_INCONSISTENT', 'STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE', 'ERROR_STACK_OVERFLOW', 'ERROR_IMAGE_NOT_AT_BASE', 'ERROR_SEM_TIMEOUT', 'CMSG_UNPROTECTED_ATTR_PARAM', 'FILE_SUPPORTS_OBJECT_IDS', 'STATUS_INVALID_QUOTA_LOWER', 'STATUS_NDIS_RESET_IN_PROGRESS', 'EVENTLOG_SEQUENTIAL_READ', 'IMAGE_SCN_CNT_CODE', 'CERT_NAME_DISABLE_IE4_UTF8_FLAG', 'STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR', 'ABOVE_NORMAL_PRIORITY_CLASS', 'PROV_DSS', 'STATUS_CLUSTER_NODE_ALREADY_DOWN', 'ERROR_INVALID_FLAG_NUMBER', 'SM_CYBORDER', 'IMAGE_SCN_GPREL', 'szOID_RFC3161_counterSign', 'ERROR_FILE_INVALID', 'STATUS_RM_METADATA_CORRUPT', 'ERROR_OPLOCK_NOT_GRANTED', 'ERROR_INVALID_SEGDPL', 'PRODUCT_DATACENTER_SERVER_CORE_V', 'ERROR_ABIOS_ERROR', 'RPC_NT_BYTE_COUNT_TOO_SMALL', 'RPC_RESPONSE_TYPE_SUCCESS', 'STATUS_RXACT_COMMIT_NECESSARY', 'X509_KEY_ATTRIBUTES', 'OS_ANYSERVER', 'STATUS_TRANSACTION_NOT_ENLISTED', 'WTD_UI_NONE', 'STATUS_GRAPHICS_ALLOCATION_CLOSED', 'FILE_ATTRIBUTE_SYSTEM', 'X509_OCTET_STRING', 'STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION', 'FILE_WRITE_ATTRIBUTES', 'ERROR_NOINTERFACE', 'ERROR_INVALID_ORDINAL', 'SM_CYSMICON', 'PRODUCT_STORAGE_EXPRESS_SERVER', 'IMAGE_DIRECTORY_ENTRY_SECURITY', 'STATUS_INVALID_SID', 'STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST', 'IMAGE_SCN_MEM_READ', 'STATUS_CRED_REQUIRES_CONFIRMATION', 'STATUS_FLT_VOLUME_NOT_FOUND', 'ERROR_MAX_THRDS_REACHED', 'SERVICE_CONTROL_NETBINDADD', 'X509_ANY_STRING', 'ERROR_EAS_NOT_SUPPORTED', 'STATUS_GRAPHICS_INVALID_FREQUENCY', 'CONTEXT_CONTROL', 'szOID_RSA_SHA256RSA', 'PAGE_EXECUTE_WRITECOPY', 'SM_CXSCREEN', 'CRYPT_E_NOT_DECRYPTED', 'STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED', 'ERROR_BACKUP_CONTROLLER', 'STATUS_GRAPHICS_OPM_NOT_SUPPORTED', 'STATUS_DRIVER_BLOCKED', 'ERROR_REGISTRY_RECOVERED', 'SECURITY_MANDATORY_SYSTEM_RID', 'CREATE_SEPARATE_WOW_VDM', 'STATUS_NDIS_DEVICE_FAILED', 'ERROR_ENVVAR_NOT_FOUND', 'FILE_NOTIFY_CHANGE_LAST_WRITE', 'DBG_PRINTEXCEPTION_C', 'STATUS_FVE_AUTH_INVALID_CONFIG', 'STARTF_FORCEOFFFEEDBACK', 'ERROR_TOO_MANY_NAMES', 'SERVICE_INTERACTIVE_PROCESS', 'STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED', 'OS_NT', 'CREATE_THREAD_DEBUG_EVENT', 'SW_MAXIMIZE', 'STATUS_INVALID_EA_NAME', 'ERROR_TRANSACTION_ALREADY_COMMITTED', 'X509_AUTHORITY_KEY_ID', 'ERROR_FORMS_AUTH_REQUIRED', 'PRODUCT_STANDARD_SERVER_V', 'MS_ENH_RSA_AES_PROV_XP_W', 'STATUS_FLOPPY_UNKNOWN_ERROR', 'STATUS_PROCESS_IS_TERMINATING', 'ERROR_CALL_NOT_IMPLEMENTED', 'IMAGE_FILE_MACHINE_MIPSFPU', 'STATUS_TIMER_RESUME_IGNORED', 'STATUS_TRANSACTION_ABORTED', 'STATUS_INVALID_DISPOSITION', 'CERT_TRUST_IS_OFFLINE_REVOCATION', 'SM_ARRANGE', 'SW_SHOWNORMAL', 'CRYPT_ENCODE_DECODE_NONE', 'MS_ENHANCED_PROV_W', 'PROV_DSS_DH', 'STATUS_INTEGER_OVERFLOW', 'CMSG_CERT_PARAM', 'SE_LOCK_MEMORY_NAME', 'STATUS_ILLEGAL_CHARACTER', 'UNPROTECTED_SACL_SECURITY_INFORMATION', 'CRYPT_DEFAULT_CONTAINER_OPTIONAL', 'ERROR_DBG_CONTROL_BREAK', 'STATUS_IPSEC_INTEGRITY_CHECK_FAILED', 'szOID_DSALG_RSA', 'RPC_NT_INVALID_BOUND', 'STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE', 'PROV_RSA_SCHANNEL', 'STATUS_LOCK_NOT_GRANTED', 'ERROR_FLOPPY_VOLUME', 'AF_UNKNOWN1', 'ERROR_WAIT_FOR_OPLOCK', 'SERVICE_CONTROL_NETBINDENABLE', 'RPC_NT_NO_INTERFACES', 'STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE', 'szOID_RSA_signEnvData', 'SECTION_MAP_READ', 'STATUS_UNEXPECTED_IO_ERROR', 'STATUS_WRONG_PASSWORD_CORE', 'SECTION_MAP_EXECUTE', 'STATUS_CTX_CONSOLE_CONNECT', 'EVENT_ALL_ACCESS', 'STATUS_WRONG_EFS', 'STATUS_WMI_INSTANCE_NOT_FOUND', 'CERT_FIND_SUBJECT_ATTR', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_UINT64', 'CERT_QUERY_OBJECT_FILE', 'STATUS_RESOURCE_LANG_NOT_FOUND', 'SCOPE_SECURITY_INFORMATION', 'STATUS_FLT_DUPLICATE_ENTRY', 'IMAGE_FILE_AGGRESIVE_WS_TRIM', 'STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER', 'STATUS_TOO_MANY_GUIDS_REQUESTED', 'STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED', 'RPC_NT_NO_CONTEXT_AVAILABLE', 'ERROR_BAD_FILE_TYPE', 'STATUS_MUST_BE_KDC', 'IMAGE_FILE_DLL', 'STATUS_LONGJUMP', 'STATUS_NDIS_BAD_VERSION', 'STATUS_TRANSACTION_RECORD_TOO_LONG', 'ERROR_NO_CALLBACK_ACTIVE', 'IMAGE_SCN_MEM_PRELOAD', 'CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED', 'SE_SACL_PRESENT', 'STATUS_ACPI_FATAL', 'CRYPT_E_UNEXPECTED_ENCODING', 'SM_CXFULLSCREEN', 'STATUS_CTX_TD_ERROR', 'STATUS_DS_VERSION_CHECK_FAILURE', 'STATUS_IN_PAGE_ERROR', 'NTE_BAD_KEY', 'ERROR_CALLBACK_POP_STACK', 'ERROR_INTERRUPT_VECTOR_ALREADY_CONNECTED', 'CERT_TRUST_IS_NOT_TIME_VALID', 'SERVICE_ACCEPT_STOP', 'CMSG_VERIFY_SIGNER_CERT', 'CERT_STORE_PROV_SYSTEM_W', 'STANDARD_RIGHTS_REQUIRED', 'RPC_NT_INVALID_BINDING', 'ERROR_EVT_QUERY_RESULT_STALE', 'CREATE_BREAKAWAY_FROM_JOB', 'STATUS_NOT_SERVER_SESSION', 'STATUS_INVALID_SUB_AUTHORITY', 'STATUS_ACPI_ADDRESS_NOT_MAPPED', 'SERVICE_RECOGNIZER_DRIVER', 'ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND', 'STATUS_TRANSACTION_ALREADY_ABORTED', 'RRF_RT_ANY', 'CERT_INFO_VERSION_FLAG', 'CERT_TRUST_IS_COMPLEX_CHAIN', 'CRYPT_USER_PROTECTED', 'STATUS_ENCRYPTION_FAILED', 'ERROR_FS_DRIVER_REQUIRED', 'FILE_CASE_SENSITIVE_SEARCH', 'IMAGE_DLLCHARACTERISTICS_GUARD_CF', 'STATUS_DS_DOMAIN_RENAME_IN_PROGRESS', 'STATUS_INVALID_TASK_NAME', 'STATUS_ACPI_MUTEX_NOT_OWNER', 'TOKEN_SECURITY_ATTRIBUTE_CUSTOM_FLAGS', 'STATUS_NOT_SAME_DEVICE', 'FILE_SUPPORTS_OPEN_BY_FILE_ID', 'STATUS_LPC_RECEIVE_BUFFER_EXPECTED', 'STGM_PRIORITY', 'STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL', 'STATUS_EVENTLOG_FILE_CHANGED', 'STATUS_CRM_PROTOCOL_ALREADY_EXISTS', 'STATUS_CONFLICTING_ADDRESSES', 'SW_SHOWMINIMIZED', 'STATUS_RECOVERY_NOT_NEEDED', 'STATUS_DS_HAVE_PRIMARY_MEMBERS', 'STATUS_POSSIBLE_DEADLOCK', 'ERROR_DRIVER_FAILED_PRIOR_UNLOAD', 'PROCESS_QUERY_LIMITED_INFORMATION', 'STGM_DIRECT_SWMR', 'STATUS_BAD_CLUSTERS', 'RPC_NT_INVALID_PIPE_OBJECT', 'STATUS_WX86_FLOAT_STACK_CHECK', 'STATUS_INSUFFICIENT_POWER', 'SM_CYCAPTION', 'CMSG_CMS_RECIPIENT_INFO_PARAM', 'CERT_INFO_ISSUER_UNIQUE_ID_FLAG', 'ERROR_UNSUPPORTED_COMPRESSION', 'szOID_RSA_SMIMEalgCMSRC2wrap', 'szOID_RSA_contentType', 'DRIVE_NO_ROOT_DIR', 'MS_ENHANCED_PROV', 'CERT_SUBJECT_NAME_MD5_HASH_PROP_ID', 'STATUS_FVE_KEYFILE_INVALID', 'TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN', 'STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE', 'szOID_NIST_AES192_CBC', 'STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED', 'IMAGE_REL_BASED_HIGHADJ', 'STATUS_SXS_FILE_HASH_MISMATCH', 'ERROR_OUT_OF_STRUCTURES', 'CMSG_RECIPIENT_INDEX_PARAM', 'IMAGE_FILE_MACHINE_R4000', 'STATUS_CANT_OPEN_ANONYMOUS', 'RPC_NT_INVALID_STRING_BINDING', 'STATUS_TXF_METADATA_ALREADY_PRESENT', 'COMPRESSION_ENGINE_STANDARD', 'STATUS_FWP_NOT_FOUND', 'MUTANT_QUERY_STATE', 'STATUS_WRONG_COMPARTMENT', 'STATUS_CANT_RECOVER_WITH_HANDLE_OPEN', 'STATUS_PKU2U_CERT_FAILURE', 'SM_CLEANBOOT', 'LPC_DEBUG_EVENT', 'STATUS_GRAPHICS_NO_PREFERRED_MODE', 'IMAGE_SCN_ALIGN_1024BYTES', 'SE_SELF_RELATIVE', 'CRYPT_E_MSG_ERROR', 'ERROR_CANCEL_VIOLATION', 'ERROR_READ_FAULT', 'SERVICE_RUNNING', 'CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED', 'CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS', 'FILE_FLAG_SEQUENTIAL_SCAN', 'STATUS_NOT_EXPORT_FORMAT', 'STATUS_CHECKOUT_REQUIRED', 'STATUS_OBJECT_PATH_INVALID', 'STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE', 'STATUS_CTX_LICENSE_NOT_AVAILABLE', 'OUTPUT_DEBUG_STRING_EVENT', 'CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT', 'STATUS_DRIVER_FAILED_SLEEP', 'STATUS_GRAPHICS_MODE_NOT_PINNED', 'STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS', 'CMSG_VERIFY_SIGNER_NULL', 'ERROR_INVALID_STARTING_CODESEG', 'szOID_INFOSEC_mosaicSignature', 'ERROR_INVALID_ADDRESS', 'PROV_DH_SCHANNEL', 'FILE_NOTIFY_CHANGE_FILE_NAME', 'STATUS_CROSSREALM_DELEGATION_FAILURE', 'ERROR_INVALID_LOCK_RANGE', 'CONTEXT_EXTENDED_REGISTERS', 'CERT_STORE_CRL_CONTEXT', 'SECTION_EXTEND_SIZE', 'STATUS_GRAPHICS_DATASET_IS_EMPTY', 'STATUS_INVALID_IMAGE_WIN_32', 'SE_TCB_NAME', 'CALLBACK_ALL_ACCESS', 'CERT_STORE_PROV_COLLECTION', 'ERROR_REGISTRY_HIVE_RECOVERED', 'CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY', 'ERROR_UNHANDLED_EXCEPTION', 'STATUS_BREAKPOINT', 'CERT_NAME_DNS_TYPE', 'STATUS_CLUSTER_INVALID_NETWORK', 'SERVICE_CONTROL_NETBINDREMOVE', 'STATUS_INCOMPATIBLE_DRIVER_BLOCKED', 'szOID_INFOSEC', 'STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST', 'STATUS_LINK_FAILED', 'PROCESS_VM_READ', 'STATUS_STACK_OVERFLOW', 'TOKEN_ALL_ACCESS', 'STATUS_POLICY_ONLY_IN_DS', 'STATUS_FLT_VOLUME_ALREADY_MOUNTED', 'STATUS_CURRENT_TRANSACTION_NOT_VALID', 'STATUS_AUTHIP_FAILURE', 'NTE_INVALID_PARAMETER', 'NTE_SIGNATURE_FILE_BAD', 'IMAGE_DIRECTORY_ENTRY_GLOBALPTR', 'PROCESS_TRUST_LABEL_SECURITY_INFORMATION', 'ERROR_UNRECOGNIZED_VOLUME', 'CMSG_CTRL_DEL_CRL', 'RPC_NT_NO_PROTSEQS_REGISTERED', 'STATUS_ABANDON_HIBERFILE', 'STATUS_IMAGE_ALREADY_LOADED', 'CRYPT_NDR_ENCODING', 'STATUS_ENTRYPOINT_NOT_FOUND', 'STATUS_FLT_MUST_BE_NONPAGED_POOL', 'STATUS_ALPC_CHECK_COMPLETION_LIST', 'STATUS_RESOURCE_IN_USE', 'RPC_NT_ALREADY_LISTENING', 'FILE_NOTIFY_CHANGE_LAST_ACCESS', 'ERROR_PORT_NOT_SET', 'OS_APPLIANCE', 'SM_CXICONSPACING', 'CERT_SYSTEM_STORE_CURRENT_USER_ID', 'SEMAPHORE_ALL_ACCESS', 'STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS', 'ERROR_CRASH_DUMP', 'ERROR_LOCK_VIOLATION', 'DEBUG_EVENT_EXIT_PROCESS', 'MEM_RELEASE', 'STATUS_PTE_CHANGED', 'ALPC_HANDLEFLG_DUPLICATE_INHERIT', 'STATUS_PARITY_ERROR', 'CMSG_CMS_ENCAPSULATED_CONTENT_FLAG', 'STATUS_IPSEC_QUEUE_OVERFLOW', 'INHERIT_CALLER_PRIORITY', 'IMAGE_SCN_NO_DEFER_SPEC_EXC', 'STATUS_NDIS_OPEN_FAILED', 'STATUS_PNP_REBOOT_REQUIRED', 'STATUS_WMI_ALREADY_DISABLED', 'ERROR_OBJECT_NAME_EXISTS', 'FAX_JOB_MANAGE', 'STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED', 'STATUS_INVALID_PIPE_STATE', 'ERROR_BAD_DRIVER_LEVEL', 'CERT_EXTENDED_ERROR_INFO_PROP_ID', 'STATUS_FWP_CONDITION_NOT_FOUND', 'PIPE_ACCESS_INBOUND', 'ERROR_BUFFER_OVERFLOW', 'STATUS_INVALID_VIEW_SIZE', 'NTE_BAD_KEY_STATE', 'STATUS_IPSEC_DOSP_INVALID_PACKET', 'SERVICE_ACCEPT_TIMECHANGE', 'STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED', 'STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY', 'CERT_TRUST_IS_PEER_TRUSTED', 'STATUS_IPSEC_DOSP_RECEIVED_MULTICAST', 'szOID_OIWSEC_shaDSA', 'KEY_CREATE_SUB_KEY', 'SM_CXCURSOR', 'STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET', 'PKCS12_PREFER_CNG_KSP', 'STATUS_DEVICE_NOT_READY', 'CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR', 'SERVICE_AUTO_START', 'OS_HOME', 'WTD_CHOICE_CATALOG', 'CERT_STORE_PROV_PKCS12', 'RPC_NT_UNKNOWN_MGR_TYPE', 'STATUS_CALLBACK_RETURNED_THREAD_PRIORITY', 'SM_CYMINSPACING', 'STATUS_NOT_SUPPORTED_ON_SBS', 'ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE', 'RPC_NT_PROTSEQ_NOT_FOUND', 'STATUS_GRAPHICS_PRESENT_OCCLUDED', 'SM_XVIRTUALSCREEN', 'TOKEN_ADJUST_GROUPS', 'CMSG_SIGNER_INFO_PARAM', 'DBG_EXCEPTION_NOT_HANDLED', 'FILE_SUPPORTS_EXTENDED_ATTRIBUTES', 'AF_ISO', 'STATUS_NO_SUCH_ALIAS', 'NTE_BUFFERS_OVERLAP', 'X509_MULTI_BYTE_INTEGER', 'STATUS_SXS_VERSION_CONFLICT', 'STATUS_IO_REPARSE_DATA_INVALID', 'IMAGE_DLLCHARACTERISTICS_NO_SEH', 'ACCESS_DENIED_ACE_TYPE', 'STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE', 'ERROR_EVT_FILTER_TOO_COMPLEX', 'szOID_INFOSEC_sdnsTokenProtection', 'STATUS_AUDIT_FAILED', 'STATUS_QUOTA_LIST_INCONSISTENT', 'STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED', 'PRODUCT_PROFESSIONAL', 'HKEY_CLASSES_ROOT', 'IMAGE_FILE_MACHINE_TRICORE', 'STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS', 'EXCEPTION_ACCESS_VIOLATION', 'ACCESS_ALLOWED_COMPOUND_ACE_TYPE', 'X509_BASIC_CONSTRAINTS', 'PERSIST_E_SIZEDEFINITE', 'STATUS_MAX_REFERRALS_EXCEEDED', 'STATUS_BAD_BINDINGS', 'ERROR_BAD_ENVIRONMENT', 'STATUS_WMI_NOT_SUPPORTED', 'STATUS_WOW_ASSERTION', 'REG_SZ', 'EXIT_THREAD_DEBUG_EVENT', 'CRYPT_SILENT', 'STATUS_CLIENT_SERVER_PARAMETERS_INVALID', 'ERROR_DEVICE_ALREADY_ATTACHED', 'STATUS_LOG_RESERVATION_INVALID', 'STATUS_TM_INITIALIZATION_FAILED', 'CERT_STORE_DELETE_FLAG', 'ERROR_NO_YIELD_PERFORMED', 'SM_RESERVED1', 'STATUS_GRAPHICS_I2C_NOT_SUPPORTED', 'STATUS_CLUSTER_NODE_NOT_MEMBER', 'SERVICE_KERNEL_DRIVER', 'SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE', 'szOID_OIWSEC_desCBC', 'SM_RESERVED3', 'SERVICE_CONTROL_TRIGGEREVENT', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING', 'SERVICE_CONTROL_SESSIONCHANGE', 'CERT_ENROLLMENT_PROP_ID', 'IMAGE_SCN_ALIGN_32BYTES', 'AF_APPLETALK', 'STATUS_NAME_TOO_LONG', 'szOID_NIST_AES256_WRAP', 'PAGE_READWRITE', 'STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING', 'STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED', 'STATUS_TIMEOUT', 'SE_SYSTEMTIME_NAME', 'SERVICE_TRIGGER_DATA_TYPE_STRING', 'STATUS_CTX_SECURITY_LAYER_ERROR', 'STATUS_TOO_MANY_THREADS', 'MEM_TOP_DOWN', 'CERT_NAME_URL_TYPE', 'SM_YVIRTUALSCREEN', 'SM_MAXIMUMTOUCHES', 'ERROR_FT_READ_RECOVERY_FROM_BACKUP', 'SERVICE_CONTROL_PRESHUTDOWN', 'ERROR_DBG_CONTROL_C', 'ERROR_PIPE_LISTENING', 'STATUS_KDC_CERT_REVOKED', 'ALPC_SECFLG_CREATE_HANDLE', 'szOID_INFOSEC_sdnsSignature', 'ERROR_BAD_STACK', 'STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION', 'CRYPT_NEWKEYSET', 'STATUS_DIRECTORY_NOT_RM', 'CERT_FIND_PROPERTY', 'RPC_NT_NOT_RPC_ERROR', 'STATUS_INVALID_LDT_DESCRIPTOR', 'FILE_ACTION_ADDED', 'szOID_NIST_sha512', 'STATUS_FATAL_APP_EXIT', 'STATUS_ILL_FORMED_PASSWORD', 'CERT_REQUEST_ORIGINATOR_PROP_ID', 'FILE_ATTRIBUTE_READONLY', 'STATUS_MARSHALL_OVERFLOW', 'szOID_RSA_SHA1RSA', 'ERROR_BAD_ACCESSOR_FLAGS', 'SPECIFIC_RIGHTS_ALL', 'STATUS_LOG_CONTAINER_READ_FAILED', 'MEM_COMMIT', 'FILE_NOTIFY_CHANGE_CREATION', 'STATUS_SXS_INVALID_DEACTIVATION', 'STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK', 'szOID_DH_SINGLE_PASS_STDDH_SHA256_KDF', 'STATUS_CORRUPT_SYSTEM_FILE', 'STATUS_GRAPHICS_INVALID_GAMMA_RAMP', 'STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN', 'STATUS_CANNOT_MAKE', 'szOID_RSA_unstructAddr', 'CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT', 'SC_MANAGER_CREATE_SERVICE', 'FILE_OVERWRITTEN', 'CERT_QUERY_CONTENT_SERIALIZED_CRL', 'STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET', 'FILE_ACTION_REMOVED', 'RRF_RT_DWORD', 'RPC_S_PROTOCOL_ERROR', 'X509_INTEGER', 'STATUS_INVALID_VARIANT', 'szOID_DSALG_HASH', 'STATUS_SAM_NEED_BOOTKEY_FLOPPY', 'STATUS_HANDLE_NO_LONGER_VALID', 'STATUS_WX86_BREAKPOINT', 'DRIVE_RAMDISK', 'STATUS_PAGE_FAULT_PAGING_FILE', 'STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED', 'szOID_RSA_RC2CBC', 'SM_CXMENUSIZE', 'CERT_FIND_ISSUER_STR_W', 'STATUS_NDIS_UNSUPPORTED_MEDIA', 'STATUS_RM_NOT_ACTIVE', 'SE_UNDOCK_NAME', 'STATUS_VOLUME_DISMOUNTED', 'PAGE_EXECUTE_READWRITE', 'STATUS_BAD_INITIAL_PC', 'STATUS_PRENT4_MACHINE_ACCOUNT', 'STATUS_TRANSACTION_NOT_JOINED', 'CMSG_CMS_RECIPIENT_COUNT_PARAM', 'STATUS_GRAPHICS_MODE_NOT_IN_MODESET', 'RPC_NT_UNSUPPORTED_TYPE', 'szOID_ECDSA_SHA1', 'STATUS_ALLOTTED_SPACE_EXCEEDED', 'CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE', 'szOID_DSALG_CRPT', 'STATUS_CSS_RESETS_EXHAUSTED', 'CERT_FIND_ISSUER_STR', 'FILE_SYNCHRONOUS_IO_NONALERT', 'DUPLICATE_CLOSE_SOURCE', 'IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP', 'DACL_SECURITY_INFORMATION', 'STATUS_FLT_INSTANCE_ALTITUDE_COLLISION', 'STATUS_BAD_COMPRESSION_BUFFER', 'STATUS_MEMBER_IN_ALIAS', 'STATUS_AUTHENTICATION_FIREWALL_FAILED', 'STATUS_EA_CORRUPT_ERROR', 'THREAD_IMPERSONATE', 'CMSG_VERIFY_SIGNER_CHAIN', 'PRODUCT_STORAGE_WORKGROUP_SERVER_CORE', 'CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID', 'CERT_TRUST_IS_UNTRUSTED_ROOT', 'STATUS_FLOPPY_BAD_REGISTERS', 'SE_TRUSTED_CREDMAN_ACCESS_NAME', 'SW_RESTORE', 'ERROR_CORRUPT_SYSTEM_FILE', 'FILE_NO_EA_KNOWLEDGE', 'STATUS_IPSEC_INVALID_PACKET', 'STATUS_NOT_ALL_ASSIGNED', 'CRYPT_ACQUIRE_COMPARE_KEY_FLAG', 'CRYPT_E_UNKNOWN_ALGO', 'STATUS_ACCESS_AUDIT_BY_POLICY', 'STATUS_FWP_INVALID_NET_MASK', 'ERROR_NETWORK_ACCESS_DENIED', 'STATUS_NETWORK_SESSION_EXPIRED', 'SE_CREATE_GLOBAL_NAME', 'ERROR_ELEVATION_REQUIRED', 'ERROR_PNP_BAD_MPS_TABLE', 'ERROR_FILENAME_EXCED_RANGE', 'STATUS_FVE_PIN_INVALID', 'EPT_NT_CANT_CREATE', 'PRODUCT_SERVER_FOR_SB_SOLUTIONS_EM', 'ERROR_DIRECT_ACCESS_HANDLE', 'STATUS_FT_WRITE_RECOVERY', 'STATUS_PORT_NOT_SET', 'STATUS_FLOAT_DIVIDE_BY_ZERO', 'ERROR_SYSTEM_HIVE_TOO_LARGE', 'INHERIT_ONLY_ACE', 'FILE_DOES_NOT_EXIST', 'STATUS_IO_REPARSE_TAG_INVALID', 'szOID_RSA_MGF1', 'EVENT_QUERY_STATE', 'STATUS_GRAPHICS_MCA_INTERNAL_ERROR', 'SE_CREATE_SYMBOLIC_LINK_NAME', 'LPC_REPLY', 'ERROR_SEM_IS_SET', 'RPC_NT_SS_IN_NULL_CONTEXT', 'PROCESS_TERMINATE', 'SM_CYFULLSCREEN', 'STATUS_FVE_TRANSIENT_STATE', 'RPC_NT_INVALID_NAF_ID', 'STATUS_INVALID_PARAMETER_11', 'STATUS_INVALID_PARAMETER_10', 'ALPC_MSGFLG_RELEASE_MESSAGE', 'ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE', 'WTD_REVOKE_NONE', 'szOID_NIST_AES192_WRAP', 'STATUS_HASH_NOT_PRESENT', 'STATUS_SXS_CANT_GEN_ACTCTX', 'ERROR_DBG_EXCEPTION_NOT_HANDLED', 'STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST', 'STATUS_DS_CANT_MOD_OBJ_CLASS', 'FILE_SUPPORTS_ENCRYPTION', 'DBG_COMMAND_EXCEPTION', 'STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET', 'STATUS_LOG_CLIENT_NOT_REGISTERED', 'STATUS_LOG_BLOCKS_EXHAUSTED', 'szOID_OIWSEC_dsaCommSHA', 'STATUS_INVALID_OPLOCK_PROTOCOL', 'PRODUCT_HOME_BASIC', 'CERT_STORE_PROV_SYSTEM', 'STATUS_DLL_MIGHT_BE_INSECURE', 'STATUS_KDC_CERT_EXPIRED', 'SM_CYSCREEN', 'CERT_STORE_PROV_MSG', 'STATUS_LOGON_TYPE_NOT_GRANTED', 'STATUS_DS_DUPLICATE_ID_FOUND', 'STATUS_NO_S4U_PROT_SUPPORT', 'STATUS_LOG_EPHEMERAL', 'SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP', 'STATUS_LOG_TAIL_INVALID', 'szOID_OIWSEC_dhCommMod', 'STATUS_LOG_PINNED', 'ERROR_EA_ACCESS_DENIED', 'STATUS_CSS_KEY_NOT_PRESENT', 'STATUS_ARBITRATION_UNHANDLED', 'STATUS_ACPI_STACK_OVERFLOW', 'CERT_AUTO_ENROLL_RETRY_PROP_ID', 'STATUS_ACPI_ALREADY_INITIALIZED', 'STATUS_INVALID_CRUNTIME_PARAMETER', 'SACL_SECURITY_INFORMATION', 'STATUS_CLUSTER_NETINTERFACE_EXISTS', 'STATUS_SHARED_IRQ_BUSY', 'PRODUCT_ENTERPRISE_SERVER_CORE_V', 'ERROR_NESTING_NOT_ALLOWED', 'STATUS_FAILED_STACK_SWITCH', 'STATUS_RM_ALREADY_STARTED', 'CREATE_UNICODE_ENVIRONMENT', 'STATUS_ELEVATION_REQUIRED', 'ERROR_NOT_SUBSTED', 'STATUS_IO_REPARSE_TAG_NOT_HANDLED', 'ERROR_BAD_LENGTH', 'RPC_C_AUTHN_LEVEL_CALL', 'STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION', 'FILE_SUPPORTS_USN_JOURNAL', 'RPC_NT_NOTHING_TO_EXPORT', 'ERROR_BAD_FORMAT', 'NTE_BAD_PROVIDER', 'szOID_OIWSEC_sha1RSASign', 'ERROR_NOT_REGISTRY_FILE', 'STATUS_TRANSACTION_INVALID_TYPE', 'OS_FASTUSERSWITCHING', 'STATUS_PIPE_LISTENING', 'STATUS_FVE_BAD_INFORMATION', 'szOID_ECDSA_SHA384', 'VER_NT_DOMAIN_CONTROLLER', 'RPC_NT_SS_CONTEXT_DAMAGED', 'CMSG_CTRL_DEL_SIGNER', 'SE_SYNC_AGENT_NAME', 'STATUS_OPEN_FAILED', 'FILE_OVERWRITE_IF', 'STATUS_XMLDSIG_ERROR', 'STATUS_GRAPHICS_PRESENT_DENIED', 'SERVICE_INTERROGATE', 'EXPORT_PRIVATE_KEYS', 'STATUS_NDIS_INVALID_PORT', 'STATUS_DS_SAM_INIT_FAILURE_CONSOLE', 'X509_UNICODE_ANY_STRING', 'STATUS_NDIS_INDICATION_REQUIRED', 'STATUS_UNRECOGNIZED_MEDIA', 'STATUS_LOGON_FAILURE', 'IMAGE_FILE_MACHINE_R3000', 'PRODUCT_DATACENTER_EVALUATION_SERVER', 'STATUS_DEVICE_PAPER_EMPTY', 'STATUS_FVE_KEYFILE_NO_VMK', 'STATUS_RM_DISCONNECTED', 'THREAD_TERMINATE', 'CERT_E_UNTRUSTEDCA', 'STATUS_INTERNAL_DB_CORRUPTION', 'TOKEN_QUERY', 'STATUS_NO_EVENT_PAIR', 'CERT_FIND_ISSUER_NAME', 'CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT', 'STATUS_NOT_IMPLEMENTED', 'SM_TABLETPC', 'ERROR_ARENA_TRASHED', 'RPC_NT_WRONG_ES_VERSION', 'OPEN_EXISTING', 'STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY', 'IMAGE_REL_BASED_HIGH', 'FILE_MAP_READ', 'STATUS_FWP_NOTIFICATION_DROPPED', 'STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED', 'ACCESS_MAX_MS_V3_ACE_TYPE', 'PROV_REPLACE_OWF', 'TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE', 'STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE', 'STATUS_DS_SRC_SID_EXISTS_IN_FOREST', 'STATUS_INVALID_ACE_CONDITION', 'STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER', 'STARTF_RUNFULLSCREEN', 'STATUS_SECTION_TOO_BIG', 'RPC_NT_TYPE_ALREADY_REGISTERED', 'MAX_PATH', 'CERT_QUERY_CONTENT_FLAG_CRL', 'THREAD_QUERY_INFORMATION', 'STATUS_ALREADY_WIN32', 'ERROR_DBG_CONTINUE', 'STATUS_INVALID_IMAGE_LE_FORMAT', 'IMAGE_SCN_LNK_COMDAT', 'SC_MANAGER_QUERY_LOCK_STATUS', 'EPT_NT_NOT_REGISTERED', 'ALPC_CANCELFLGP_FLUSH', 'ERROR_META_EXPANSION_TOO_LONG', 'STATUS_VIRTDISK_NOT_VIRTUAL_DISK', 'szOID_INFOSEC_mosaicKeyManagement', 'szOID_INFOSEC_SuiteAKeyManagement', 'STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON', 'STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED', 'EVENT_MODIFY_STATE', 'IMAGE_FILE_MACHINE_MIPSFPU16', 'STATUS_ACPI_ACQUIRE_GLOBAL_LOCK', 'FILE_OPEN_REMOTE_INSTANCE', 'ERROR_EVT_QUERY_RESULT_INVALID_POSITION', 'IMAGE_FILE_MACHINE_WCEMIPSV2', 'STATUS_SMARTCARD_NO_KEYSET', 'STATUS_NDIS_ADAPTER_REMOVED', 'ERROR_DELETE_PENDING', 'STATUS_NO_KERB_KEY', 'SM_CXBORDER', 'STATUS_NETLOGON_NOT_STARTED', 'SERVICE_CONTROL_PARAMCHANGE', 'ERROR_DRIVER_DATABASE_ERROR', 'STATUS_WRONG_PASSWORD', 'STATUS_NDIS_INVALID_OID', 'STATUS_SXS_SECTION_NOT_FOUND', 'STATUS_NO_EFS', 'CERT_TRUST_REVOCATION_STATUS_UNKNOWN', 'SM_REMOTESESSION', 'STATUS_SXS_ASSEMBLY_NOT_FOUND', 'ERROR_TOO_MANY_THREADS', 'szOID_TIMESTAMP_TOKEN', 'CERT_STORE_OPEN_EXISTING_FLAG', 'RPC_NT_CALL_CANCELLED', 'STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER', 'STATUS_INVALID_DEVICE_STATE', 'STATUS_NO_PA_DATA', 'ERROR_CANTFETCHBACKWARDS', 'STATUS_INSUFF_SERVER_RESOURCES', 'STATUS_ACPI_INVALID_OPCODE', 'CERT_SMART_CARD_DATA_PROP_ID', 'CERT_COMPARE_SUBJECT_CERT', 'STATUS_SMARTCARD_NO_KEY_CONTAINER', 'STATUS_NOT_LOCKED', 'ERROR_SHARING_BUFFER_EXCEEDED', 'SERVICE_WIN32', 'STATUS_FWP_FILTER_NOT_FOUND', 'SM_MOUSEWHEELPRESENT', 'EXTENDED_STARTUPINFO_PRESENT', 'STATUS_PROCESS_IN_JOB', 'STATUS_REQUEST_NOT_ACCEPTED', 'FILE_OVERWRITE', 'SM_CXMAXTRACK', 'VALID_INHERIT_FLAGS', 'ERROR_NO_PROC_SLOTS', 'STGM_WRITE', 'ERROR_EVT_FILTER_INVTEST', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_SID', 'STATUS_LOG_READ_MODE_INVALID', 'szOID_X957', 'ERROR_BAD_ARGUMENTS', 'STATUS_LOG_CONTAINER_LIMIT_EXCEEDED', 'STATUS_ADAPTER_HARDWARE_ERROR', 'STATUS_SXS_CORRUPT_ACTIVATION_STACK', 'PRODUCT_MULTIPOINT_STANDARD_SERVER', 'FILE_DIRECTORY_FILE', 'NTE_BAD_SIGNATURE', 'PIPE_NOWAIT', 'ERROR_CHILD_MUST_BE_VOLATILE', 'EXCEPTION_FLT_STACK_CHECK', 'STATUS_FWP_TYPE_MISMATCH', 'TOKEN_ADJUST_SESSIONID', 'NTE_DOUBLE_ENCRYPT', 'STATUS_INVALID_PARAMETER', 'ERROR_EAS_DIDNT_FIT', 'PROTECTED_DACL_SECURITY_INFORMATION', 'STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE', 'STATUS_DS_OBJ_CLASS_VIOLATION', 'MS_ENH_RSA_AES_PROV_W', 'ERROR_INVALID_LDT_DESCRIPTOR', 'ERROR_MULTIPLE_FAULT_VIOLATION', 'PRODUCT_ENTERPRISE_EVALUATION', 'STATUS_SXS_IDENTITY_PARSE_ERROR', 'STATUS_CRYPTO_SYSTEM_INVALID', 'PRODUCT_ESSENTIALBUSINESS_SERVER_MGMT', 'szOID_OIWSEC_mdc2', 'STGM_DELETEONRELEASE', 'STATUS_INVALID_LDT_SIZE', 'SM_SERVERR2', 'STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST', 'STATUS_INSUFFICIENT_LOGON_INFO', 'STATUS_REPARSE', 'RPC_NT_UNSUPPORTED_AUTHN_LEVEL', 'ERROR_BAD_EXE_FORMAT', 'CERT_STORE_PROV_PHYSICAL_W', 'ERROR_HIBERNATED', 'DEBUG_EVENT_SESSION_STATUS', 'STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED', 'STATUS_FVE_NO_FEATURE_LICENSE', 'FILE_ADD_SUBDIRECTORY', 'ERROR_LABEL_TOO_LONG', 'CERT_SYSTEM_STORE_LOCAL_MACHINE_ID', 'ERROR_PROFILING_NOT_STOPPED', 'CERT_AIA_URL_RETRIEVED_PROP_ID', 'ACCESS_ALLOWED_CALLBACK_ACE_TYPE', 'SM_CYMENUSIZE', 'RPC_NT_INVALID_TAG', 'RPC_NT_ADDRESS_ERROR', 'AF_12844', 'STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR', 'SERVICE_ENUMERATE_DEPENDENTS', 'GENERIC_WRITE', 'STATUS_CTX_WINSTATION_NAME_COLLISION', 'STATUS_PIPE_EMPTY', 'SE_GROUP_ENABLED', 'ERROR_EVENT_DONE', 'FILE_DELETE_ON_CLOSE', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING', 'STATUS_DEVICE_DATA_ERROR', 'szOID_INFOSEC_mosaicUpdatedSig', 'STATUS_NO_LOGON_SERVERS', 'STATUS_NONEXISTENT_SECTOR', 'STATUS_TM_VOLATILE', 'ERROR_RESUME_HIBERNATION', 'STATUS_CLUSTER_NODE_ALREADY_UP', 'STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP', 'STATUS_DISK_OPERATION_FAILED', 'ERROR_NO_MORE_FILES', 'CERT_STORE_UPDATE_KEYID_FLAG', 'STATUS_TOO_MANY_NAMES', 'CMSG_VERIFY_SIGNER_PUBKEY', 'STATUS_SECURITY_STREAM_IS_INCONSISTENT', 'EXCEPTION_NONCONTINUABLE_EXCEPTION', 'STATUS_NDIS_OFFLOAD_PATH_REJECTED', 'STATUS_CRC_ERROR', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64', 'OS_WIN98_GOLD', 'STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA', 'IMAGE_FILE_BYTES_REVERSED_LO', 'ERROR_CANT_TERMINATE_SELF', 'STATUS_DEVICE_NOT_CONNECTED', 'X509_BASIC_CONSTRAINTS2', 'STATUS_CLUSTER_NETWORK_EXISTS', 'STATUS_KDC_UNABLE_TO_REFER', 'STATUS_BAD_VALIDATION_CLASS', 'DBG_TERMINATE_PROCESS', 'REG_MULTI_SZ', 'STATUS_FWP_NET_EVENTS_DISABLED', 'STATUS_DS_NO_RIDS_ALLOCATED', 'STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME', 'FILE_NO_COMPRESSION', 'STARTF_USESIZE', 'STATUS_MORE_ENTRIES', 'AF_VOICEVIEW', 'STATUS_DOMAIN_TRUST_INCONSISTENT', 'STATUS_SERVER_SHUTDOWN_IN_PROGRESS', 'szOID_NIST_sha384', 'SM_CXPADDEDBORDER', 'STATUS_INVALID_PARAMETER_MIX', 'SERVICE_ERROR_IGNORE', 'PRODUCT_SMALLBUSINESS_SERVER_PREMIUM_CORE', 'FILE_FLAG_WRITE_THROUGH', 'STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM', 'PRODUCT_STORAGE_STANDARD_EVALUATION_SERVER', 'FILE_RESERVE_OPFILTER', 'STATUS_PURGE_FAILED', 'ERROR_WAKE_SYSTEM', 'STATUS_FVE_NO_LICENSE', 'CMSG_DETACHED_FLAG', 'STATUS_LOG_METADATA_INCONSISTENT', 'ERROR_NO_SIGNAL_SENT', 'STATUS_SPECIAL_USER', 'STATUS_INVALID_TRANSACTION', 'szOID_OIWSEC', 'ERROR_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING', 'CREATE_SHARED_WOW_VDM', 'STATUS_DESTINATION_ELEMENT_FULL', 'SM_CYSMSIZE', 'STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET', 'X509_CERT_REQUEST_TO_BE_SIGNED', 'ERROR_FIRMWARE_UPDATED', 'LPC_PORT_CLOSED', 'API_SET_SCHEMA_FLAGS_HOST_EXTENSION', 'STATUS_INVALID_PARAMETER_9', 'RPC_NT_INVALID_STRING_UUID', 'STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE', 'FILE_MAP_COPY', 'STATUS_DS_NAME_NOT_UNIQUE', 'STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA', 'ERROR_ILLEGAL_CHARACTER', 'NTE_BAD_UID', 'FILE_READ_ONLY_VOLUME', 'STATUS_LOG_POLICY_CONFLICT', 'STATUS_INVALID_IMAGE_PROTECT', 'szOID_OIW', 'FILE_ATTRIBUTE_HIDDEN', 'STATUS_GRAPHICS_OPM_INTERNAL_ERROR', 'szOID_ECC_PUBLIC_KEY', 'IMAGE_DIRECTORY_ENTRY_EXCEPTION', 'CERT_E_CN_NO_MATCH', 'STATUS_FVE_NOT_DATA_VOLUME', 'STATUS_CTX_CLIENT_LICENSE_NOT_SET', 'STATUS_PAGEFILE_CREATE_FAILED', 'ALPC_MESSAGE_SECURITY_ATTRIBUTE', 'SE_GROUP_OWNER', 'CREATE_FORCEDOS', 'szOID_OIWSEC_md4RSA2', 'STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK', 'SYSTEM_MANDATORY_LABEL_ACE_TYPE', 'ERROR_CAN_NOT_COMPLETE', 'PRODUCT_CORE_ARM', 'STATUS_SINGLE_STEP', 'STATUS_OBJECT_NAME_INVALID', 'STATUS_ACCOUNT_RESTRICTION', 'TH32CS_SNAPPROCESS', 'STATUS_CLUSTER_NETWORK_NOT_FOUND', 'STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE', 'SM_CXMINTRACK', 'STATUS_CTX_MODEM_RESPONSE_BUSY', 'CERT_E_EXPIRED', 'ERROR_PRINT_CANCELLED', 'STATUS_DS_GC_REQUIRED', 'RPC_NT_NOT_ALL_OBJS_UNEXPORTED', 'ERROR_BAD_THREADID_ADDR', 'CERT_STORE_PROV_PHYSICAL', 'szOID_OIWSEC_rsaXchg', 'STATUS_SERVER_NOT_DISABLED', 'STATUS_LOG_CONTAINER_OPEN_FAILED', 'szOID_ECC_CURVE_P384', 'SE_ASSIGNPRIMARYTOKEN_NAME', 'ERROR_CONVERT_TO_LARGE', 'RPC_C_AUTHN_LEVEL_PKT_INTEGRITY', 'STATUS_GRAPHICS_INVALID_POINTER', 'ERROR_BAD_NET_RESP', 'DBG_APP_NOT_IDLE', 'RPC_NT_SS_CHAR_TRANS_SHORT_FILE', 'IMAGE_DIRECTORY_ENTRY_RESOURCE', 'STATUS_VIRTDISK_PROVIDER_NOT_FOUND', 'STATUS_ADDRESS_ALREADY_ASSOCIATED', 'STATUS_NETWORK_OPEN_RESTRICTION', 'CMSG_CRYPT_RELEASE_CONTEXT_FLAG', 'STATUS_UNEXPECTED_MM_EXTEND_ERR', 'S_FALSE', 'AF_OSI', 'ERROR_SEM_OWNER_DIED', 'ERROR_BAD_MCFG_TABLE', 'RPC_NT_PROXY_ACCESS_DENIED', 'EPT_NT_INVALID_ENTRY', 'STGM_READ', 'STATUS_CLUSTER_NODE_EXISTS', 'ERROR_EVT_INVALID_CHANNEL_PATH', 'ERROR_KEY_DELETED', 'STATUS_ACPI_NOT_INITIALIZED', 'STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED', 'STATUS_MEMBER_IN_GROUP', 'FILE_MAP_EXECUTE', 'STATUS_MUTANT_NOT_OWNED', 'SM_CXDRAG', 'STATUS_INVALID_LDT_OFFSET', 'STATUS_VARIABLE_NOT_FOUND', 'EXCEPTION_GUARD_PAGE', 'OS_DATACENTER', 'ALPC_MESSAGE_DIRECT_ATTRIBUTE', 'STATUS_FLOAT_INEXACT_RESULT', 'STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST', 'TOKEN_MANDATORY_POLICY_NO_WRITE_UP', 'NTE_NO_KEY', 'SM_PENWINDOWS', 'STATUS_MUI_INVALID_LOCALE_NAME', 'CERT_QUERY_CONTENT_PKCS7_SIGNED', 'STATUS_NDIS_MULTICAST_FULL', 'ACCESS_MAX_MS_V5_ACE_TYPE', 'STATUS_CONNECTION_IN_USE', 'STATUS_CTX_SHADOW_NOT_RUNNING', 'OS_WIN2000TERMINAL', 'STATUS_DS_CANT_ON_NON_LEAF', 'FILE_APPEND_DATA', 'STATUS_SXS_THREAD_QUERIES_DISABLED', 'SERVICE_TYPE_ALL', 'STATUS_NO_SUCH_PACKAGE', 'RPC_NT_PROTSEQ_NOT_SUPPORTED', 'ERROR_FAIL_I24', 'STATUS_LOGIN_TIME_RESTRICTION', 'STATUS_CALLBACK_RETURNED_TRANSACTION', 'STATUS_TOO_MANY_LUIDS_REQUESTED', 'SERVICE_CONTROL_CONTINUE', 'CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT', 'STATUS_FWP_CANNOT_PEND', 'SM_CYMAXIMIZED', 'X509_KEY_USAGE', 'FILE_FLAG_DELETE_ON_CLOSE', 'GENERIC_EXECUTE', 'STATUS_GRAPHICS_INVALID_VIDPN', 'STATUS_ILLEGAL_DLL_RELOCATION', 'CERT_TRUST_IS_NOT_TIME_NESTED', 'RPC_NT_SERVER_UNAVAILABLE', 'ERROR_REGISTRY_QUOTA_LIMIT', 'ERROR_IS_SUBST_PATH', 'STATUS_LOG_RESIZE_INVALID_SIZE', 'szOID_OIWDIR_SIGN', 'FILE_ACTION_RENAMED_OLD_NAME', 'EXCEPTION_SINGLE_STEP', 'STATUS_FLOAT_DENORMAL_OPERAND', 'PRODUCT_SOLUTION_EMBEDDEDSERVER', 'FILE_NOTIFY_CHANGE_DIR_NAME', 'SM_CYVTHUMB', 'STATUS_MEMBER_NOT_IN_GROUP', 'STATUS_DATATYPE_MISALIGNMENT', 'STATUS_SXS_EARLY_DEACTIVATION', 'STATUS_INSUFFICIENT_NVRAM_RESOURCES', 'STATUS_FAIL_CHECK', 'CERT_TRUST_INVALID_NAME_CONSTRAINTS', 'TOKEN_ADJUST_PRIVILEGES', 'ERROR_THREAD_MODE_NOT_BACKGROUND', 'SERVICE_PAUSE_CONTINUE', 'STATUS_CANNOT_ABORT_TRANSACTIONS', 'STATUS_MEMBERS_PRIMARY_GROUP', 'CREATE_NEW_CONSOLE', 'FILE_MAP_ALL_ACCESS', 'LPC_LOST_REPLY', 'CERT_STORE_MAXIMUM_ALLOWED_FLAG', 'STATUS_LOG_PINNED_ARCHIVE_TAIL', 'PRODUCT_SMALLBUSINESS_SERVER', 'CREATE_NEW', 'CERT_STORE_PROV_FILE', 'szOID_RSA_SHA512RSA', 'PRODUCT_HYPERV', 'SW_SHOWDEFAULT', 'szOID_OIWDIR', 'STGM_SIMPLE', 'CERT_TRUST_IS_SELF_SIGNED', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_STRING', 'CRYPT_ONLINE', 'STATUS_GRAPHICS_UAB_NOT_SUPPORTED', 'szOID_INFOSEC_mosaicIntegrity', 'FILE_OPEN_REPARSE_POINT', 'DIRECTORY_CREATE_SUBDIRECTORY', 'SE_DACL_AUTO_INHERITED', 'IMAGE_FILE_MACHINE_ALPHA64', 'IO_COMPLETION_QUERY_STATE', 'STATUS_NDIS_MEDIA_DISCONNECTED', 'STATUS_RECEIVE_EXPEDITED', 'STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT', 'FILE_ATTRIBUTE_NOT_CONTENT_INDEXED', 'STATUS_GRAPHICS_INVALID_COLORBASIS', 'SE_MANAGE_VOLUME_NAME', 'ERROR_MISSING_SYSTEMFILE', 'STATUS_BAD_LOGON_SESSION_STATE', 'IMAGE_SCN_TYPE_GROUP', 'STATUS_PORT_CONNECTION_REFUSED', 'STATUS_INVALID_WORKSTATION', 'IMAGE_SCN_TYPE_DSECT', 'AF_CHAOS', 'RPC_NT_DUPLICATE_ENDPOINT', 'STATUS_NOT_SAFE_MODE_DRIVER', 'PRODUCT_BUSINESS', 'ERROR_RECEIVE_EXPEDITED', 'PAGE_NOCACHE', 'STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING', 'SM_CYEDGE', 'ERROR_UNEXP_NET_ERR', 'BELOW_NORMAL_PRIORITY_CLASS', 'SERVICE_ACCEPT_NETBINDCHANGE', 'ERROR_IS_JOIN_TARGET', 'STATUS_RESTART_BOOT_APPLICATION', 'STATUS_EAS_NOT_SUPPORTED', 'STATUS_ACPI_INVALID_SUPERNAME', 'STATUS_EOM_OVERFLOW', 'ERROR_MEMORY_HARDWARE', 'CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL', 'STATUS_FWP_INCOMPATIBLE_AUTH_METHOD', 'STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE', 'ERROR_WX86_ERROR', 'STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND', 'STATUS_RXACT_COMMITTED', 'ERROR_INVALID_VERIFY_SWITCH', 'ERROR_BADDB', 'FILE_ATTRIBUTE_DIRECTORY', 'STATUS_INSTANCE_NOT_AVAILABLE', 'CREATE_NEW_PROCESS_GROUP', 'ERROR_VC_DISCONNECTED', 'CMSG_ENVELOPE_ALGORITHM_PARAM', 'STGFMT_DOCUMENT', 'FILE_EXECUTE', 'IMAGE_FILE_DEBUG_STRIPPED', 'PRODUCT_STORAGE_WORKGROUP_SERVER', 'CMSG_RECIPIENT_INFO_PARAM', 'STATUS_BAD_DEVICE_TYPE', 'STATUS_THREAD_IS_TERMINATING', 'STATUS_NO_IMPERSONATION_TOKEN', 'RPC_NT_INVALID_NAME_SYNTAX', 'MS_ENH_RSA_AES_PROV_A', 'SERVICE_PAUSE_PENDING', 'CERT_FIND_PUBKEY_MD5_HASH', 'SM_CYDLGFRAME', 'FILE_OPEN_FOR_FREE_SPACE_QUERY', 'STATUS_FWP_TCPIP_NOT_READY', 'STATUS_CLUSTER_POISONED', 'NTE_KEYSET_NOT_DEF', 'ERROR_VOLUME_MOUNTED', 'STATUS_LOG_STATE_INVALID', 'CMSG_ENCRYPT_PARAM', 'ERROR_WRITE_FAULT', 'RPC_NT_UNKNOWN_AUTHN_SERVICE', 'STATUS_PIPE_CLOSING', 'FILE_FILE_COMPRESSION', 'STATUS_DISK_REPAIR_DISABLED', 'STATUS_GRAPHICS_STALE_MODESET', 'STATUS_LOGON_NOT_GRANTED', 'STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE', 'STATUS_INVALID_COMPUTER_NAME', 'CERT_RENEWAL_PROP_ID', 'STATUS_ILLEGAL_INSTRUCTION', 'STATUS_NOT_FOUND', 'STATUS_CHECKING_FILE_SYSTEM', 'CERT_QUERY_CONTENT_SERIALIZED_CTL', 'SW_HIDE', 'STATUS_FVE_DRY_RUN_FAILED', 'szOID_OIWSEC_desECB', 'MS_STRONG_PROV_W', 'ERROR_UNEXPECTED_MM_EXTEND_ERR', 'STATUS_INVALID_PARAMETER_4', 'PRODUCT_SB_SOLUTION_SERVER_EM', 'CLUSAPI_ALL_ACCESS', 'STATUS_FVE_DEBUGGER_ENABLED', 'STATUS_DS_SHUTTING_DOWN', 'STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY', 'szOID_RSA_signingTime', 'STATUS_DATA_ERROR', 'ERROR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR', 'STATUS_NO_SUCH_FILE', 'STATUS_IPSEC_REPLAY_CHECK_FAILED', 'CERT_E_PURPOSE', 'RPC_C_QOS_IDENTITY_DYNAMIC', 'ERROR_NO_TOKEN', 'STATUS_NO_TGT_REPLY', 'CERT_E_REVOKED', 'szOID_OIWSEC_dsaCommSHA1', 'STATUS_FWP_LIFETIME_MISMATCH', 'FILE_SUPPORTS_REPARSE_POINTS', 'STATUS_DRIVER_ENTRYPOINT_NOT_FOUND', 'IMAGE_SCN_TYPE_COPY', 'ERROR_VALIDATE_CONTINUE', 'STATUS_INVALID_PARAMETER_2', 'ERROR_SUBST_TO_JOIN', 'LPC_CONNECTION_REQUEST', 'STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE', 'RPC_RESPONSE_TYPE_FAIL', 'EXCEPTION_DEBUG_EVENT', 'REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY', 'SM_CXSMSIZE', 'STATUS_VOLSNAP_HIBERNATE_READY', 'IMAGE_DIRECTORY_ENTRY_IAT', 'TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT', 'CERT_KEY_SPEC_PROP_ID', 'CMSG_CRL_COUNT_PARAM', 'SERVICE_CONTROL_PAUSE', 'FILE_SUPERSEDED', 'STATUS_HOST_UNREACHABLE', 'ERROR_RANGE_LIST_CONFLICT', 'CRYPT_ARCHIVABLE', 'ERROR_CHILD_NOT_COMPLETE', 'STATUS_RANGE_NOT_FOUND', 'SYSTEM_MANDATORY_LABEL_NO_READ_UP', 'STATUS_TRUSTED_RELATIONSHIP_FAILURE', 'CERT_TRUST_NO_ERROR', 'STATUS_TOO_MANY_PAGING_FILES', 'STATUS_DS_INVALID_GROUP_TYPE', 'STATUS_CTX_LICENSE_EXPIRED', 'STATUS_IPSEC_AUTH_FIREWALL_DROP', 'FILE_VALID_MAILSLOT_OPTION_FLAGS', 'CERT_FIND_CROSS_CERT_DIST_POINTS', 'STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN', 'STATUS_USER_MAPPED_FILE', 'ERROR_NOT_ALL_ASSIGNED', 'ERROR_CANTREAD', 'STATUS_GRAPHICS_TOO_MANY_REFERENCES', 'ERROR_VIRUS_DELETED', 'FAILED_ACCESS_ACE_FLAG', 'RPC_NT_SEC_PKG_ERROR', 'IMAGE_SCN_ALIGN_MASK', 'NTE_BAD_TYPE', 'X509_KEYGEN_REQUEST_TO_BE_SIGNED', 'ERROR_FULLSCREEN_MODE', 'STATUS_COMMITMENT_LIMIT', 'NTE_BAD_FLAGS', 'CONTAINER_INHERIT_ACE', 'STATUS_FWP_INCOMPATIBLE_SA_STATE', 'ERROR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR', 'szOID_INFOSEC_mosaicTokenProtection', 'SERVICE_ACCEPT_PARAMCHANGE', 'OS_TERMINALCLIENT', 'CERT_STORE_BACKUP_RESTORE_FLAG', 'STATUS_IMAGE_CHECKSUM_MISMATCH', 'ERROR_RING2_STACK_IN_USE', 'STATUS_IMAGE_MACHINE_TYPE_MISMATCH', 'STILL_ACTIVE', 'STATUS_REQUEST_CANCELED', 'PRODUCT_CORE_LANGUAGESPECIFIC', 'CERT_STORE_CTL_CONTEXT', 'STATUS_EVENTLOG_CANT_START', 'NTE_BAD_HASH', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_BOOLEAN', 'STATUS_WAS_UNLOCKED', 'SE_MACHINE_ACCOUNT_NAME', 'CREATE_PROCESS_DEBUG_EVENT', 'ERROR_CANTWRITE', 'STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT', 'CERT_NAME_UPN_TYPE', 'SERVICE_ERROR_SEVERE', 'STATUS_RESOURCEMANAGER_NOT_FOUND', 'STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED', 'STATUS_INVALID_IMAGE_WIN_64', 'STATUS_IMAGE_ALREADY_LOADED_AS_DLL', 'STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE', 'szOID_ECDSA_SHA256', 'ERROR_INVALID_PARAMETER', 'STATUS_REGISTRY_HIVE_RECOVERED', 'STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED', 'CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED', 'OBJECT_INHERIT_ACE', 'DBG_NO_STATE_CHANGE', 'STATUS_FILE_RENAMED', 'szOID_RSA_MD4RSA', 'CMSG_CTRL_ADD_ATTR_CERT', 'STATUS_NOT_CAPABLE', 'STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED', 'STATUS_NO_SAVEPOINT_WITH_OPEN_FILES', 'SW_SHOWNOACTIVATE', 'PKCS12_INCLUDE_EXTENDED_PROPERTIES', 'RPC_REQUEST_TYPE_BIND', 'NTE_INVALID_HANDLE', 'STATUS_BUS_RESET', 'STATUS_FLT_INVALID_NAME_REQUEST', 'STATUS_CLUSTER_NODE_PAUSED', 'PROCESS_DUP_HANDLE', 'STATUS_PROTOCOL_UNREACHABLE', 'ERROR_COMPRESSION_DISABLED', 'FILE_FLAG_BACKUP_SEMANTICS', 'STATUS_INTEGER_DIVIDE_BY_ZERO', 'STATUS_OBJECTID_NOT_FOUND', 'ERROR_OPEN_FAILED', 'CRYPT_CREATE_IV', 'PRODUCT_SMALLBUSINESS_SERVER_PREMIUM', 'STATUS_FVE_NOT_OS_VOLUME', 'FILE_VOLUME_QUOTAS', 'NTE_PROV_TYPE_NOT_DEF', 'CERT_STORE_PROV_PKCS7', 'STATUS_FWP_MATCH_TYPE_MISMATCH', 'REG_EXPAND_SZ', 'CRYPT_E_ATTRIBUTES_MISSING', 'ERROR_NOT_CAPABLE', 'STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER', 'CERT_FIND_SUBJECT_NAME', 'RPC_NT_NOT_CANCELLED', 'STATUS_FWP_OUT_OF_BOUNDS', 'FILE_READ_DATA', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_SID', 'SE_SHUTDOWN_NAME', 'szOID_OIWSEC_sha1', 'ERROR_FSFILTER_OP_COMPLETED_SUCCESSFULLY', 'STATUS_CTX_NO_OUTBUF', 'RPC_NT_BINDING_INCOMPLETE', 'SM_CYFRAME', 'STATUS_CTX_LICENSE_CLIENT_INVALID', 'STATUS_NO_MEDIA', 'STATUS_SOME_NOT_MAPPED', 'STATUS_FLT_NO_WAITER_FOR_REPLY', 'STATUS_BAD_NETWORK_PATH', 'ERROR_WAS_LOCKED', 'FILE_GENERIC_EXECUTE', 'ERROR_INVALID_MESSAGE', 'CERT_TRUST_HAS_ISSUANCE_CHAIN_POLICY', 'STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT', 'PRODUCT_ENTERPRISE_SERVER_CORE', 'STATUS_AMBIGUOUS_SYSTEM_DEVICE', 'szOID_OIWSEC_dsa', 'SERVICE_DISABLED', 'STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET', 'ERROR_INVALID_FLAGS', 'STATUS_CTX_WINSTATION_ACCESS_DENIED', 'STATUS_ARRAY_BOUNDS_EXCEEDED', 'CERT_COMPARE_ATTR', 'STATUS_OBJECT_TYPE_MISMATCH', 'STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED', 'STATUS_GRAPHICS_RESOURCES_NOT_RELATED', 'PRODUCT_ESSENTIALBUSINESS_SERVER_ADDLSVC', 'CWCSTORAGENAME', 'STATUS_WAS_LOCKED', 'THREAD_DIRECT_IMPERSONATION', 'CERT_ENHKEY_USAGE_PROP_ID', 'SE_PRIVILEGE_ENABLED', 'WTD_STATEACTION_AUTO_CACHE_FLUSH', 'szOID_OIWSEC_rsaSign', 'STATUS_NO_TRACKING_SERVICE', 'STATUS_SECTION_NOT_IMAGE', 'STATUS_IPSEC_DOSP_BLOCK', 'STATUS_FIRMWARE_UPDATED', 'STATUS_PROFILING_AT_LIMIT', 'STATUS_PAGE_FAULT_GUARD_PAGE', 'STATUS_FVE_FAILED_BAD_FS', 'MAX_INTERFACE_NAME_LEN', 'STATUS_HEAP_CORRUPTION', 'MS_ENH_RSA_AES_PROV_XP_A', 'STATUS_CONTROL_C_EXIT', 'INHERITED_ACE', 'STATUS_SETMARK_DETECTED', 'PRODUCT_STORAGE_ENTERPRISE_SERVER', 'STATUS_MOUNT_POINT_NOT_RESOLVED', 'STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET', 'STATUS_RESOURCE_ENUM_USER_STOP', 'ERROR_PATH_BUSY', 'ERROR_THREAD_MODE_ALREADY_BACKGROUND', 'szOID_OIWSEC_md2RSASign', 'MAX_ADAPTER_NAME', 'OS_TABLETPC', 'STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE', 'ERROR_TOO_MANY_POSTS', 'STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL', 'CONTEXT_SEGMENTS', 'STATUS_LOG_START_OF_LOG', 'ERROR_CLIENT_SERVER_PARAMETERS_INVALID', 'STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED', 'STGM_SHARE_DENY_READ', 'SECURITY_MANDATORY_HIGH_RID', 'CERT_QUERY_CONTENT_PKCS7_UNSIGNED', 'STATUS_FILE_LOCKED_WITH_ONLY_READERS', 'DBG_EXCEPTION_HANDLED', 'STATUS_ADVANCED_INSTALLER_FAILED', 'IMAGE_FILE_MACHINE_AMD64', 'ERROR_NET_OPEN_FAILED', 'CRYPT_CREATE_SALT', 'FILE_OPEN_NO_RECALL', 'RPC_NT_NO_ENTRY_NAME', 'szOID_ANSI_X942', 'JOB_OBJECT_SET_ATTRIBUTES', 'IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR', 'STATUS_WAIT_3', 'STATUS_VIRUS_INFECTED', 'STATUS_WAIT_1', 'SECURITY_MANDATORY_UNTRUSTED_RID', 'STATUS_INVALID_IMAGE_HASH', 'CERT_SHA1_HASH_PROP_ID', 'CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT', 'STATUS_TRUST_FAILURE', 'STATUS_CTX_WINSTATION_NAME_INVALID', 'ERROR_EVENT_PENDING', 'NTE_BAD_ALGID', 'STG_LAYOUT_INTERLEAVED', 'CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT', 'EVT_VARIANT_TYPE_MASK', 'ERROR_NO_MORE_MATCHES', 'RPC_NT_UUID_NO_ADDRESS', 'ERROR_TRANSACTION_NOT_ACTIVE', 'STATUS_EA_TOO_LARGE', 'STATUS_USER2USER_REQUIRED', 'STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME', 'CERT_QUERY_CONTENT_SERIALIZED_STORE', 'CERT_FIND_KEY_IDENTIFIER', 'RPC_NT_NO_MORE_ENTRIES', 'API_SET_SCHEMA_ENTRY_FLAGS_EXTENSION', 'STATUS_TIME_DIFFERENCE_AT_DC', 'CMSG_CTRL_KEY_AGREE_DECRYPT', 'IMAGE_SCN_ALIGN_2048BYTES', 'STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE', 'ERROR_THREAD_NOT_IN_PROCESS', 'PKCS12_ALWAYS_CNG_KSP', 'CERT_SYSTEM_STORE_USERS', 'OBJ_FORCE_ACCESS_CHECK', 'STATUS_ACCESS_DISABLED_BY_POLICY_PATH', 'STATUS_VOLMGR_MIRROR_NOT_SUPPORTED', 'ERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY', 'RPC_NT_INVALID_ES_ACTION', 'STATUS_PIPE_BROKEN', 'ERROR_EVT_EVENT_DEFINITION_NOT_FOUND', 'CERT_COMPARE_SIGNATURE_HASH', 'szOID_INFOSEC_sdnsConfidentiality', 'STATUS_WMI_ITEMID_NOT_FOUND', 'STATUS_FVE_TOO_SMALL', 'RPC_NT_COMM_FAILURE', 'ERROR_DIR_NOT_EMPTY', 'ERROR_PNP_RESTART_ENUMERATION', 'NTE_DECRYPTION_FAILURE', 'SM_DBCSENABLED', 'STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS', 'STATUS_QUOTA_EXCEEDED', 'DBG_CONTROL_C', 'ERROR_RXACT_STATE_CREATED', 'FC_ALLOCATE_ALL_NODES', 'STATUS_FLT_NO_DEVICE_OBJECT', 'RSA_CSP_PUBLICKEYBLOB', 'RPC_X_BAD_STUB_DATA', 'KEY_WOW64_RES', 'ERROR_TOO_MANY_MUXWAITERS', 'STATUS_PAGEFILE_QUOTA_EXCEEDED', 'RPC_C_QOS_IDENTITY_STATIC', 'ERROR_NO_VOLUME_LABEL', 'ALPC_PORFLG_WAITABLE_PORT', 'STATUS_TRANSACTION_TIMED_OUT', 'NTE_NOT_FOUND', 'ERROR_PNP_REBOOT_REQUIRED', 'STATUS_COPY_PROTECTION_FAILURE', 'X509_NDR_ENCODING', 'STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL', 'THREAD_SET_THREAD_TOKEN', 'ERROR_DRIVE_LOCKED', 'STATUS_FLT_INSTANCE_NOT_FOUND', 'CERT_FIND_HASH', 'ERROR_ACCESS_AUDIT_BY_POLICY', 'STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED', 'szOID_RSAES_OAEP', 'ERROR_BAD_COMMAND', 'AF_SNA', 'STATUS_NDIS_CLOSING', 'CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD', 'STATUS_MONITOR_INVALID_MANUFACTURE_DATE', 'STATUS_FWP_TXN_ABORTED', 'szOID_RSA_SSA_PSS', 'SE_REMOTE_SHUTDOWN_NAME', 'SM_RESERVED4', 'szOID_DSALG', 'ERROR_PAGE_FAULT_DEMAND_ZERO', 'SM_RESERVED2', 'STATUS_TRANSACTION_NOT_REQUESTED', 'SEC_WINNT_AUTH_IDENTITY_ANSI', 'STATUS_CANNOT_DELETE', 'RPC_C_QOS_CAPABILITIES_MAKE_FULLSIC', 'STATUS_MAPPED_FILE_SIZE_ZERO', 'STATUS_PLUGPLAY_QUERY_VETOED', 'PRODUCT_STORAGE_WORKGROUP_EVALUATION_SERVER', 'szOID_RSA_MD5RSA', 'MS_ENHANCED_PROV_A', 'ERROR_DIR_NOT_ROOT', 'szOID_INFOSEC_mosaicUpdatedInteg', 'CERT_TRUST_INVALID_EXTENSION', 'STATUS_CTX_CLOSE_PENDING', 'CERT_STORE_NO_CRYPT_RELEASE_FLAG', 'STATUS_FVE_VOLUME_NOT_BOUND', 'ERROR_DISK_FULL', 'ERROR_INTERRUPT_STILL_CONNECTED', 'STATUS_SMARTCARD_CARD_BLOCKED', 'STATUS_INVALID_IMAGE_FORMAT', 'STATUS_FILE_IS_OFFLINE', 'ERROR_LONGJUMP', 'CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY', 'CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY', 'STATUS_UNEXPECTED_NETWORK_ERROR', 'NTE_HMAC_NOT_SUPPORTED', 'MAILSLOT_NO_MESSAGE', 'STATUS_LOG_METADATA_INVALID', 'CMSG_HASHED', 'STATUS_GUID_SUBSTITUTION_MADE', 'STATUS_PRINT_QUEUE_FULL', 'STATUS_NDIS_INVALID_DATA', 'szOID_RSA_data', 'ERROR_ALREADY_ASSIGNED', 'ERROR_WAKE_SYSTEM_DEBUGGER', 'STATUS_EXTRANEOUS_INFORMATION', 'STATUS_TRANSACTION_OBJECT_EXPIRED', 'CERT_E_UNTRUSTEDROOT', 'STATUS_WX86_CONTINUE', 'ERROR_TRANSACTION_ALREADY_ABORTED', 'STATUS_DOMAIN_EXISTS', 'FILE_ATTRIBUTE_DEVICE', 'STATUS_DIRECTORY_NOT_EMPTY', 'NMPWAIT_NOWAIT', 'STATUS_FLT_CBDQ_DISABLED', 'OS_PERSONALTERMINALSERVER', 'ERROR_INVALID_LDT_OFFSET', 'CERT_ARCHIVED_KEY_HASH_PROP_ID', 'RPC_NT_INVALID_RPC_PROTSEQ', 'STATUS_NETWORK_ACCESS_DENIED', 'ERROR_APP_INIT_FAILURE', 'STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT', 'STATUS_PWD_TOO_SHORT', 'szOID_OIWSEC_md5RSA', 'REG_LINK', 'STATUS_BUFFER_OVERFLOW', 'STATUS_LOG_SECTOR_INVALID', 'STATUS_CALLBACK_POP_STACK', 'SERVICE_TRIGGER_TYPE_NETWORK_ENDPOINT', 'FILE_ATTRIBUTE_ENCRYPTED', 'STATUS_FVE_FAILED_AUTHENTICATION', 'ERROR_LOCKED', 'CERT_FRIENDLY_NAME_PROP_ID', 'STATUS_PIPE_NOT_AVAILABLE', 'IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT', 'STATUS_NO_LDT', 'CLUSAPI_NO_ACCESS', 'STATUS_TRANSACTION_RESPONDED', 'CMSG_HASH_ALGORITHM_PARAM', 'STATUS_GRAPHICS_DDCCI_INVALID_DATA', 'RPC_NT_ALREADY_REGISTERED', 'STATUS_NDIS_DOT11_POWER_STATE_INVALID', 'ERROR_OPERATION_ABORTED', 'STATUS_REPARSE_POINT_NOT_RESOLVED', 'SERVICE_ACTIVE', 'STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED', 'STATUS_REMOTE_RESOURCES', 'IMAGE_REL_BASED_RESERVED', 'OBJ_OPENIF', 'STATUS_CHILD_MUST_BE_VOLATILE', 'STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS', 'ERROR_IO_INCOMPLETE', 'CERT_QUERY_FORMAT_BASE64_ENCODED', 'STATUS_END_OF_MEDIA', 'OS_PROFESSIONAL', 'ERROR_FILE_NOT_FOUND', 'STATUS_VDM_HARD_ERROR', 'SERVICE_WIN32_OWN_PROCESS', 'ERROR_UNWIND_CONSOLIDATE', 'ERROR_INVALID_EVENT_COUNT', 'STATUS_MEMORY_NOT_ALLOCATED', 'ERROR_ILLEGAL_FLOAT_CONTEXT', 'BIND_IF_SYNTAX_NDR32', 'ERROR_CRC', 'SM_MOUSEPRESENT', 'STATUS_PROCESS_CLONED', 'ACCESS_ALLOWED_OBJECT_ACE_TYPE', 'ERROR_THREAD_1_INACTIVE', 'CERT_STORE_PROV_REG', 'ERROR_SERVER_SID_MISMATCH', 'STATUS_NO_IP_ADDRESSES', 'ERROR_DIRECTORY', 'CERT_QUERY_CONTENT_FLAG_PFX', 'CERT_AUTO_ENROLL_PROP_ID', 'STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET', 'ERROR_ABANDONED_WAIT_63', 'STATUS_FILE_NOT_ENCRYPTED', 'ERROR_VOLSNAP_PREPARE_HIBERNATE', 'STATUS_PORT_ALREADY_HAS_COMPLETION_LIST', 'SERVICE_CONTROL_STOP', 'STATUS_RESOURCE_NAME_NOT_FOUND', 'STATUS_DS_NO_MORE_RIDS', 'DELETE', 'MS_STRONG_PROV_A', 'STATUS_TRANSACTION_PROPAGATION_FAILED', 'SE_DEBUG_NAME', 'ERROR_FILE_TOO_LARGE', 'STATUS_SYNCHRONIZATION_REQUIRED', 'IMAGE_FILE_32BIT_MACHINE', 'STATUS_INVALID_HANDLE', 'STATUS_ALREADY_REGISTERED', 'STATUS_NETWORK_UNREACHABLE', 'STATUS_DS_INIT_FAILURE', 'CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG', 'STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE', 'STATUS_ROLLBACK_TIMER_EXPIRED', 'SM_CXVSCROLL', 'SE_SACL_AUTO_INHERIT_REQ', 'ERROR_NOT_OWNER', 'STATUS_REMOTE_NOT_LISTENING', 'PROFILE_KERNEL', 'STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS', 'STATUS_BEGINNING_OF_MEDIA', 'STATUS_BEYOND_VDL', 'IMAGE_FILE_UP_SYSTEM_ONLY', 'EPT_NT_CANT_PERFORM_OP', 'SM_SLOWMACHINE', 'ERROR_DRIVERS_LEAKING_LOCKED_PAGES', 'E_INVALIDARG', 'STATUS_CLUSTER_NETINTERFACE_NOT_FOUND', 'STATUS_NO_RECOVERY_POLICY', 'SECTION_MAP_WRITE', 'STATUS_LOGON_SERVER_CONFLICT', 'STATUS_WAIT_2', 'STATUS_ENLISTMENT_NOT_FOUND', 'STATUS_DRIVER_PROCESS_TERMINATED', 'ERROR_JOIN_TO_JOIN', 'PKCS12_EXPORT_RESERVED_MASK', 'PRODUCT_PROFESSIONAL_E', 'SE_DACL_PRESENT', 'PRODUCT_PROFESSIONAL_N', 'STATUS_USER_APC', 'OS_MEORGREATER', 'STATUS_NET_WRITE_FAULT', 'STATUS_REINITIALIZATION_NEEDED', 'ERROR_INVALID_ACE_CONDITION', 'ERROR_PWD_TOO_RECENT', 'ERROR_PORT_MESSAGE_TOO_LONG', 'STATUS_GRAPHICS_NO_VIDEO_MEMORY', 'ERROR_UNWIND', 'ERROR_EXCL_SEM_ALREADY_OWNED', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_INVALID', 'CERT_E_WRONG_USAGE', 'STATUS_CALLBACK_RETURNED_PRI_BACK', 'DUPLICATE_SAME_ACCESS', 'STATUS_FLOAT_STACK_CHECK', 'STATUS_NOT_LOGON_PROCESS', 'STATUS_INVALID_SYSTEM_SERVICE', 'STATUS_UNSUPPORTED_PREAUTH', 'CERT_FIND_ANY', 'szOID_RSA', 'STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER', 'CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID', 'IMAGE_DIRECTORY_ENTRY_EXPORT', 'STATUS_GRAPHICS_TRY_AGAIN_LATER', 'STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET', 'STATUS_IO_DEVICE_ERROR', 'CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED', 'STATUS_ACPI_INVALID_OBJTYPE', 'STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH', 'ALPC_MSGFLG_WAIT_USER_MODE', 'STATUS_DEBUGGER_INACTIVE', 'ERROR_JOIN_TO_SUBST', 'STATUS_MORE_PROCESSING_REQUIRED', 'STATUS_CTL_FILE_NOT_SUPPORTED', 'PIPE_TYPE_BYTE', 'PKCS_7_ASN_ENCODING', 'STATUS_NO_INHERITANCE', 'STATUS_OBJECT_NAME_NOT_FOUND', 'PROV_RSA_SIG', 'SE_SYSTEM_PROFILE_NAME', 'STATUS_FWP_TXN_IN_PROGRESS', 'IMAGE_SCN_TYPE_OVER', 'STATUS_ACCESS_DISABLED_BY_POLICY_OTHER', 'ERROR_VERSION_PARSE_ERROR', 'STATUS_SERVER_HAS_OPEN_HANDLES', 'ERROR_DEBUG_ATTACH_FAILED', 'STATUS_ABANDONED_WAIT_0', 'CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE', 'STATUS_CTX_WINSTATION_BUSY', 'IMAGE_SCN_MEM_16BIT', 'ERROR_BIOS_FAILED_TO_CONNECT_INTERRUPT', 'STATUS_TOO_MANY_SIDS', 'ERROR_FT_WRITE_RECOVERY', 'CERT_FIND_ISSUER_ATTR', 'AF_UNIX', 'STATUS_SHUTDOWN_IN_PROGRESS', 'RPC_NT_GROUP_MEMBER_NOT_FOUND', 'ERROR_DEVICE_ENUMERATION_ERROR', 'CERT_INFO_SIGNATURE_ALGORITHM_FLAG', 'STATUS_FVE_FS_MOUNTED', 'SERVICE_FILE_SYSTEM_DRIVER', 'TOKEN_DUPLICATE', 'CERT_COMPARE_CTL_USAGE', 'CRYPT_ACQUIRE_USE_PROV_INFO_FLAG', 'STATUS_EVENT_DONE', 'STATUS_NDIS_INVALID_LENGTH', 'STATUS_REMOTE_DISCONNECT', 'CERT_SYSTEM_STORE_CURRENT_SERVICE_ID', 'STATUS_BAD_INITIAL_STACK', 'ERROR_INVALID_MINALLOCSIZE', 'STATUS_CTX_WD_NOT_FOUND', 'STATUS_ALERTED', 'CERT_INFO_SUBJECT_UNIQUE_ID_FLAG', 'STATUS_CSS_KEY_NOT_ESTABLISHED', 'ERROR_EVT_VERSION_TOO_NEW', 'STATUS_FWP_EM_NOT_SUPPORTED', 'STANDARD_RIGHTS_EXECUTE', 'MEM_ROTATE', 'ERROR_FILE_CHECKED_OUT', 'STATUS_LOG_INVALID_RANGE', 'SM_CYSIZEFRAME', 'PRODUCT_HOME_SERVER', 'ERROR_SIGNAL_REFUSED', 'STATUS_LOG_MULTIPLEXED', 'ERROR_REPLY_MESSAGE_MISMATCH', 'STATUS_CLUSTER_INVALID_NODE', 'ERROR_PNP_IRQ_TRANSLATION_FAILED', 'ERROR_ALREADY_WIN32', 'ERROR_NO_MORE_SEARCH_HANDLES', 'STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR', 'ALPC_MESSAGE_HANDLE_ATTRIBUTE', 'VER_NT_WORKSTATION', 'ERROR_SYSTEM_IMAGE_BAD_SIGNATURE', 'STATUS_MUTANT_LIMIT_EXCEEDED', 'szOID_ECDSA_SPECIFIED', 'STATUS_INVALID_IMPORT_OF_NON_DLL', 'PKCS12_ALLOW_OVERWRITE_KEY', 'STATUS_ACCOUNT_LOCKED_OUT', 'STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE', 'ACE_INHERITED_OBJECT_TYPE_PRESENT', 'STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE', 'PIPE_TYPE_MESSAGE', 'STATUS_FLOAT_MULTIPLE_TRAPS', 'CRYPT_E_INVALID_INDEX', 'ERROR_BUSY_DRIVE', 'STATUS_NDIS_GROUP_ADDRESS_IN_USE', 'AF_BAN', 'STATUS_NO_SUCH_LOGON_SESSION', 'STATUS_VIRTUAL_CIRCUIT_CLOSED', 'STATUS_CTX_CONSOLE_DISCONNECT', 'OS_SERVERADMINUI', 'szOID_RSA_signedData', 'KEY_NOTIFY', 'STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT', 'STATUS_FVE_AUTH_INVALID_APPLICATION', 'ERROR_HIBERNATION_FAILURE', 'CMSG_SIGNER_CERT_INFO_PARAM', 'ERROR_PROCESS_MODE_ALREADY_BACKGROUND', 'ALPC_MSGFLG_WOW64_CALL', 'OWNER_SECURITY_INFORMATION', 'TRUST_E_ACTION_UNKNOWN', 'SC_MANAGER_MODIFY_BOOT_CONFIG', 'ERROR_RECEIVE_PARTIAL', 'CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL', 'STATUS_ALLOCATE_BUCKET', 'SM_REMOTECONTROL', 'PRODUCT_ENTERPRISE_N', 'ERROR_REPARSE_OBJECT', 'ERROR_AUDIT_FAILED', 'FILE_FLAG_FIRST_PIPE_INSTANCE', 'ERROR_EVT_FILTER_NOTELTSET', 'STATUS_GUARD_PAGE_VIOLATION', 'PRODUCT_ENTERPRISE_E', 'STATUS_FWP_WRONG_SESSION', 'CREATE_ALWAYS', 'CMSG_CTRL_VERIFY_HASH', 'ERROR_SCOPE_NOT_FOUND', 'PROCESS_SET_QUOTA', 'RPC_NT_UUID_LOCAL_ONLY', 'RPC_NT_INVALID_ENDPOINT_FORMAT', 'SE_GROUP_RESOURCE', 'ERROR_MOUNT_POINT_NOT_RESOLVED', 'ERROR_INVALID_EA_HANDLE', 'STATUS_KDC_INVALID_REQUEST', 'PROCESS_MODE_BACKGROUND_BEGIN', 'READ_CONTROL', 'EXCEPTION_FLT_OVERFLOW', 'ERROR_INVALID_SEGMENT_NUMBER', 'STATUS_PIPE_DISCONNECTED', 'COM_EXECUTE_LOCAL', 'TXFS_MINIVERSION_COMMITTED_VIEW', 'FILE_CREATE_TREE_CONNECTION', 'SERVICE_TRIGGER_TYPE_IP_ADDRESS_AVAILABILITY', 'STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED', 'STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST', 'STATUS_MCA_EXCEPTION', 'CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT', 'CERT_TRUST_HAS_CRL_VALIDITY_EXTENDED', 'ERROR_INVALID_STACKSEG', 'STATUS_DS_CANT_START', 'OS_WIN2000ADVSERVER', 'FILE_WRITE_THROUGH', 'STATUS_LOST_WRITEBEHIND_DATA', 'STATUS_DECRYPTION_FAILED', 'SUCCESSFUL_ACCESS_ACE_FLAG', 'STATUS_SEGMENT_NOTIFICATION', 'STATUS_CLUSTER_JOIN_IN_PROGRESS', 'STATUS_ADDRESS_NOT_ASSOCIATED', 'ERROR_PRINTQ_FULL', 'CERT_QUERY_FORMAT_BINARY', 'ERROR_BAD_CURRENT_DIRECTORY', 'ERROR_GEN_FAILURE', 'STATUS_PROFILING_NOT_STARTED', 'MUTANT_ALL_ACCESS', 'STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY', 'STATUS_CS_ENCRYPTION_FILE_NOT_CSE', 'ERROR_PIPE_CONNECTED', 'CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES', 'SERVICE_ERROR_CRITICAL', 'ERROR_VERIFIER_STOP', 'STATUS_KEY_DELETED', 'NMPWAIT_USE_DEFAULT_WAIT', 'PROV_MS_EXCHANGE', 'STATUS_ACPI_RS_ACCESS', 'CERT_NAME_ATTR_TYPE', 'ERROR_INVALID_PLUGPLAY_DEVICE_PATH', 'SE_SACL_AUTO_INHERITED', 'STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH', 'STATUS_NONE_MAPPED', 'DIGSIG_E_ENCODE', 'STATUS_GRAPHICS_ALLOCATION_INVALID', 'MEM_RESERVE', 'IMAGE_DLLCHARACTERISTICS_WDM_DRIVER', 'STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN', 'ERROR_LOGON_SERVER_CONFLICT', 'CERT_TRUST_INVALID_BASIC_CONSTRAINTS', 'SERVICE_CONTINUE_PENDING', 'IMAGE_FILE_MACHINE_CEE', 'IMAGE_FILE_MACHINE_CEF', 'STATUS_DS_UNAVAILABLE', 'ERROR_INVALID_LDT_SIZE', 'ERROR_NOT_SUPPORTED', 'PROCESS_SET_SESSIONID', 'RPC_NT_FP_OVERFLOW', 'STATUS_UNSUPPORTED_COMPRESSION', 'ERROR_TOO_MANY_SEM_REQUESTS', 'STATUS_HIBERNATED', 'SE_GROUP_DEFAULTED', 'ERROR_ACCESS_DENIED', 'FILE_DELETE_CHILD', 'CMSG_CRL_PARAM', 'CMSG_SIGNER_HASH_ALGORITHM_PARAM', 'STATUS_EA_LIST_INCONSISTENT', 'STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER', 'STANDARD_RIGHTS_ALL', 'CERT_STORE_ADD_ALWAYS', 'ERROR_SERVICE_NOTIFICATION', 'REG_DWORD_LITTLE_ENDIAN', 'STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED', 'STATUS_SAM_NEED_BOOTKEY_PASSWORD', 'TRUST_E_NOSIGNATURE', 'IMAGE_REL_BASED_MACHINE_SPECIFIC_9', 'IMAGE_REL_BASED_MACHINE_SPECIFIC_8', 'CERT_QUERY_CONTENT_PFX_AND_LOAD', 'ERROR_ERRORS_ENCOUNTERED', 'IMAGE_REL_BASED_MACHINE_SPECIFIC_5', 'AF_CLUSTER', 'SERVICE_USER_DEFINED_CONTROL', 'FILE_SHARE_DELETE', 'FILE_FLAG_OVERLAPPED', 'STATUS_INVALID_BUFFER_SIZE', 'SYSTEM_PROCESS_TRUST_LABEL_VALID_MASK', 'CRYPT_E_NOT_FOUND', 'STATUS_INTERRUPT_STILL_CONNECTED', 'PKCS12_NO_PERSIST_KEY', 'RPC_NT_SEND_INCOMPLETE', 'CERT_NAME_SIMPLE_DISPLAY_TYPE', 'STATUS_POLICY_OBJECT_NOT_FOUND', 'CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR', 'ERROR_CANNOT_BREAK_OPLOCK', 'STATUS_NO_MORE_FILES', 'FILE_OPENED', 'STATUS_THREAD_ALREADY_IN_TASK', 'CERT_STORE_PROV_SYSTEM_A', 'STATUS_WAKE_SYSTEM_DEBUGGER', 'STATUS_FILE_FORCED_CLOSED', 'SM_MIDEASTENABLED', 'STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT', 'SE_DACL_PROTECTED', 'FILE_SHARE_WRITE', 'STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS', 'ERROR_LOCK_FAILED', 'CMSG_CTRL_DEL_CERT', 'CMSG_SIGNER_AUTH_ATTR_PARAM', 'ERROR_IMAGE_MACHINE_TYPE_MISMATCH', 'E_FAIL', 'STATUS_CRM_PROTOCOL_NOT_FOUND', 'CMSG_CTRL_KEY_TRANS_DECRYPT', 'STATUS_GRAPHICS_COPP_NOT_SUPPORTED', 'RPC_NT_NO_CALL_ACTIVE', 'RPC_NT_NO_PRINC_NAME', 'EXCEPTION_NONCONTINUABLE', 'ERROR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY', 'STATUS_MUI_INVALID_FILE', 'STATUS_FLT_DISALLOW_FAST_IO', 'SE_SECURITY_NAME', 'CERT_FIND_SIGNATURE_HASH', 'STATUS_SMARTCARD_SUBSYSTEM_FAILURE', 'STATUS_INVALID_OWNER', 'STATUS_FLT_ALREADY_ENLISTED', 'CRYPT_E_HASH_VALUE', 'STATUS_CTX_CLIENT_QUERY_TIMEOUT', 'FAX_JOB_QUERY', 'IMAGE_FILE_MACHINE_AM33', 'MAXLEN_PHYSADDR', 'WRITE_DAC', 'szOID_PKCS', 'STATUS_OBJECT_PATH_NOT_FOUND', 'ERROR_PROCESS_IN_JOB', 'IMAGE_SCN_MEM_EXECUTE', 'PROV_EC_ECNRA_FULL', 'szOID_INFOSEC_SuiteAIntegrity', 'STATUS_SXS_PROCESS_TERMINATION_REQUESTED', 'STATUS_LOCAL_DISCONNECT', 'STATUS_DEVICE_FEATURE_NOT_SUPPORTED', 'FILE_ATTRIBUTE_COMPRESSED', 'CERT_COMPARE_PUBLIC_KEY', 'AF_NETBIOS', 'FILE_SUPERSEDE', 'IMAGE_NUMBEROF_DIRECTORY_ENTRIES', 'STATUS_TOO_MANY_NODES', 'szOID_RSA_messageDigest', 'ERROR_IS_SUBST_TARGET', 'SE_PROF_SINGLE_PROCESS_NAME', 'STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION', 'STATUS_CLUSTER_NODE_DOWN', 'STATUS_POWER_STATE_INVALID', 'SERVICE_ADAPTER', 'TIMER_MODIFY_STATE', 'STATUS_NDIS_INTERFACE_NOT_FOUND', 'STATUS_CSS_SCRAMBLED_SECTOR', 'ERROR_DISCARDED', 'ERROR_OUTOFMEMORY', 'PRODUCT_STANDARD_SERVER_CORE_V', 'szOID_RSA_MD2RSA', 'STATUS_NO_TOKEN', 'szOID_RSA_encryptedData', 'STATUS_FWP_NULL_POINTER', 'STATUS_NO_LINK_TRACKING_IN_TRANSACTION', 'CMSG_CTRL_ADD_SIGNER', 'OS_WIN2000ORGREATER', 'WRITE_OWNER', 'FILE_MAXIMUM_DISPOSITION', 'ERROR_INFLOOP_IN_RELOC_CHAIN', 'SW_MAX', 'STATUS_INVALID_PORT_ATTRIBUTES', 'DBG_CONTINUE', 'CMSG_CONTENTS_OCTETS_FLAG', 'X509_UNICODE_NAME_VALUE', 'ERROR_BAD_PATHNAME', 'SM_CYDRAG', 'TH32CS_SNAPALL', 'STATUS_NO_USER_SESSION_KEY', 'ERROR_IO_PRIVILEGE_FAILED', 'STATUS_WMI_ALREADY_ENABLED', 'STATUS_PREDEFINED_HANDLE', 'FILE_CREATE', 'ALPC_MESSAGE_VIEW_ATTRIBUTE', 'CERT_E_REVOCATION_FAILURE', 'STATUS_GRAPHICS_NO_ACTIVE_VIDPN', 'ERROR_EXE_MARKED_INVALID', 'PORT_CONNECT', 'STATUS_STREAM_MINIVERSION_NOT_VALID', 'FILE_SUPPORTS_HARD_LINKS', 'STATUS_SMARTCARD_CERT_REVOKED', 'FILE_READ_EA', 'STATUS_FWP_TOO_MANY_CALLOUTS', 'COMPRESSION_FORMAT_XPRESS_HUFF', 'STATUS_PWD_HISTORY_CONFLICT', 'STATUS_COMPRESSION_DISABLED', 'ERROR_PAGEFILE_QUOTA_EXCEEDED', 'ERROR_MCA_OCCURED', 'WTD_CHOICE_CERT', 'IMAGE_FILE_MACHINE_R10000', 'SERVICE_CHANGE_CONFIG', 'OBJECT_TYPE_CREATE', 'ERROR_NOT_SAFE_MODE_DRIVER', 'CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG', 'REG_QWORD_LITTLE_ENDIAN', 'SERVICE_DRIVER', 'IMAGE_SCN_ALIGN_8BYTES', 'TRUST_E_BAD_DIGEST', 'RRF_ZEROONFAILURE', 'ERROR_INVALID_QUOTA_LOWER', 'USAGE_MATCH_TYPE_OR', 'ERROR_SEM_NOT_FOUND', 'STATUS_ACPI_INVALID_TARGETTYPE', 'THREAD_ALL_ACCESS', 'szOID_OIWDIR_CRPT', 'STATUS_SXS_ACTIVATION_CONTEXT_DISABLED', 'JOB_OBJECT_QUERY', 'ERROR_RXACT_COMMIT_NECESSARY', 'PRODUCT_ULTIMATE_N', 'STATUS_ACPI_POWER_REQUEST_FAILED', 'STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY', 'PIPE_SERVER_END', 'STATUS_INVALID_PRIMARY_GROUP', 'STATUS_TIMER_RESOLUTION_NOT_SET', 'STATUS_DISK_CORRUPT_ERROR', 'E_NOINTERFACE', 'STATUS_FILE_TOO_LARGE', 'STATUS_CONNECTION_COUNT_LIMIT', 'STATUS_CALLBACK_BYPASS', 'STATUS_BAD_STACK', 'STATUS_FLOATED_SECTION', 'STATUS_CANNOT_BREAK_OPLOCK', 'STATUS_CTX_GRAPHICS_INVALID', 'STATUS_DELAY_LOAD_FAILED', 'CERT_STORE_SET_LOCALIZED_NAME_FLAG', 'TH32CS_SNAPTHREAD', 'PROV_INTEL_SEC', 'PROCESS_SET_INFORMATION', 'STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS', 'TH32CS_SNAPHEAPLIST', 'PRODUCT_STANDARD_SERVER_SOLUTIONS_CORE', 'ERROR_INVALID_PASSWORD', 'CONTEXT_ALL', 'szOID_OIWSEC_shaRSA', 'STATUS_FWP_INVALID_PARAMETER', 'SM_CXICON', 'SM_CMONITORS', 'NTE_PERM', 'STATUS_NO_UNICODE_TRANSLATION', 'LPC_REQUEST', 'CERT_XML_NAME_STR', 'DBG_RIPEXCEPTION', 'IMAGE_SCN_ALIGN_8192BYTES', 'PROCESS_ALL_ACCESS', 'STATUS_CARDBUS_NOT_SUPPORTED', 'DETACHED_PROCESS', 'STGM_FAILIFTHERE', 'STATUS_DRIVER_FAILED_PRIOR_UNLOAD', 'OS_WOW6432', 'RPC_NT_PROTOCOL_ERROR', 'STATUS_PROTOCOL_NOT_SUPPORTED', 'STATUS_LUIDS_EXHAUSTED', 'RPC_NT_INVALID_VERS_OPTION', 'ERROR_TOO_MANY_SEMAPHORES', 'SW_MINIMIZE', 'NTE_NO_MORE_ITEMS', 'CRYPT_E_FILE_ERROR', 'CERT_BACKED_UP_PROP_ID', 'STATUS_FWP_ALREADY_EXISTS', 'PRODUCT_CORE', 'CERT_TRUST_HAS_NAME_MATCH_ISSUER', 'NTE_SYS_ERR', 'CERT_SIMPLE_NAME_STR', 'ERROR_EVT_INVALID_PUBLISHER_NAME', 'STATUS_LOG_BLOCK_VERSION', 'STATUS_FT_ORPHANING', 'CMSG_CERT_COUNT_PARAM', 'CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG', 'ERROR_NOTIFY_ENUM_DIR', 'CRYPT_SF', 'STATUS_GRAPHICS_INVALID_PIXELFORMAT', 'ERROR_DBG_RIPEXCEPTION', 'ERROR_IMAGE_SUBSYSTEM_NOT_PRESENT', 'IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT', 'PIPE_READMODE_MESSAGE', 'STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM', 'SE_GROUP_LOGON_ID', 'ERROR_BAD_COMPRESSION_BUFFER', 'STATUS_REGISTRY_IO_FAILED', 'STATUS_FOUND_OUT_OF_SCOPE', 'STATUS_DLL_INIT_FAILED', 'REG_RESOURCE_LIST', 'STATUS_INVALID_ACL', 'STATUS_ACPI_INVALID_DATA', 'ERROR_INVALID_LIST_FORMAT', 'ERROR_PAGE_FAULT_PAGING_FILE', 'STATUS_NDIS_LOW_POWER_STATE', 'ERROR_EVT_MALFORMED_XML_TEXT', 'STATUS_IP_ADDRESS_CONFLICT2', 'IMAGE_SCN_TYPE_REG', 'COM_ACTIVATE_REMOTE', 'STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING', 'CERT_EFS_PROP_ID', 'STATUS_SMI_PRIMITIVE_INSTALLER_FAILED', 'CMSG_SIGNED', 'CERT_E_UNTRUSTEDTESTROOT', 'SEC_FILE', 'IMAGE_FILE_MACHINE_SH3DSP', 'SECURITY_MANDATORY_PROTECTED_PROCESS_RID', 'ERROR_SHARING_PAUSED', 'STATUS_CURRENT_DOMAIN_NOT_ALLOWED', 'RRF_RT_QWORD', 'TOKEN_MANDATORY_POLICY_VALID_MASK', 'FILE_NON_DIRECTORY_FILE', 'COMPRESSION_FORMAT_DEFAULT', 'UNLOAD_DLL_DEBUG_EVENT', 'SEC_LARGE_PAGES', 'PRODUCT_STARTER', 'STATUS_KDC_UNKNOWN_ETYPE', 'NTE_TOKEN_KEYSET_STORAGE_FULL', 'STATUS_APC_RETURNED_WHILE_IMPERSONATING', 'EXCEPTION_FLT_DIVIDE_BY_ZERO', 'FILE_SEQUENTIAL_WRITE_ONCE', 'EXCEPTION_INT_OVERFLOW', 'JOB_OBJECT_SET_SECURITY_ATTRIBUTES', 'STATUS_SMARTCARD_WRONG_PIN', 'szOID_ECDSA_SHA512', 'szOID_PKCS_12', 'szOID_PKCS_10', 'STATUS_SMARTCARD_SILENT_CONTEXT', 'PROV_SSL', 'SERVICE_TRIGGER_TYPE_DEVICE_INTERFACE_ARRIVAL', 'CERT_QUERY_CONTENT_FLAG_ALL', 'WTD_CHOICE_SIGNER', 'STATUS_CTX_RESPONSE_ERROR', 'IMAGE_FILE_LINE_NUMS_STRIPPED', 'STATUS_INVALID_DEVICE_OBJECT_PARAMETER', 'STATUS_UNEXPECTED_MM_MAP_ERROR', 'ERROR_ROWSNOTRELEASED', 'ERROR_FILE_EXISTS', 'STATUS_CANCELLED', 'STATUS_LOG_SECTOR_PARITY_INVALID', 'IMAGE_FILE_MACHINE_SH3E', 'FILE_NO_INTERMEDIATE_BUFFERING', 'STATUS_COMMITMENT_MINIMUM', 'CERT_QUERY_CONTENT_CRL', 'IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE', 'IMAGE_SCN_ALIGN_2BYTES', 'DRIVE_CDROM', 'EVENTLOG_FORWARDS_READ', 'DRIVE_UNKNOWN', 'STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION', 'STATUS_CLEANER_CARTRIDGE_INSTALLED', 'FILE_PERSISTENT_ACLS', 'STATUS_CANT_DISABLE_MANDATORY', 'CERT_FIND_MD5_HASH', 'CMSG_SIGNER_CERT_ID_PARAM', 'STATUS_ACCESS_VIOLATION', 'STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE', 'STATUS_SERVICE_NOTIFICATION', 'STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS', 'CERT_TRUST_IS_NOT_SIGNATURE_VALID', 'CERT_QUERY_CONTENT_PKCS10', 'STATUS_FWP_INVALID_WEIGHT', 'STATUS_NOTIFY_CLEANUP', 'STATUS_FWP_KM_CLIENTS_ONLY', 'PAGE_GUARD', 'STATUS_WX86_INTERNAL_ERROR', 'STATUS_UNABLE_TO_LOCK_MEDIA', 'LPC_DATAGRAM', 'DEBUG_ONLY_THIS_PROCESS', 'AF_FIREFOX', 'STATUS_MCA_OCCURED', 'ERROR_PLUGPLAY_QUERY_VETOED', 'ERROR_DATA_NOT_ACCEPTED', 'ERROR_INVALID_BLOCK', 'STATUS_INVALID_PLUGPLAY_DEVICE_PATH', 'RPC_NT_NO_PROTSEQS', 'STATUS_NO_SUCH_MEMBER', 'SM_SECURE', 'RPC_NT_WRONG_PIPE_VERSION', 'STATUS_OBJECT_PATH_SYNTAX_BAD', 'ERROR_CONTROL_C_EXIT', 'STATUS_REDIRECTOR_NOT_STARTED', 'RPC_NT_INTERNAL_ERROR', 'EXIT_PROCESS_DEBUG_EVENT', 'TRUST_E_PROVIDER_UNKNOWN', 'STATUS_CTX_MODEM_INF_NOT_FOUND', 'CREATE_PRESERVE_CODE_AUTHZ_LEVEL', 'PIPE_ACCESS_OUTBOUND', 'KEY_READ', 'CERT_FIND_ISSUER_OF', 'szOID_INFOSEC_mosaicConfidentiality', 'CERT_STORE_PROV_FILENAME_A', 'MS_DEF_PROV', 'STATUS_SYMLINK_CLASS_DISABLED', 'SYSTEM_AUDIT_CALLBACK_ACE_TYPE', 'IMAGE_DIRECTORY_ENTRY_ARCHITECTURE', 'SYSTEM_SCOPED_POLICY_ID_ACE_TYPE', 'FILE_ATTRIBUTE_SPARSE_FILE', 'STATUS_CANT_ACCESS_DOMAIN_INFO', 'CERT_STORE_PROV_FILENAME_W', 'STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER', 'ERROR_SUBST_TO_SUBST', 'SE_CREATE_TOKEN_NAME', 'FILE_ATTRIBUTE_OFFLINE', 'STATUS_DS_NO_ATTRIBUTE_OR_VALUE', 'STATUS_INVALID_SIGNATURE', 'STGM_SHARE_DENY_WRITE', 'ERROR_CHECKING_FILE_SYSTEM', 'STATUS_REVOCATION_OFFLINE_C', 'ERROR_FLOAT_MULTIPLE_TRAPS', 'RPC_NT_NAME_SERVICE_UNAVAILABLE', 'STATUS_DS_GROUP_CONVERSION_ERROR', 'ERROR_PATH_NOT_FOUND', 'PRODUCT_HOME_PREMIUM_SERVER', 'SE_PRIVILEGE_USED_FOR_ACCESS', 'ERROR_EVT_UNRESOLVED_PARAMETER_INSERT', 'STD_OUTPUT_HANDLE', 'AF_INET6', 'COMPRESSION_ENGINE_HIBER', 'STATUS_FLT_DO_NOT_ATTACH', 'TIMER_ALL_ACCESS', 'STATUS_WRONG_CREDENTIAL_HANDLE', 'ERROR_RANGE_NOT_FOUND', 'STATUS_TRANSACTION_REQUEST_NOT_VALID', 'STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT', 'CRYPT_NO_SALT', 'ERROR_NOT_LOCKED', 'STATUS_LOG_FULL', 'STATUS_THREADPOOL_HANDLE_EXCEPTION', 'STATUS_TXF_DIR_NOT_EMPTY', 'STATUS_LOG_INCONSISTENT_SECURITY', 'LPC_EXCEPTION', 'STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME', 'PAGE_READONLY', 'AF_ATM', 'EXCEPTION_IN_PAGE_ERROR', 'STARTF_USEFILLATTRIBUTE', 'STATUS_CONNECTION_RESET', 'STATUS_DRIVER_ORDINAL_NOT_FOUND', 'STARTF_USECOUNTCHARS', 'IMAGE_SCN_LNK_INFO', 'STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE', 'STATUS_DOMAIN_CTRLR_CONFIG_ERROR', 'COM_EXECUTE', 'STATUS_DELETE_PENDING', 'STATUS_INVALID_SECURITY_DESCR', 'FILE_SUPPORTS_REMOTE_STORAGE', 'CMSG_CTRL_MAIL_LIST_DECRYPT', 'SE_SYSTEM_ENVIRONMENT_NAME', 'STATUS_LPC_REPLY_LOST', 'NTE_FAIL', 'STATUS_FLT_CONTEXT_ALREADY_LINKED', 'FAX_JOB_SUBMIT', 'CERT_COMPARE_KEY_IDENTIFIER', 'STATUS_REDIRECTOR_HAS_OPEN_HANDLES', 'STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND', 'SERVICE_ERROR_NORMAL', 'CMSG_CTRL_VERIFY_SIGNATURE_EX', 'SM_CYMINIMIZED', 'STATUS_HMAC_NOT_SUPPORTED', 'PRODUCT_STORAGE_STANDARD_SERVER', 'STATUS_DRIVER_INTERNAL_ERROR', 'STATUS_UNEXPECTED_MM_CREATE_ERR', 'HKEY_LOCAL_MACHINE', 'STATUS_VOLUME_DIRTY', 'STATUS_NO_PAGEFILE', 'RPC_NT_SS_CHAR_TRANS_OPEN_FAIL', 'STATUS_FLT_CONTEXT_ALREADY_DEFINED', 'STATUS_INSTRUCTION_MISALIGNMENT', 'STATUS_INVALID_ACCOUNT_NAME', 'szOID_RSA_digestedData', 'STATUS_CANT_ENABLE_DENY_ONLY', 'ERROR_ILLEGAL_DLL_RELOCATION', 'MEM_PHYSICAL', 'szOID_DS', 'IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY', 'ERROR_NOT_JOINED', 'SM_CYSIZE', 'WTD_CHOICE_BLOB', 'STATUS_PRINT_CANCELLED', 'CRYPT_FORCE_KEY_PROTECTION_HIGH', 'CERT_COMPARE_MD5_HASH', 'OS_WIN2000SERVER', 'STATUS_SXS_SETTING_NOT_REGISTERED', 'STATUS_ACPI_ASSERT_FAILED', 'PRODUCT_DATACENTER_SERVER_CORE', 'STATUS_ALIAS_EXISTS', 'szOID_ECC_CURVE_P256', 'STATUS_FWP_INVALID_RANGE', 'STATUS_FORMS_AUTH_REQUIRED', 'STATUS_LOG_CONTAINER_WRITE_FAILED', 'MAXLEN_IFDESCR', 'CERT_COMPARE_EXISTING', 'RRF_RT_REG_BINARY', 'VER_NT_SERVER', 'AF_DATAKIT', 'STATUS_SMARTCARD_LOGON_REQUIRED', 'ERROR_DBG_COMMAND_EXCEPTION', 'STATUS_XML_ENCODING_MISMATCH', 'NTE_TEMPORARY_PROFILE', 'EXCEPTION_PRIV_INSTRUCTION', 'STATUS_FWP_CALLOUT_NOT_FOUND', 'RPC_NT_WRONG_STUB_VERSION', 'KEY_WRITE', 'szOID_DH_SINGLE_PASS_STDDH_SHA384_KDF', 'SERVICE_ACCEPT_TRIGGEREVENT', 'ERROR_MARSHALL_OVERFLOW', 'SERVICE_STOPPED', 'SERVICE_QUERY_STATUS', 'WTD_STATEACTION_VERIFY', 'STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED', 'ERROR_PROFILING_AT_LIMIT', 'STATUS_DRIVER_CANCEL_TIMEOUT', 'OBJ_PERMANENT', 'CERT_INFO_SUBJECT_FLAG', 'PRODUCT_STORAGE_ENTERPRISE_SERVER_CORE', 'STATUS_REPARSE_ATTRIBUTE_CONFLICT', 'STATUS_FWP_NULL_DISPLAY_NAME', 'STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET', 'ERROR_PROFILING_NOT_STARTED', 'STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT', 'HKEY_PERFORMANCE_TEXT', 'TRUST_E_SUBJECT_NOT_TRUSTED', 'SM_CXFRAME', 'WTD_UI_NOGOOD', 'STATUS_FLT_FILTER_NOT_FOUND', 'STATUS_NO_MORE_EAS', 'STGM_NOSCRATCH', 'ERROR_ALLOCATE_BUCKET', 'STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE', 'STATUS_DRIVER_DATABASE_ERROR', 'STATUS_MUI_INVALID_RC_CONFIG', 'STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED', 'STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET', 'szOID_RSA_emailAddr', 'CERT_STORE_UNSAFE_PHYSICAL_FLAG', 'ERROR_SHARING_VIOLATION', 'FC_SIMPLE_POINTER', 'RPC_NT_FP_UNDERFLOW', 'ERROR_EVT_FILTER_OUT_OF_RANGE', 'CONTEXT_DEBUG_REGISTERS', 'STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS', 'STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE', 'CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK', 'ERROR_REQUEST_OUT_OF_SEQUENCE', 'ERROR_INVALID_PORT_ATTRIBUTES', 'STATUS_DS_BUSY', 'STATUS_FWP_BUILTIN_OBJECT', 'SE_GROUP_USE_FOR_DENY_ONLY', 'CMSG_ATTR_CERT_COUNT_PARAM', 'STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT', 'STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH', 'RPC_C_IMP_LEVEL_IDENTIFY', 'STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE', 'SM_CXSIZE', 'EVENTLOG_WARNING_TYPE', 'FILE_SEQUENTIAL_ONLY', 'FC_ALLOCED_ON_STACK', 'ERROR_PNP_INVALID_ID', 'ERROR_PROC_NOT_FOUND', 'ERROR_OUT_OF_PAPER', 'SM_CXVIRTUALSCREEN', 'ALPC_MSGFLG_REPLY_MESSAGE', 'STATUS_RANGE_NOT_LOCKED', 'ACCESS_DENIED_CALLBACK_ACE_TYPE', 'STATUS_DEVICE_PROTOCOL_ERROR', 'STATUS_MEMBER_NOT_IN_ALIAS', 'STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED', 'EXCEPTION_STACK_OVERFLOW', 'RPC_NT_UNKNOWN_IF', 'STATUS_ACPI_INVALID_INDEX', 'SM_STARTER', 'EVENTLOG_ERROR_TYPE', 'RPC_NT_SS_CONTEXT_MISMATCH', 'STGFMT_ANY', 'CERT_COMPARE_NAME', 'PRODUCT_SERVER_FOR_SMALLBUSINESS_V', 'STATUS_DEVICE_DOES_NOT_EXIST', 'STATUS_CTX_LOGON_DISABLED', 'STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE', 'ERROR_EXTRANEOUS_INFORMATION', 'STATUS_DATA_LOST_REPAIR', 'CMSG_AUTHENTICATED_ATTRIBUTES_FLAG', 'ERROR_RING2SEG_MUST_BE_MOVABLE', 'CERT_STORE_SHARE_STORE_FLAG', 'STATUS_SXS_INVALID_ACTCTXDATA_FORMAT', 'STATUS_INVALID_IMAGE_WIN_16', 'STATUS_MUI_FILE_NOT_LOADED', 'STATUS_FILE_NOT_AVAILABLE', 'RRF_RT_REG_EXPAND_SZ', 'STATUS_PNP_INVALID_ID', 'ERROR_PIPE_NOT_CONNECTED', 'ERROR_DBG_REPLY_LATER', 'SM_CXHSCROLL', 'STATUS_IMAGE_NOT_AT_BASE', 'STATUS_LOGIN_WKSTA_RESTRICTION', 'ACCESS_MIN_MS_OBJECT_ACE_TYPE', 'STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE', 'szOID_OIWDIR_md2RSA', 'ERROR_PNP_TRANSLATION_FAILED', 'SEMAPHORE_QUERY_STATE', 'WARMING_NOT_SAME_FLAG_FOR_WINXP', 'TIMER_QUERY_STATE', 'CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID', 'FILE_VALID_SET_FLAGS', 'STATUS_HOST_DOWN', 'SW_NORMAL', 'ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL', 'STATUS_DISK_RECALIBRATE_FAILED', 'szOID_INFOSEC_sdnsKMandSig', 'ERROR_PAGEFILE_CREATE_FAILED', 'STATUS_WORKING_SET_LIMIT_RANGE', 'IMAGE_SCN_TYPE_NO_PAD', 'FILE_RANDOM_ACCESS', 'STATUS_INDOUBT_TRANSACTIONS_EXIST', 'STATUS_OBJECTID_EXISTS', 'STATUS_CTX_BAD_VIDEO_MODE', 'ERROR_NOT_ENOUGH_MEMORY', 'STATUS_DEVICE_DOOR_OPEN', 'STATUS_FWP_RESERVED', 'SYSTEM_ALARM_OBJECT_ACE_TYPE', 'STATUS_FILE_CHECKED_OUT', 'STATUS_ACPI_INVALID_TABLE', 'IMAGE_SCN_MEM_LOCKED', 'NTE_NOT_SUPPORTED', 'PKCS_UTC_TIME', 'ERROR_KEY_HAS_CHILDREN', 'STATUS_REVOCATION_OFFLINE_KDC', 'CERT_CTL_USAGE_PROP_ID', 'STATUS_FLT_DELETING_OBJECT', 'ERROR_INSUFFICIENT_BUFFER', 'STATUS_COULD_NOT_INTERPRET', 'STATUS_DEVICE_ENUMERATION_ERROR', 'PRODUCT_CLUSTER_SERVER_V', 'ERROR_INVALID_TARGET_HANDLE', 'STATUS_SYSTEM_POWERSTATE_TRANSITION', 'EXCEPTION_DATATYPE_MISALIGNMENT', 'STATUS_NO_SUCH_DEVICE', 'STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE', 'STATUS_BAD_NETWORK_NAME', 'PRODUCT_EMBEDDED', 'PIPE_UNLIMITED_INSTANCES', 'STATUS_BUFFER_TOO_SMALL', 'API_SET_SCHEMA_VERSION_V4', 'API_SET_SCHEMA_VERSION_V2', 'API_SET_SCHEMA_VERSION_V3', 'MEM_FREE', 'STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION', 'PRODUCT_MEDIUMBUSINESS_SERVER_MESSAGING', 'FILE_FLAG_NO_BUFFERING', 'DEBUG_EVENT_EXCEPTION', 'STATUS_PARTIAL_COPY', 'STATUS_GRAPHICS_PARTIAL_DATA_POPULATED', 'STATUS_TRUSTED_DOMAIN_FAILURE', 'PRODUCT_ENTERPRISE_N_EVALUATION', 'STATUS_ACPI_INVALID_MUTEX_LEVEL', 'STATUS_SERIAL_NO_DEVICE_INITED', 'ERROR_COMMITMENT_MINIMUM', 'DBG_TERMINATE_THREAD', 'OS_MEDIACENTER', 'STATUS_XML_PARSE_ERROR', 'FILE_VALID_OPTION_FLAGS', 'KEY_CREATE_LINK', 'STATUS_CLUSTER_NODE_NOT_FOUND', 'STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE', 'STATUS_FLOAT_OVERFLOW', 'STATUS_DLL_INIT_FAILED_LOGOFF', 'STATUS_NO_MORE_MATCHES', 'WAIT_IO_COMPLETION', 'STATUS_FLT_NOT_INITIALIZED', 'STATUS_FLT_NAME_CACHE_MISS', 'ERROR_INSTRUCTION_MISALIGNMENT', 'STATUS_VERIFY_REQUIRED', 'ERROR_INVALID_MODULETYPE', 'CRYPT_UPDATE_KEY', 'IMAGE_SCN_LNK_OTHER', 'STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE', 'STGFMT_DOCFILE', 'CERT_COMPARE_ANY', 'CRYPT_DATA_KEY', 'STATUS_MESSAGE_NOT_FOUND', 'SERVICE_STOP', 'RPC_NT_MAX_CALLS_TOO_SMALL', 'RPC_REQUEST_TYPE_CALL', 'STATUS_DOWNGRADE_DETECTED', 'ERROR_DLL_MIGHT_BE_INSECURE', 'STATUS_FLOPPY_WRONG_CYLINDER', 'NTE_FIXEDPARAMETER', 'STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION', 'szOID_OIWSEC_dsaSHA1', 'DEBUG_EVENT_UNLOAD_MODULE', 'STATUS_CSS_REGION_MISMATCH', 'SERVICE_CONTROL_TIMECHANGE', 'STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER', 'CERT_TRUST_CTL_IS_NOT_TIME_VALID', 'PERSIST_E_NOTSELFSIZING', 'OBJ_OPENLINK', 'SERVICE_BOOT_START', 'STATUS_PROPSET_NOT_FOUND', 'STATUS_NDIS_INVALID_ADDRESS', 'STATUS_FAIL_FAST_EXCEPTION', 'PRODUCT_SOLUTION_EMBEDDEDSERVER_CORE', 'STATUS_FLOAT_UNDERFLOW', 'ERROR_WX86_WARNING', 'WTD_STATEACTION_AUTO_CACHE', 'KEY_WOW64_64KEY', 'STATUS_CANNOT_IMPERSONATE', 'STATUS_BIZRULES_NOT_ENABLED', 'STATUS_LOG_METADATA_FLUSH_FAILED', 'STATUS_CONNECTION_DISCONNECTED', 'IMAGE_SCN_CNT_UNINITIALIZED_DATA', 'STATUS_ACCOUNT_EXPIRED', 'STATUS_DS_INCORRECT_ROLE_OWNER', 'STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE', 'CERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORE', 'STATUS_IPSEC_THROTTLE_DROP', 'STATUS_HANDLE_NOT_CLOSABLE', 'STATUS_FWP_INCOMPATIBLE_LAYER', 'ERROR_PARTIAL_COPY', 'STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED', 'ERROR_PIPE_BUSY', 'PIPE_READMODE_BYTE', 'SM_CMOUSEBUTTONS', 'ALPC_HANDLEFLG_DUPLICATE_SAME_ATTRIBUTES', 'CERT_FIND_SUBJECT_CERT', 'STATUS_BAD_FUNCTION_TABLE', 'PAGE_NOACCESS', 'STATUS_NOT_COMMITTED', 'CERT_COMPARE_ENHKEY_USAGE', 'STATUS_SXS_RELEASE_ACTIVATION_CONTEXT', 'KEY_SET_VALUE', 'STATUS_NO_TRUST_SAM_ACCOUNT', 'STATUS_PER_USER_TRUST_QUOTA_EXCEEDED', 'STATUS_FT_MISSING_MEMBER', 'STATUS_INVALID_LOGON_TYPE', 'STATUS_DEVICE_POWERED_OFF', 'STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS', 'ERROR_BAD_PIPE', 'FILE_LIST_DIRECTORY', 'TOKEN_SECURITY_ATTRIBUTE_VALID_FLAGS', 'FILE_READ_ATTRIBUTES', 'STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET', 'CONTEXT_FLOATING_POINT', 'STATUS_IMAGE_MP_UP_MISMATCH', 'SC_MANAGER_ALL_ACCESS', 'IMAGE_FILE_NET_RUN_FROM_SWAP', 'STATUS_PORT_MESSAGE_TOO_LONG', 'CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID', 'X509_CHOICE_OF_TIME', 'STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK', 'API_SET_LOAD_SCHEMA_ORDINAL', 'IMAGE_FILE_MACHINE_I386', 'STATUS_INVALID_MEMBER', 'RPC_NT_UNKNOWN_AUTHN_TYPE', 'SECURITY_MANDATORY_LOW_RID', 'ERROR_INVALID_SIGNAL_NUMBER', 'STATUS_GRAPHICS_TARGET_ALREADY_IN_SET', 'ERROR_FATAL_APP_EXIT', 'STATUS_WAKE_SYSTEM', 'CREATE_SUSPENDED', 'CERT_E_INVALID_NAME', 'MEM_LARGE_PAGES', 'RPC_NT_PIPE_EMPTY', 'STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION', 'ERROR_DEV_NOT_EXIST', 'MEM_WRITE_WATCH', 'STATUS_FILE_SYSTEM_LIMITATION', 'RPC_NT_PROCNUM_OUT_OF_RANGE', 'szOID_RSA_DES_EDE3_CBC', 'KEY_ENUMERATE_SUB_KEYS', 'ERROR_NO_EVENT_PAIR', 'LOAD_DLL_DEBUG_EVENT', 'PROFILE_SERVER', 'STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST', 'CMSG_CONTENT_PARAM', 'CERT_INFO_ISSUER_FLAG', 'ERROR_DRIVER_FAILED_SLEEP', 'DRIVE_REMOVABLE', 'CERT_SYSTEM_STORE_LOCATION_MASK', 'STATUS_NO_SPOOL_SPACE', 'STATUS_PNP_RESTART_ENUMERATION', 'OS_SERVER', 'TOKEN_SECURITY_ATTRIBUTE_DISABLED', 'CERT_QUERY_CONTENT_PFX', 'CERT_TRUST_HAS_EXACT_MATCH_ISSUER', 'STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET', 'ERROR_SWAPERROR', 'EXCEPTION_MAXIMUM_PARAMETERS', 'STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE', 'STATUS_DOMAIN_CONTROLLER_NOT_FOUND', 'WTD_REVOKE_WHOLECHAIN', 'STATUS_LOG_GROWTH_FAILED', 'INFINITE', 'STATUS_LOG_RECORD_NONEXISTENT', 'STATUS_RXACT_INVALID_STATE', 'DBG_CONTROL_BREAK', 'STATUS_WAIT_FOR_OPLOCK', 'CRYPT_INITIATOR', 'STATUS_SYSTEM_IMAGE_BAD_SIGNATURE', 'STATUS_GRAPHICS_NO_VIDPNMGR', 'X509_ALTERNATE_NAME', 'SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ANY', 'CERT_QUERY_CONTENT_CERT_PAIR', 'EVENTLOG_AUDIT_FAILURE', 'STATUS_NDIS_BUFFER_TOO_SHORT', 'STATUS_LOG_SECTOR_REMAPPED', 'REG_DWORD', 'IMAGE_FILE_RELOCS_STRIPPED', 'STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD', 'STATUS_PASSWORD_RESTRICTION', 'JOB_OBJECT_ASSIGN_PROCESS', 'ERROR_OPLOCK_BREAK_IN_PROGRESS', 'STATUS_TRANSACTION_ALREADY_COMMITTED', 'CERT_COMPARE_CROSS_CERT_DIST_POINTS', 'SM_CYSMCAPTION', 'STATUS_SERVER_SID_MISMATCH', 'RPC_NT_SERVER_TOO_BUSY', 'CERT_TRUST_IS_NOT_VALID_FOR_USAGE', 'STATUS_NDIS_PAUSED', 'STATUS_INVALID_IMAGE_NE_FORMAT', 'ERROR_ITERATED_DATA_EXCEEDS_64k', 'STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE', 'CERT_STORE_PROV_SMART_CARD', 'RPC_NT_UNKNOWN_AUTHZ_SERVICE', 'CMSG_INNER_CONTENT_TYPE_PARAM', 'ERROR_SEEK', 'X509_ASN_ENCODING', 'IMAGE_FILE_EXECUTABLE_IMAGE', 'FILE_ATTRIBUTE_VIRTUAL', 'szOID_RSA_SMIMEalg', 'ERROR_ALREADY_EXISTS', 'STATUS_STOPPED_ON_SYMLINK', 'szOID_INFOSEC_SuiteAKMandSig', 'X509_NAME', 'SE_GROUP_VALID_ATTRIBUTES', 'CERT_FIND_CTL_USAGE', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN', 'STATUS_INVALID_SERVER_STATE', 'STATUS_FWP_NEVER_MATCH', 'ERROR_IS_JOINED', 'STATUS_GRAPHICS_MONITOR_NOT_CONNECTED', 'CONTEXT_I386', 'SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ALL', 'STATUS_TRANSACTIONAL_CONFLICT', 'HKEY_PERFORMANCE_NLSTEXT', 'PROCESS_VM_WRITE', 'ERROR_INVALID_HANDLE', 'SM_CXMAXIMIZED', 'ERROR_INVALID_FUNCTION', 'szOID_INFOSEC_mosaicKMandUpdSig', 'STGM_CONVERT', 'STATUS_IPSEC_SA_LIFETIME_EXPIRED', 'STATUS_TRANSACTION_REQUIRED_PROMOTION', 'RPC_NT_CALL_IN_PROGRESS', 'STATUS_USER_EXISTS', 'CMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAM', 'STATUS_LOG_CONTAINER_STATE_INVALID', 'STATUS_FVE_BAD_DATA', 'STATUS_GRAPHICS_INVALID_ACTIVE_REGION', 'CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES', 'SERVICE_ALL_ACCESS', 'ERROR_NO_PAGEFILE', 'STATUS_OPLOCK_NOT_GRANTED', 'STATUS_INVALID_PARAMETER_12', 'ERROR_LOG_HARD_ERROR', 'STATUS_RECEIVE_PARTIAL_EXPEDITED', 'IMAGE_FILE_MACHINE_POWERPCFP', 'PROCESS_CREATE_THREAD', 'OPEN_ALWAYS', 'STARTF_USEPOSITION', 'CERT_TRUST_IS_REVOKED', 'ERROR_MCA_EXCEPTION', 'COMPRESSION_FORMAT_LZNT1', 'IMAGE_REL_BASED_MACHINE_SPECIFIC_7', 'ERROR_EVT_FILTER_ALREADYSCOPED', 'REG_NONE', 'STATUS_RESOURCE_REQUIREMENTS_CHANGED', 'STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER', 'ERROR_INVALID_NAME', 'SE_INCREASE_QUOTA_NAME', 'ERROR_EVT_CHANNEL_CANNOT_ACTIVATE', 'SECTION_MAP_EXECUTE_EXPLICIT', 'SM_CYCURSOR', 'STATUS_DFS_UNAVAILABLE', 'SERVICE_ACCEPT_SHUTDOWN', 'SYSTEM_ALARM_ACE_TYPE', 'STATUS_SXS_MANIFEST_FORMAT_ERROR', 'CERT_DESCRIPTION_PROP_ID', 'IMAGE_REL_BASED_HIGHLOW', 'STATUS_TRANSACTIONMANAGER_NOT_ONLINE', 'STATUS_FILE_ENCRYPTED', 'STGFMT_NATIVE', 'STATUS_INVALID_DEVICE_REQUEST', 'ERROR_BAD_REM_ADAP', 'STATUS_ACPI_INVALID_REGION', 'SE_RESTORE_NAME', 'STATUS_DS_INVALID_ATTRIBUTE_SYNTAX', 'szOID_INFOSEC_SuiteATokenProtection', 'STATUS_INVALID_TOKEN', 'FILE_FLAG_RANDOM_ACCESS', 'STATUS_CALLBACK_RETURNED_LANG', 'RPC_NT_FP_DIV_ZERO', 'NTE_NO_MEMORY', 'STATUS_REG_NAT_CONSUMPTION', 'ERROR_EVT_MAX_INSERTS_REACHED', 'ERROR_NEGATIVE_SEEK', 'DEBUG_EVENT_CHANGE_SYMBOL_STATE', 'ERROR_SECURITY_STREAM_IS_INCONSISTENT', 'STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS', 'FILE_WRITE_EA', 'CRYPT_VOLATILE', 'STATUS_UNABLE_TO_DELETE_SECTION', 'CERT_HASH_PROP_ID', 'CERT_STORE_PROV_LDAP', 'EVENTLOG_SUCCESS', 'CERT_STORE_ADD_USE_EXISTING', 'STGM_DIRECT', 'CRYPT_DELETEKEYSET', 'IMAGE_FILE_LARGE_ADDRESS_AWARE', 'STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY', 'ERROR_EVT_NON_VALIDATING_MSXML', 'STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT', 'OS_SMALLBUSINESSSERVER', 'PROV_EC_ECDSA_FULL', 'STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS', 'STATUS_RDP_PROTOCOL_ERROR', 'OBJ_INHERIT', 'IMAGE_FILE_MACHINE_UNKNOWN', 'PKCS_CONTENT_INFO_SEQUENCE_OF_ANY', 'RPC_C_QOS_CAPABILITIES_ANY_AUTHORITY', 'CRYPT_SGCKEY', 'TOKEN_SOURCE_LENGTH', 'RRF_RT_REG_NONE', 'CERT_QUERY_FORMAT_FLAG_ALL', 'PRODUCT_CORE_N', 'CRYPT_E_AUTH_ATTR_MISSING', 'STATUS_FVE_TPM_INVALID_PCR', 'STATUS_LOG_APPENDED_FLUSH_FAILED', 'CERT_QUERY_CONTENT_CTL', 'ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL', 'X509_ENUMERATED', 'STATUS_TOO_MANY_OPENED_FILES', 'STATUS_NDIS_INVALID_DEVICE_REQUEST', 'PROCESS_VM_OPERATION', 'STATUS_UNWIND', 'STATUS_SXS_MANIFEST_TOO_BIG', 'SM_CYFOCUSBORDER', 'STATUS_SXS_MULTIPLE_DEACTIVATION', 'STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET', 'STATUS_APPHELP_BLOCK', 'STATUS_CANNOT_LOAD_REGISTRY_FILE', 'ERROR_AUTODATASEG_EXCEEDS_64k', 'ERROR_STACK_OVERFLOW_READ', 'CRYPT_RECIPIENT', 'PRODUCT_STANDARD_SERVER', 'STATUS_NO_SUCH_GROUP', 'szOID_NIST_AES128_CBC', 'ACCESS_SYSTEM_SECURITY', 'MAILSLOT_WAIT_FOREVER', 'STATUS_HIVE_UNLOADED', 'OS_TERMINALREMOTEADMIN', 'STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED', 'STATUS_NO_TXF_METADATA', 'STATUS_NOTIFY_ENUM_DIR', 'WTD_STATEACTION_CLOSE', 'CERT_SYSTEM_STORE_CURRENT_USER', 'STATUS_SMARTCARD_CERT_EXPIRED', 'STATUS_NO_SECURITY_ON_OBJECT', 'STATUS_SXS_WRONG_SECTION_TYPE', 'STATUS_ALL_SIDS_FILTERED', 'ACCESS_MAX_MS_OBJECT_ACE_TYPE', 'szOID_OIWDIR_md2', 'STATUS_REMOTE_FILE_VERSION_MISMATCH', 'SYSTEM_PROCESS_TRUST_NOCONSTRAINT_MASK', 'STATUS_GENERIC_NOT_MAPPED', 'RPC_C_AUTHN_LEVEL_CONNECT', 'STGFMT_STORAGE', 'STATUS_FLOPPY_VOLUME', 'STATUS_FVE_CONV_READ_ERROR', 'ERROR_REGISTRY_IO_FAILED', 'EXCEPTION_POSSIBLE_DEADLOCK', 'PROFILE_USER', 'AF_LAT', 'ERROR_INVALID_DATA', 'AT_SIGNATURE', 'RPC_NT_CANT_CREATE_ENDPOINT', 'PRODUCT_HOME_PREMIUM_N', 'PAGE_WRITECOMBINE', 'CERT_AUTHORITY_INFO_ACCESS_PROP_ID', 'PRODUCT_HOME_PREMIUM_E', 'STATUS_DS_OID_NOT_FOUND', 'STATUS_FVE_NOT_ENCRYPTED', 'RPC_C_IMP_LEVEL_DEFAULT', 'OS_WIN95ORGREATER', 'STATUS_FVE_FAILED_SECTOR_SIZE', 'STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE', 'ERROR_IS_SUBSTED', 'SYSTEM_AUDIT_OBJECT_ACE_TYPE', 'UNPROTECTED_DACL_SECURITY_INFORMATION', 'FILE_SYNCHRONOUS_IO_ALERT', 'ALPC_MESSAGE_CONTEXT_ATTRIBUTE', 'STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET', 'STATUS_GRAPHICS_ADAPTER_WAS_RESET', 'STATUS_DIRECTORY_SERVICE_REQUIRED', 'STATUS_RETRY', 'CMSG_ATTR_CERT_PARAM', 'API_SET_RELEASE_SCHEMA_ORDINAL', 'CRYPT_KEK', 'ALPC_MSGFLG_LPC_MODE', 'STATUS_FWP_TOO_MANY_SUBLAYERS', 'REG_DWORD_BIG_ENDIAN', 'DEBUG_EVENT_CHANGE_ENGINE_STATE', 'ERROR_CANT_WAIT', 'SERVICE_ACCEPT_POWEREVENT', 'SE_DACL_AUTO_INHERIT_REQ', 'STATUS_DS_ADMIN_LIMIT_EXCEEDED', 'SW_SHOW', 'STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL', 'STATUS_MEDIA_CHECK', 'STATUS_FWP_LAYER_NOT_FOUND', 'FILE_OPEN_FOR_BACKUP_INTENT', 'NO_PROPAGATE_INHERIT_ACE', 'STATUS_INVALID_ADDRESS_WILDCARD', 'ERROR_MOD_NOT_FOUND', 'SM_CYMINTRACK', 'STATUS_TOKEN_ALREADY_IN_USE', 'TXFS_MINIVERSION_DIRTY_VIEW', 'STATUS_ACPI_HANDLER_COLLISION', 'STATUS_MISSING_SYSTEMFILE', 'STATUS_TRANSACTION_NOT_ROOT', 'STATUS_CANT_CROSS_RM_BOUNDARY', 'SECURITY_MANDATORY_MEDIUM_PLUS_RID', 'STATUS_GENERIC_COMMAND_FAILED', 'STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET', 'ERROR_DBG_TERMINATE_PROCESS', 'STATUS_BAD_MCFG_TABLE', 'STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER', 'STATUS_FILE_LOCK_CONFLICT', 'SM_CYFIXEDFRAME', 'STATUS_PNP_BAD_MPS_TABLE', 'SE_UNSOLICITED_INPUT_NAME', 'CERT_COMPARE_KEY_SPEC', 'STATUS_NDIS_FILE_NOT_FOUND', 'STATUS_ACPI_INVALID_ACCESS_SIZE', 'SM_NETWORK', 'EXCEPTION_CONTINUE_EXECUTION', 'ERROR_FLOAT_MULTIPLE_FAULTS', 'STATUS_ACPI_REG_HANDLER_FAILED', 'ERROR_PWD_TOO_SHORT', 'PRODUCT_SERVER_FOR_SMALLBUSINESS', 'CLUSAPI_READ_ACCESS', 'STARTF_FORCEONFEEDBACK', 'ERROR_TOO_MANY_TCBS', 'STATUS_CANT_TERMINATE_SELF', 'STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL', 'STATUS_LM_CROSS_ENCRYPTION_REQUIRED', 'ERROR_IOPL_NOT_ENABLED', 'STATUS_RXACT_STATE_CREATED', 'STATUS_FVE_ACTION_NOT_ALLOWED', 'STATUS_INFO_LENGTH_MISMATCH', 'STATUS_FILEMARK_DETECTED', 'IMAGE_SCN_MEM_PURGEABLE', 'STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY', 'RPC_NT_NO_MORE_MEMBERS', 'STATUS_SUCCESS', 'STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK', 'SE_TAKE_OWNERSHIP_NAME', 'CERT_STORE_ADD_NEWER', 'STATUS_CTX_CDM_DISCONNECT', 'PIPE_REJECT_REMOTE_CLIENTS', 'ERROR_BADKEY', 'ALPC_CANCELFLG_TRY_CANCEL', 'STATUS_LOG_RECORDS_RESERVED_INVALID', 'STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE', 'STATUS_STACK_OVERFLOW_READ', 'CRYPT_EXPORTABLE', 'STATUS_CACHE_PAGE_LOCKED', 'PRODUCT_PROFESSIONAL_WMC', 'PRODUCT_UNLICENSED', 'STATUS_REGISTRY_QUOTA_LIMIT', 'STATUS_FVE_VOLUME_TOO_SMALL', 'RIP_EVENT', 'ERROR_CHECKOUT_REQUIRED', 'AF_IMPLINK', 'PRODUCT_STORAGE_STANDARD_SERVER_CORE', 'ERROR_NO_DATA', 'TRUST_E_SUBJECT_FORM_UNKNOWN', 'IMAGE_DIRECTORY_ENTRY_DEBUG', 'CERT_QUERY_FORMAT_FLAG_BINARY', 'ERROR_NO_GUID_TRANSLATION', 'RPC_NT_CALL_FAILED_DNE', 'ERROR_DYNLINK_FROM_INVALID_RING', 'PROV_RNG', 'CREATE_NO_WINDOW', 'STATUS_TOO_MANY_COMMANDS', 'CERT_TRUST_IS_PARTIAL_CHAIN', 'ERROR_ABANDON_HIBERFILE', 'STATUS_TOO_MANY_ADDRESSES', 'STATUS_NO_SUCH_USER', 'SM_SAMEDISPLAYFORMAT', 'CMSG_CTRL_VERIFY_SIGNATURE', 'STATUS_TIMER_NOT_CANCELED', 'AF_CCITT', 'SERVICE_CONTROL_HARDWAREPROFILECHANGE', 'STATUS_INTERNAL_DB_ERROR', 'TOKEN_QUERY_SOURCE', 'FILE_MAP_WRITE', 'STATUS_DEVICE_NOT_PARTITIONED', 'STATUS_MESSAGE_RETRIEVED', 'X509_CERT_POLICIES', 'IMAGE_REL_BASED_ABSOLUTE', 'STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED', 'STATUS_DRIVERS_LEAKING_LOCKED_PAGES', 'STATUS_LOG_READ_CONTEXT_INVALID', 'SM_SHUTTINGDOWN', 'szOID_OIWSEC_sha', 'STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS', 'CERT_SYSTEM_STORE_UNPROTECTED_FLAG', 'SYMBOLIC_LINK_QUERY', 'STATUS_OPLOCK_BREAK_IN_PROGRESS', 'STATUS_ACPI_MUTEX_NOT_OWNED', 'STATUS_TRANSACTION_NOT_ACTIVE', 'NTE_BAD_HASH_STATE', 'ERROR_MORE_DATA', 'STATUS_SMARTCARD_NO_CERTIFICATE', 'STATUS_CTX_CDM_CONNECT', 'STATUS_DS_SENSITIVE_GROUP_VIOLATION', 'SE_CHANGE_NOTIFY_NAME', 'PKCS_TIME_REQUEST', 'ERROR_ABANDONED_WAIT_0', 'STATUS_REGISTRY_RECOVERED', 'ERROR_WAS_UNLOCKED', 'STATUS_NDIS_BAD_CHARACTERISTICS', 'FILE_GENERIC_READ', 'ACCESS_ALLOWED_ACE_TYPE', 'STATUS_CSS_AUTHENTICATION_FAILURE', 'FILE_OPEN', 'TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE', 'STANDARD_RIGHTS_READ', 'STATUS_FWP_DUPLICATE_AUTH_METHOD', 'STATUS_FWP_SESSION_ABORTED', 'STATUS_PAGE_FAULT_TRANSITION', 'ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY', 'STATUS_BAD_DLL_ENTRYPOINT', 'STATUS_NDIS_REQUEST_ABORTED', 'CERT_SIGNATURE_HASH_PROP_ID', 'ACE_OBJECT_TYPE_PRESENT', 'CONTEXT_XSTATE', 'SECTION_ALL_ACCESS', 'OS_ADVSERVER', 'ERROR_INVALID_EA_NAME', 'CERT_PUBKEY_HASH_RESERVED_PROP_ID', 'SERVICE_TRIGGER_TYPE_DOMAIN_JOIN', 'SERVICE_CONTROL_POWEREVENT', 'REG_BINARY', 'SEC_RESERVE', 'CERT_STORE_PROV_FILENAME', 'MEM_DECOMMIT', 'STATUS_SYSTEM_PROCESS_TERMINATED', 'STATUS_PASSWORD_MUST_CHANGE', 'STATUS_USER_SESSION_DELETED', 'DEBUG_EVENT_BREAKPOINT', 'STATUS_CONNECTION_ACTIVE', 'IMAGE_SCN_MEM_NOT_CACHED', 'ERROR_TIMER_RESOLUTION_NOT_SET', 'STATUS_SEMAPHORE_LIMIT_EXCEEDED', 'STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED', 'STATUS_UNABLE_TO_UNLOAD_MEDIA', 'STATUS_SHARED_POLICY', 'NTE_BAD_KEYSET_PARAM', 'STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND', 'RPC_NT_CALL_FAILED', 'SM_SWAPBUTTON', 'SM_DEBUG', 'IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG', 'PRODUCT_SERVER_FOR_SB_SOLUTIONS', 'STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION', 'STATUS_PKINIT_FAILURE', 'STATUS_NDIS_INVALID_PORT_STATE', 'CERT_TRUST_IS_CYCLIC', 'ERROR_TOO_MANY_MODULES', 'STATUS_CLUSTER_NODE_UP', 'CERT_KEY_IDENTIFIER_PROP_ID', 'STATUS_INVALID_ADDRESS', 'OBJ_VALID_ATTRIBUTES', 'STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT', 'ERROR_DS_VERSION_CHECK_FAILURE', 'STATUS_NO_QUOTAS_FOR_ACCOUNT', 'SM_CYICONSPACING', 'RPC_NT_CANNOT_SUPPORT', 'STATUS_SPECIAL_GROUP', 'ERROR_INVALID_DEVICE_OBJECT_PARAMETER', 'CERT_FIND_CERT_ID', 'PAGE_EXECUTE', 'SM_CYICON', 'STATUS_ACCESS_DENIED', 'STATUS_ACCOUNT_DISABLED', 'STATUS_NO_SECRETS', 'STATUS_CONNECTION_INVALID', 'STATUS_PAGE_FAULT_DEMAND_ZERO', 'TOKEN_IMPERSONATE', 'FILE_WRITE_DATA', 'TOKEN_ASSIGN_PRIMARY', 'RPC_NT_STRING_TOO_LONG', 'ERROR_EVT_MESSAGE_ID_NOT_FOUND', 'FILE_UNICODE_ON_DISK', 'CMSG_CTRL_ADD_CERT', 'CERT_STORE_READONLY_FLAG', 'RPC_C_AUTHN_LEVEL_PKT_PRIVACY', 'CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED', 'szOID_OIWSEC_dsaComm', 'STATUS_DFS_EXIT_PATH_FOUND', 'STGM_READWRITE', 'STATUS_CTX_MODEM_RESPONSE_VOICE', 'REALTIME_PRIORITY_CLASS', 'ACCESS_MAX_MS_ACE_TYPE', 'SM_CXSIZEFRAME', 'ERROR_MUTANT_LIMIT_EXCEEDED', 'STATUS_FWP_INVALID_FLAGS', 'STATUS_FLT_POST_OPERATION_CLEANUP', 'STATUS_IMAGE_CERT_REVOKED', 'STATUS_DEVICE_UNREACHABLE', 'DEBUG_EVENT_CREATE_THREAD', 'SERVICE_CONTROL_SHUTDOWN', 'CERT_PVK_FILE_PROP_ID', 'STATUS_REDIRECTOR_PAUSED', 'ERROR_EVT_UNRESOLVED_VALUE_INSERT', 'ASYNC_MODE_DEFAULT', 'SERVICE_TRIGGER_TYPE_GROUP_POLICY', 'STATUS_LOG_DEDICATED', 'ERROR_EXE_CANNOT_MODIFY_SIGNED_BINARY', 'STATUS_SXS_FILE_HASH_MISSING', 'ERROR_RXACT_COMMITTED', 'STATUS_DIRECTORY_IS_A_REPARSE_POINT', 'RPC_NT_NULL_REF_POINTER', 'DBG_UNABLE_TO_PROVIDE_HANDLE', 'NTE_BAD_PROV_TYPE', 'OS_WIN98ORGREATER', 'RPC_NT_PIPE_DISCIPLINE_ERROR', 'ERROR_ARBITRATION_UNHANDLED', 'CMSG_CTRL_DECRYPT', 'STATUS_GRAPHICS_DRIVER_MISMATCH', 'PRODUCT_BUSINESS_N', 'SM_CXMINSPACING', 'CERT_COMPARE_CERT_ID', 'SE_TIME_ZONE_NAME', 'ERROR_SHORT_NAMES_NOT_ENABLED_ON_VOLUME', 'CERT_QUERY_CONTENT_FLAG_CERT', 'SE_CREATE_PERMANENT_NAME', 'TRUNCATE_EXISTING', 'STATUS_INVALID_PARAMETER_5', 'SM_CXHTHUMB', 'STATUS_INVALID_PARAMETER_7', 'STATUS_INVALID_PARAMETER_6', 'STATUS_INVALID_PARAMETER_1', 'RPC_NT_UNSUPPORTED_TRANS_SYN', 'STATUS_INVALID_PARAMETER_3', 'CERT_KEY_PROV_INFO_PROP_ID', 'STATUS_FWP_ZERO_LENGTH_ARRAY', 'BIND_IF_SYNTAX_UNKNOWN', 'AF_ECMA', 'ERROR_SYSTEM_TRACE', 'STATUS_CONTEXT_MISMATCH', 'DIRECTORY_CREATE_OBJECT', 'STATUS_TXF_ATTRIBUTE_CORRUPT', 'PIPE_ACCEPT_REMOTE_CLIENTS', 'CERT_STORE_CREATE_NEW_FLAG', 'IMAGE_FILE_MACHINE_IA64', 'SW_FORCEMINIMIZE', 'ERROR_VDM_HARD_ERROR', 'STATUS_UNFINISHED_CONTEXT_DELETED', 'ERROR_PRIMARY_TRANSPORT_CONNECT_FAILED', 'SC_MANAGER_CONNECT', 'CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG', 'ERROR_NOTHING_TO_TERMINATE', 'STATUS_WMI_GUID_DISCONNECTED', 'szOID_OIWSEC_md5RSASign', 'STATUS_LPC_INVALID_CONNECTION_USAGE', 'INVALID_HANDLE_VALUE', 'STATUS_UNRECOGNIZED_VOLUME', 'CERT_FIND_SHA1_HASH', 'STATUS_CTX_SHADOW_DISABLED', 'IDLE_PRIORITY_CLASS', 'STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE', 'PRODUCT_WEB_SERVER_CORE', 'STATUS_FILE_CORRUPT_ERROR', 'STATUS_TRANSLATION_COMPLETE', 'STATUS_GROUP_EXISTS', 'IMAGE_SCN_ALIGN_4BYTES', 'STATUS_GUIDS_EXHAUSTED', 'szOID_OIWSEC_desOFB', 'STATUS_FVE_LOCKED_VOLUME', 'CERT_NEXT_UPDATE_LOCATION_PROP_ID', 'X509_BITS', 'STGTY_REPEAT', 'STATUS_RESOURCE_NOT_OWNED', 'CERT_STORE_PROV_SERIALIZED', 'szOID_RSA_RSA', 'SE_SACL_DEFAULTED', 'ERROR_CANNOT_LOAD_REGISTRY_FILE', 'STATUS_SHARING_PAUSED', 'STATUS_CTX_INVALID_WD', 'STATUS_INVALID_USER_PRINCIPAL_NAME', 'SE_GROUP_ENABLED_BY_DEFAULT', 'STATUS_ABANDONED_WAIT_63', 'SE_IMPERSONATE_NAME', 'FILE_ATTRIBUTE_TEMPORARY', 'ERROR_MP_PROCESSOR_MISMATCH', 'ERROR_BAD_DEV_TYPE', 'FILE_GENERIC_WRITE', 'STATUS_CTX_PD_NOT_FOUND', 'FAX_PORT_SET', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING', 'STATUS_WX86_UNSIMULATE', 'CERT_STORE_PROV_LDAP_W', 'STATUS_NO_SECURITY_CONTEXT', 'EXCEPTION_EXECUTE_HANDLER', 'STATUS_INVALID_THREAD', 'OS_EMBEDDED', 'CMSG_ENCODED_SIGNER', 'STATUS_MEDIA_WRITE_PROTECTED', 'STGM_SHARE_DENY_NONE', 'FILE_NOTIFY_CHANGE_ATTRIBUTES', 'ERROR_EA_FILE_CORRUPT', 'CMSG_CTRL_DEL_ATTR_CERT', 'STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED', 'STATUS_SECRET_TOO_LONG', 'STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING', 'HKEY_CURRENT_USER', 'CERT_FIND_SUBJECT_STR_W', 'THREAD_SET_CONTEXT', 'ERROR_UNEXPECTED_MM_CREATE_ERR', 'PROCESS_MODE_BACKGROUND_END', 'SM_CXMINIMIZED', 'PRODUCT_UNDEFINED', 'SERVICE_QUERY_CONFIG', 'CERT_FIND_SUBJECT_STR_A', 'PRODUCT_STARTER_N', 'OBJ_EXCLUSIVE', 'PRODUCT_STARTER_E', 'ERROR_DISK_TOO_FRAGMENTED', 'WOW64_MAXIMUM_SUPPORTED_EXTENSION', 'SERVICE_ACCEPT_PRESHUTDOWN', 'STATUS_RECURSIVE_DISPATCH', 'STATUS_INVALID_NETWORK_RESPONSE', 'FILE_ATTRIBUTE_NORMAL', 'TH32CS_SNAPMODULE', 'STATUS_DISK_FULL', 'IMAGE_FILE_MACHINE_AXP64', 'STATUS_GRAPHICS_CANNOTCOLORCONVERT', 'SM_CYHSCROLL', 'SYNCHRONIZE', 'CERT_COMPARE_PROPERTY', 'ERROR_EVT_FILTER_INVARG', 'TOKEN_ADJUST_DEFAULT', 'STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED', 'STATUS_MUTUAL_AUTHENTICATION_FAILED', 'STATUS_SPECIAL_ACCOUNT', 'STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET', 'SC_MANAGER_LOCK', 'SM_CYMENUCHECK', 'STGM_SHARE_EXCLUSIVE', 'CERT_CHAIN_REVOCATION_CHECK_CHAIN', 'ERROR_CANTSCROLLBACKWARDS', 'STATUS_CTX_WINSTATION_NOT_FOUND', 'WRITE_WATCH_FLAG_RESET', 'STATUS_REMOTE_STORAGE_NOT_ACTIVE', 'STATUS_PLUGPLAY_NO_DEVICE', 'NTE_BAD_VER', 'STATUS_ILLEGAL_ELEMENT_ADDRESS', 'DEBUG_EVENT_LOAD_MODULE', 'SERVICE_CONTROL_INTERROGATE', 'STATUS_INVALID_INFO_CLASS', 'NTE_PROV_DLL_NOT_FOUND', 'STATUS_UNMAPPABLE_CHARACTER', 'RPC_NT_BINDING_HAS_NO_AUTH', 'STATUS_ALREADY_DISCONNECTED', 'ERROR_NO_LOG_SPACE', 'STATUS_DS_CANT_ON_RDN', 'STATUS_NETWORK_CREDENTIAL_CONFLICT', 'STATUS_LOG_RESTART_INVALID', 'ALPC_MSGFLG_WAIT_ALERTABLE', 'STATUS_FWP_INVALID_INTERVAL', 'STATUS_CTX_MODEM_RESPONSE_NO_CARRIER', 'STATUS_DEVICE_BUSY', 'ERROR_PAGE_FAULT_GUARD_PAGE', 'ALPC_CANCELFLG_NO_CONTEXT_CHECK', 'SERVICE_INACTIVE', 'STATUS_ND_QUEUE_OVERFLOW', 'STATUS_TOO_MANY_LINKS', 'STATUS_LOG_CLIENT_ALREADY_REGISTERED', 'STATUS_ILLEGAL_FLOAT_CONTEXT', 'ERROR_CANNOT_COPY', 'STATUS_NO_USER_KEYS', 'COMPRESSION_FORMAT_XPRESS', 'STATUS_TRANSACTION_INVALID_ID', 'ERROR_DLL_MIGHT_BE_INCOMPATIBLE', 'STATUS_VOLUME_NOT_UPGRADED', 'STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER', 'PIPE_ACCESS_DUPLEX', 'ERROR_OPLOCK_HANDLE_CLOSED', 'CERT_E_ISSUERCHAINING', 'STATUS_RESOURCE_TYPE_NOT_FOUND', 'STATUS_WX86_EXCEPTION_CONTINUE', 'STATUS_STRONG_CRYPTO_NOT_SUPPORTED', 'STATUS_BAD_CURRENT_DIRECTORY', 'STATUS_GRAPHICS_OPM_INVALID_SRM', 'BACKUP_SECURITY_INFORMATION', 'STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON', 'STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER', 'STATUS_BACKUP_CONTROLLER', 'STATUS_FREE_VM_NOT_AT_BASE', 'SM_SHOWSOUNDS', 'PRODUCT_HOME_BASIC_E', 'OS_WINDOWS', 'szOID_RSA_PSPECIFIED', 'ERROR_IMAGE_MACHINE_TYPE_MISMATCH_EXE', 'PRODUCT_HOME_BASIC_N', 'STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED', 'STATUS_STACK_BUFFER_OVERRUN', 'STATUS_JOURNAL_NOT_ACTIVE', 'ERROR_MR_MID_NOT_FOUND', 'ERROR_SUCCESS', 'ERROR_CANNOT_GRANT_REQUESTED_OPLOCK', 'SM_CYMENU', 'FILE_CASE_PRESERVED_NAMES', 'STATUS_BAD_IMPERSONATION_LEVEL', 'STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED', 'STATUS_LOG_SPACE_RESERVED_INVALID', 'STATUS_PORT_CLOSED', 'STATUS_UNKNOWN_REVISION', 'ERROR_EVT_VERSION_TOO_OLD', 'PRODUCT_CLUSTER_SERVER', 'STATUS_SAM_INIT_FAILURE', 'PRODUCT_STORAGE_EXPRESS_SERVER_CORE', 'CERT_OCSP_RESPONSE_PROP_ID', 'STATUS_INVALID_IDN_NORMALIZATION', 'ERROR_ALERTED', 'RPC_NT_NO_ENDPOINT_FOUND', 'STATUS_HARDWARE_MEMORY_ERROR', 'STATUS_CLUSTER_NETWORK_ALREADY_ONLINE', 'STATUS_TS_INCOMPATIBLE_SESSIONS', 'STATUS_NO_YIELD_PERFORMED', 'STATUS_DEVICE_REMOVED', 'SM_CARETBLINKINGENABLED', 'STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED', 'STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA', 'RPC_NT_INVALID_AUTH_IDENTITY', 'szOID_INFOSEC_sdnsKeyManagement', 'STATUS_FWP_INJECT_HANDLE_CLOSING', 'STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER', 'STATUS_FWP_INCOMPATIBLE_DH_GROUP', 'RPC_C_IMP_LEVEL_DELEGATE', 'PERSIST_E_SIZEINDEFINITE', 'STATUS_NO_MEMORY', 'X509_UNICODE_NAME', 'ERROR_WRONG_DISK', 'STATUS_FVE_RAW_BLOCKED', 'STATUS_ENCOUNTERED_WRITE_IN_PROGRESS', 'STATUS_DS_GC_NOT_AVAILABLE', 'RPC_NT_NOT_LISTENING', 'SM_MEDIACENTER', 'ERROR_BAD_DLL_ENTRYPOINT', 'STATUS_LOG_BLOCK_INVALID', 'ERROR_WAIT_NO_CHILDREN', 'CERT_NAME_ISSUER_FLAG', 'PRODUCT_DATACENTER_SERVER_V', 'PROCESS_QUERY_INFORMATION', 'szOID_DH_SINGLE_PASS_STDDH_SHA1_KDF', 'STATUS_ADDRESS_CLOSED', 'FILE_ALL_ACCESS', 'STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT', 'IMAGE_FILE_MACHINE_THUMB', 'STATUS_FVE_FAILED_WRONG_FS', 'ERROR_COULD_NOT_INTERPRET', 'ERROR_ARITHMETIC_OVERFLOW', 'STATUS_PROCEDURE_NOT_FOUND', 'PRODUCT_MEDIUMBUSINESS_SERVER_MANAGEMENT', 'SYSTEM_ALARM_CALLBACK_ACE_TYPE', 'STATUS_FULLSCREEN_MODE', 'PRODUCT_STANDARD_SERVER_SOLUTIONS', 'EXCEPTION_ILLEGAL_INSTRUCTION', 'ERROR_UNDEFINED_CHARACTER', 'NTE_BAD_LEN', 'CERT_FIND_ENHKEY_USAGE', 'STATUS_FILE_DELETED', 'OBJECT_TYPE_ALL_ACCESS', 'FILE_TRAVERSE', 'CERT_QUERY_CONTENT_SERIALIZED_CERT', 'szOID_RSA_SETOAEP_RSA', 'ERROR_NOT_DOS_DISK', 'szOID_NIST_AES128_WRAP', 'DEBUG_EVENT_SYSTEM_ERROR', 'SM_CXFIXEDFRAME', 'CRYPT_MACHINE_KEYSET', 'STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA', 'CERT_FIND_SUBJECT_STR', 'STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY', 'WOW64_SIZE_OF_80387_REGISTERS', 'RRF_RT_REG_MULTI_SZ', 'CERT_STORE_PROV_SMART_CARD_W', 'HKEY_PERFORMANCE_DATA', 'IMAGE_FILE_MACHINE_POWERPC', 'DRIVE_REMOTE', 'STATUS_WX86_EXCEPTION_LASTCHANCE', 'SE_RM_CONTROL_VALID', 'STATUS_GRAPHICS_PRESENT_UNOCCLUDED', 'ERROR_NOTIFICATION_GUID_ALREADY_DEFINED', 'szOID_ANSI_X942_DH', 'SERVICE_CONTROL_NETBINDDISABLE', 'FAX_CONFIG_QUERY', 'STATUS_NO_EAS_ON_FILE', 'SEC_WINNT_AUTH_IDENTITY_UNICODE', 'THREAD_SET_INFORMATION', 'PROTECTED_SACL_SECURITY_INFORMATION', 'STATUS_FWP_TRAFFIC_MISMATCH', 'STATUS_TOO_MANY_PRINCIPALS', 'CERT_CROSS_CERT_DIST_POINTS_PROP_ID', 'PROV_EC_ECDSA_SIG', 'STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED', 'STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT', 'STATUS_NOTIFICATION_GUID_ALREADY_DEFINED', 'FILE_COMPLETE_IF_OPLOCKED', 'CERT_SYSTEM_STORE_SERVICES_ID', 'ERROR_DISK_REPAIR_DISABLED', 'CERT_STORE_MANIFOLD_FLAG', 'STATUS_BAD_FILE_TYPE', 'STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS', 'STATUS_LOG_CANT_DELETE', 'STATUS_SHARING_VIOLATION', 'IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE', 'CERT_QUERY_CONTENT_FLAG_CTL', 'STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE', 'SE_LOAD_DRIVER_NAME', 'STD_ERROR_HANDLE', 'PROV_EC_ECNRA_SIG', 'STATUS_PWD_TOO_RECENT', 'PROCESS_SUSPEND_RESUME', 'EVENTLOG_BACKWARDS_READ', 'szOID_RSA_SMIMEalgESDH', 'STATUS_NDIS_ADAPTER_NOT_FOUND', 'STATUS_OBJECT_NO_LONGER_EXISTS', 'STATUS_NETWORK_NAME_DELETED', 'STATUS_GRAPHICS_LEADLINK_START_DEFERRED', 'STATUS_NETWORK_BUSY', 'IMAGE_FILE_MACHINE_ALPHA', 'STATUS_DLL_NOT_FOUND', 'STATUS_INVALID_UNWIND_TARGET', 'STATUS_GRAPHICS_INTERNAL_ERROR', 'STATUS_WMI_SET_FAILURE', 'STATUS_REVISION_MISMATCH', 'RPC_NT_INVALID_TIMEOUT', 'STATUS_INVALID_ADDRESS_COMPONENT', 'PRODUCT_SERVER_FOUNDATION', 'STATUS_GRAPHICS_PRESENT_MODE_CHANGED', 'STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE', 'CERT_QUERY_CONTENT_CERT', 'NULL', 'STATUS_NDIS_NOT_SUPPORTED', 'STATUS_ACPI_INVALID_EVENTTYPE', 'FILE_CREATED', 'ERROR_KERNEL_APC', 'SERVICE_SYSTEM_START', 'STATUS_DEVICE_REQUIRES_CLEANING', 'ERROR_VIRUS_INFECTED', 'FILE_NOTIFY_CHANGE_SIZE', 'CERT_FIND_KEY_SPEC', 'STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY', 'STATUS_PKINIT_CLIENT_FAILURE', 'ERROR_IS_JOIN_PATH', 'STATUS_CLUSTER_NODE_NOT_PAUSED', 'szOID_X957_DSA', 'SERVICE_WIN32_SHARE_PROCESS', 'STATUS_VOLMGR_RAID5_NOT_SUPPORTED', 'STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP', 'ERROR_SEEK_ON_DEVICE', 'CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG', 'STATUS_NOT_CLIENT_SESSION', 'STATUS_HUNG_DISPLAY_DRIVER_THREAD', 'ERROR_HANDLE_EOF', 'RRF_NOEXPAND', 'STATUS_NDIS_RESOURCE_CONFLICT', 'CERT_ACCESS_STATE_PROP_ID', 'IMAGE_FILE_MACHINE_SH4', 'IMAGE_FILE_MACHINE_SH5', 'IMAGE_FILE_MACHINE_SH3', 'ERROR_PROCESS_MODE_NOT_BACKGROUND', 'ERROR_INVALID_CATEGORY', 'SECURITY_MANDATORY_MEDIUM_RID', 'CRYPT_ACQUIRE_CACHE_FLAG', 'CRYPT_PREGEN', 'STATUS_NT_CROSS_ENCRYPTION_REQUIRED', 'ERROR_HANDLES_CLOSED', 'STATUS_FWP_PROVIDER_CONTEXT_MISMATCH', 'STATUS_DS_CANT_MOD_PRIMARYGROUPID', 'CERT_STORE_ADD_NEW', 'ERROR_RECEIVE_PARTIAL_EXPEDITED', 'SW_SHOWMINNOACTIVE', 'TH32CS_SNAPMODULE32', 'STGM_NOSNAPSHOT', 'STATUS_NULL_LM_PASSWORD', 'STATUS_FVE_RAW_ACCESS', 'RPC_S_PROCNUM_OUT_OF_RANGE', 'IMAGE_DIRECTORY_ENTRY_IMPORT', 'CERT_E_CHAINING', 'ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND', 'CREATE_PROTECTED_PROCESS', 'ERROR_NO_MORE_ITEMS', 'RPC_NT_WRONG_KIND_OF_BINDING', 'STATUS_UNABLE_TO_FREE_VM', 'STATUS_FVE_CONV_RECOVERY_FAILED', 'ERROR_FOUND_OUT_OF_SCOPE']) -structs = set(['PFILE_ALIGNMENT_INFORMATION', 'PCRYPT_ATTRIBUTE_TYPE_VALUE', 'PALPC_HANDLE_ATTR', 'PACCESS_DENIED_CALLBACK_ACE', '_CLAIM_SECURITY_ATTRIBUTE_V1_UNION', 'CERT_INFO', 'PCRYPT_ATTRIBUTES', 'MIB_UDPTABLE_OWNER_PID', '_FILE_FS_LABEL_INFORMATION', 'CRYPT_KEY_PROV_PARAM', 'FILE_DISPOSITION_INFORMATION', 'PIDLIST_ABSOLUTE', 'CERT_STRONG_SIGN_SERIALIZED_INFO', 'LPUNLOAD_DLL_DEBUG_INFO', '_FILE_FS_VOLUME_INFORMATION', 'IDLDESC', 'PSYSTEM_AUDIT_OBJECT_ACE', 'LPEXCEPTION_DEBUG_INFO', '__tagVARIANT', 'PFILE_FS_OBJECTID_INFORMATION', 'FILE_ATTRIBUTE_TAG_INFORMATION', 'API_SET_VALUE_ARRAY_V4', 'SHITEMID', 'THREAD_BASIC_INFORMATION', '_ALPC_MESSAGE_ATTRIBUTES', 'CMSG_STREAM_INFO', '_TOKEN_SOURCE', '_ANON_PROCESS_MITIGATION_IMAGE_LOAD_POLICY_BITFIELD', 'CURDIR', '_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO', 'NPRGBTRIPLE', 'LPRIP_INFO', '_tagVARIANT', 'FILE_FS_VOLUME_INFORMATION', 'IP_ADAPTER_INDEX_MAP', 'PANSI_STRING', 'PRTL_UNLOAD_EVENT_TRACE64', '_MIB_IFTABLE', '_ALPC_PORT_ATTRIBUTES64', 'IMAGE_FILE_HEADER', '_PSAPI_WORKING_SET_EX_BLOCK32', 'tagTYPEDESC', 'PRTL_RELATIVE_NAME_U', 'PSYSTEM_PROCESS_TRUST_LABEL_ACE', 'LOAD_DLL_DEBUG_INFO', '_SYSTEMTIME', 'PCERT_RDN_VALUE_BLOB', 'PPSAPI_WORKING_SET_EX_INFORMATION', '_FILE_IO_PRIORITY_HINT_INFORMATION', 'PCRYPT_ENCRYPT_MESSAGE_PARA', 'PPSAPI_WORKING_SET_INFORMATION64', 'TOKEN_ORIGIN', 'CMSG_ENVELOPED_ENCODE_INFO', 'LPENUM_SERVICE_STATUS_PROCESSW', '_ANON_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_UNION', '_BG_JOB_PROGRESS', 'PALPC_DIRECT_ATTR64', 'PDEBUG_MODULE_AND_ID', 'LPIDLDESC', '_CERT_REVOCATION_CRL_INFO', '_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE', 'BG_JOB_PROGRESS', 'PUNICODE_STRING', '_ANON_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_UNION', 'PUBLIC_OBJECT_TYPE_INFORMATION', 'CERT_TRUST_LIST_INFO', 'PFILE_FULL_EA_INFORMATION', 'SERVICE_STATUS_PROCESS', 'CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO', 'WINTRUST_FILE_INFO_', 'PIMAGE_OPTIONAL_HEADER32', '_TOKEN_SECURITY_ATTRIBUTES_INFORMATION', '_CMSG_SIGNER_INFO', '_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', 'PSID_AND_ATTRIBUTES_HASH', 'tagBINDPTR', 'SYSTEM_MANDATORY_LABEL_ACE', 'PSPC_SP_OPUS_INFO', '_IMAGE_OPTIONAL_HEADER', 'XSAVE_FORMAT_32', 'LPCONTEXT64', 'ALPC_SERVER_INFORMATION_TMP_OUT', 'PFILE_ALL_INFORMATION', 'PDEBUG_PROCESSOR_IDENTIFICATION_ALL', 'FILE_EA_INFORMATION', 'LPJIT_DEBUG_INFO', 'PXSAVE_FORMAT_32', '_MIB_TCP6ROW_OWNER_PID', 'TMP_signscale_union', 'PPROCESS_MEMORY_COUNTERS', 'SID_AND_ATTRIBUTES_HASH', '_FILE_NAME_INFORMATION', '_DEBUG_PROCESSOR_IDENTIFICATION_X86', 'MIB_TCP6TABLE_OWNER_PID', 'PACE_HEADER', '_ALPC_CONTEXT_ATTR', 'WINTRUST_CATALOG_INFO_', '_CERT_CHAIN_ELEMENT', 'PROCESS_BASIC_INFORMATION', 'BG_FILE_INFO', 'OSVERSIONINFOW', '_TOKEN_ACCESS_INFORMATION', 'LPSECURITY_ATTRIBUTES', '_GUID', 'FILE_FS_DEVICE_INFORMATION', 'OSVERSIONINFOA', 'EXCEPTION_POINTERS64', '_PSAPI_WORKING_SET_BLOCK64', 'WOW64_FLOATING_SAVE_AREA', 'PFILE_MODE_INFORMATION', '_IMAGE_NT_HEADERS', 'EXCEPINFO', '_KEY_VALUE_PARTIAL_INFORMATION', '_TMP_CONTEXT64_SUBUNION', 'PMIB_IFROW', 'LPLOAD_DLL_DEBUG_INFO', '_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY', 'DEBUG_BREAKPOINT_PARAMETERS', '_ALPC_WORK_ON_BEHALF_ATTR', 'PSIP_INDIRECT_DATA', 'PISECURITY_DESCRIPTOR', 'PFILE_FS_SIZE_INFORMATION', 'TOKEN_ACCESS_INFORMATION', '_STARTUPINFOEXA', 'PDEBUG_STACK_FRAME', 'PROCESS_MITIGATION_DYNAMIC_CODE_POLICY', '_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE', 'PFILE_POSITION_INFORMATION', 'CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', 'PWINTRUST_CATALOG_INFO', '_JIT_DEBUG_INFO', '_DEBUG_EVENT', 'PTOKEN_STATISTICS', 'PFILE_STANDARD_INFORMATION', 'LPBITMAPFILEHEADER', 'PMIB_UDPROW_OWNER_PID', 'PTOKEN_PRIMARY_GROUP', '_EXCEPTION_POINTERS64', 'MULTI_QI', 'LPEXIT_THREAD_DEBUG_INFO', 'WINTRUST_BLOB_INFO', 'PUBLIC_OBJECT_BASIC_INFORMATION', 'FILE_FS_CONTROL_INFORMATION', 'ACCESS_DENIED_CALLBACK_ACE', '_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY', 'TOKEN_SECURITY_ATTRIBUTES_INFORMATION', '_CRL_ENTRY', 'PTOKEN_APPCONTAINER_INFORMATION', '_SYSTEM_MODULE64', 'BITMAPCOREINFO', '_TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', 'FILE_FULL_EA_INFORMATION', 'CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION', '_TOKEN_PRIMARY_GROUP', 'DEBUG_VALUE_TMP_UNION', '_TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION', 'POSVERSIONINFOEXW', 'WINTRUST_FILE_INFO', 'FILE_STANDARD_INFORMATION', 'PSYSTEM_RESOURCE_ATTRIBUTE_ACE', 'REFGUID', '_SERVICE_STATUS_PROCESS', 'MIB_IPADDRROW', '_ALPC_DIRECT_ATTR32', 'CMSG_CTRL_DECRYPT_PARA', 'PPROCESS_MITIGATION_IMAGE_LOAD_POLICY', 'PCLAIM_SECURITY_ATTRIBUTES_INFORMATION', 'RTL_UNLOAD_EVENT_TRACE32', 'PORT_MESSAGE64', 'PFILE_FS_DRIVER_PATH_INFORMATION', 'tagSOLE_AUTHENTICATION_SERVICE', 'ALPC_DIRECT_ATTR32', '_CREATE_THREAD_DEBUG_INFO', 'PFILE_IS_REMOTE_DEVICE_INFORMATION', 'LPPROCESSENTRY32', 'API_SET_NAMESPACE_ARRAY_V4', '_EXIT_THREAD_DEBUG_INFO', '_CLIENT_ID', 'MEMORY_BASIC_INFORMATION32', 'SECURITY_ATTRIBUTES', 'IMAGE_NT_HEADERS32', '_ANON_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_UNION', '_CRYPT_HASH_MESSAGE_PARA', 'PALPC_SECURITY_ATTR64', 'PALPC_HANDLE_ATTR32', 'PIMAGE_EXPORT_DIRECTORY', '_DEBUG_BREAKPOINT_PARAMETERS', 'PORT_VIEW', '_TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', 'MIB_TCPTABLE_OWNER_PID', 'LPDEBUG_EVENT', 'PACCESS_DENIED_OBJECT_ACE', 'DISPPARAMS', 'SYSTEM_HANDLE_INFORMATION', '_LOCALTHIS', 'PCRYPTCATMEMBER', 'TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION', 'ALPC_HANDLE_ATTR', 'FILE_IO_PRIORITY_HINT_INFORMATION', 'CRYPT_DIGEST_BLOB', 'PTOKEN_GROUPS', 'TOKEN_ELEVATION', 'tagBITMAPINFOHEADER', '_FILE_FULL_EA_INFORMATION', 'tagORPCTHIS', '_ACCESS_DENIED_OBJECT_ACE', 'PPROCESS_MITIGATION_DEP_POLICY', '_ACCESS_ALLOWED_ACE', 'TOKEN_GROUPS_AND_PRIVILEGES', '_IMAGE_BASE_RELOCATION', 'PFILE_FS_ATTRIBUTE_INFORMATION', 'COSERVERINFO', 'SECURITY_DESCRIPTOR', 'CTL_ENTRY', 'LPBITMAPCOREINFO', 'LPFUNCDESC', 'FILE_FS_FULL_SIZE_INFORMATION', 'PCRL_INFO', '_WOW64_FLOATING_SAVE_AREA', '_CLIENT_ID32', 'CRYPT_ENCRYPT_MESSAGE_PARA', 'CERT_CHAIN_PARA', '_STARTUPINFOEXW', 'PALPC_CONTEXT_ATTR', 'STARTUPINFOEXW', '_CRYPT_KEY_PROV_PARAM', 'PALPC_DATA_VIEW_ATTR32', '_DEBUG_PROCESSOR_IDENTIFICATION_ALL', 'TOKEN_STATISTICS', 'TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', '_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY', 'DEBUG_PROCESSOR_IDENTIFICATION_IA64', 'PCMSG_SIGNER_INFO', 'PFILE_ACCESS_INFORMATION', '_SYSTEM_MODULE32', 'PMIB_UDP6TABLE_OWNER_PID', 'PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY', 'TOKEN_PRIVILEGES', 'SECURITY_QUALITY_OF_SERVICE', '_RPC_IF_ID', 'SYSTEM_ALARM_CALLBACK_ACE', 'COAUTHINFO', 'CRYPT_DER_BLOB', '_API_SET_NAMESPACE_ARRAY', 'PSPC_SERIALIZED_OBJECT', 'PIMAGE_BASE_RELOCATION', 'ACCESS_ALLOWED_CALLBACK_OBJECT_ACE', 'tagVARDESC', 'PSYMBOL_INFO', 'STARTUPINFOEXA', '_ALPC_TOKEN_ATTR', 'PALPC_DIRECT_ATTR32', 'PCRYPT_ATTR_BLOB', '_TOKEN_STATISTICS', 'SIP_INDIRECT_DATA', 'PPSAPI_WORKING_SET_INFORMATION32', '_DEBUG_SYMBOL_PARAMETERS', 'PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', 'PCTL_CONTEXT', 'KEY_VALUE_FULL_INFORMATION', '_SYSTEM_PROCESS_TRUST_LABEL_ACE', '_PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION', 'PCERT_KEY_CONTEXT', '_PROCESS_MEMORY_COUNTERS', 'REFCLSID', 'GUID', 'CRYPT_KEY_VERIFY_MESSAGE_PARA', 'PCRL_CONTEXT', 'LSA_UNICODE_STRING', 'PCRYPT_UINT_BLOB', 'PDEBUG_REGISTER_DESCRIPTION', '_MIB_TCPROW', 'PPORT_MESSAGE64', '_SYMBOL_INFO', 'PMIB_TCP6TABLE_OWNER_PID', 'LPSYSTEMTIME', 'CRYPT_UINT_BLOB', 'CLIENT_ID32', 'PALPC_TOKEN_ATTR', 'PCRYPT_BIT_BLOB', 'ALPC_DIRECT_ATTR', 'MEMORY_BASIC_INFORMATION64', '__MIDL_XmitDefs_0001', 'PSPC_LINK', 'PPUBLIC_OBJECT_BASIC_INFORMATION', 'LPTHREADENTRY32', '_RIP_INFO', 'CATALOG_INFO_', 'PTOKEN_DEFAULT_DACL', 'PSTRING', 'SAFEARRAY', 'OBJECT_DIRECTORY_INFORMATION', '_ALPC_SECURITY_ATTR', 'PPSAPI_WORKING_SET_BLOCK64', 'ENUM_SERVICE_STATUS_PROCESSA', 'PAPI_SET_NAMESPACE_ENTRY_V2', 'PCANSI_STRING', '_ALPC_SECURITY_ATTR32', 'PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE', '_SECURITY_ATTRIBUTES', '_LOAD_DLL_DEBUG_INFO', '_EVT_VARIANT', 'IO_STATUS_BLOCK', '_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY', 'PTOKEN_MANDATORY_LABEL', '_API_SET_NAMESPACE_ENTRY_V2', 'LPELEMDESC', 'PSID_AND_ATTRIBUTES', 'ALPC_SECURITY_ATTR32', 'PIMAGEHLP_MODULE64', '_CLAIM_SECURITY_ATTRIBUTE_V1', 'ALPC_DATA_VIEW_ATTR32', 'TMP_CONTEXT64_SUBUNION', 'API_SET_NAMESPACE_ENTRY_V6', 'DEBUG_PROCESSOR_IDENTIFICATION_X86', 'DEBUG_VALUE_TMP_SUBSTRUCT1', '_API_SET_NAMESPACE_ARRAY_V4', '_IMAGE_NT_HEADERS64', 'PCURDIR', 'tagTLIBATTR', 'PCRYPT_KEY_PROV_INFO', 'TOKEN_DEFAULT_DACL', '_DEBUG_VALUE_TMP_SUBSTRUCT2', 'DEBUG_LAST_EVENT_INFO_EXCEPTION', 'CRYPT_SIGN_MESSAGE_PARA', '_DEBUG_VALUE_TMP_SUBSTRUCT1', 'PCRYPT_KEY_VERIFY_MESSAGE_PARA', '_TMP_UNION_DEBUG_INFO', 'PFILE_IO_PRIORITY_HINT_INFORMATION', 'PCERT_CHAIN_ELEMENT', 'PPSAPI_WORKING_SET_EX_BLOCK64', 'PMEMORY_BASIC_INFORMATION', 'PMEMORY_BASIC_INFORMATION32', 'PAPI_SET_NAMESPACE_ARRAY_V4', '_IMAGE_DATA_DIRECTORY', '_KEY_VALUE_FULL_INFORMATION', '_ANON_PEB_SYSTEM_DEPENDENT_03', '_CRL_CONTEXT', 'OBJECT_ATTRIBUTES', 'PCRYPT_DATA_BLOB', '_ANON_PEB_SYSTEM_DEPENDENT_07', 'PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY', '_THREAD_BASIC_INFORMATION', '_ANON_PROCESS_MITIGATION_ASLR_POLICY_UNION', '_CALLFRAMEINFO', 'PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE', 'tagBITMAPFILEHEADER', '_PORT_MESSAGE32_TMP_UNION', 'LPCREATE_THREAD_DEBUG_INFO', '_DEBUG_LAST_EVENT_INFO_BREAKPOINT', 'PCRYPT_DER_BLOB', '_LUID', 'IID', 'PDEBUG_SYMBOL_SOURCE_ENTRY', 'PFILE_INTERNAL_INFORMATION', 'PAPI_SET_NAMESPACE_ARRAY_V2', 'PCTL_USAGE', 'DEBUG_EVENT', 'PCRYPT_HASH_MESSAGE_PARA', 'PLIST_ENTRY', 'DEBUG_OFFSET_REGION', '_EVENTLOGRECORD', 'EXCEPTION_DEBUG_INFO', '_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO', 'PSAPI_WORKING_SET_BLOCK64', 'CERT_RDN_VALUE_BLOB', 'DEBUG_STACK_FRAME', 'LIST_ENTRY', 'CRYPTCATATTRIBUTE_', '_OSVERSIONINFOW', '_PSAPI_WORKING_SET_EX_BLOCK64', 'PALPC_CONTEXT_ATTR64', 'PCERT_ID', 'PFILE_FS_DEVICE_INFORMATION', 'PRTL_USER_PROCESS_PARAMETERS', 'PCRYPTCATATTRIBUTE', '_PSAPI_WORKING_SET_EX_INFORMATION', 'CERT_ENHKEY_USAGE', 'PSYSTEM_SCOPED_POLICY_ID_ACE', '_CALLFRAMEPARAMINFO', 'PFILE_FS_FULL_SIZE_INFORMATION', 'CERT_ISSUER_SERIAL_NUMBER', 'LPEVENTLOG_FULL_INFORMATION', '_OSVERSIONINFOA', 'CERT_REVOCATION_CRL_INFO', 'PSAPI_WORKING_SET_BLOCK', 'PBITMAPINFO', 'PRGBTRIPLE', '_SYSTEM_ALARM_OBJECT_ACE', 'LPSTARTUPINFOEXA', 'PROCESSENTRY32', '_TOKEN_MANDATORY_POLICY', '_MIB_UDP6TABLE_OWNER_PID', '__PUBLIC_OBJECT_TYPE_INFORMATION', 'LUID_AND_ATTRIBUTES', 'WOW64_CONTEXT', '_CERT_USAGE_MATCH', 'IMAGE_NT_HEADERS64', 'ACL_REVISION_INFORMATION', 'PDEBUG_SYMBOL_ENTRY', 'tagEXCEPINFO', 'CREATE_THREAD_DEBUG_INFO', 'PWINTRUST_FILE_INFO', '_ANON_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_BITFIELD', 'tagPARAMDESCEX', '_CRYPT_DECRYPT_MESSAGE_PARA', 'SYSTEM_AUDIT_OBJECT_ACE', 'PFILE_FS_VOLUME_INFORMATION', 'PCERT_SIMPLE_CHAIN', '_MIB_TCPTABLE_OWNER_PID', '_ACCESS_ALLOWED_OBJECT_ACE', '_DEBUG_OFFSET_REGION', 'PACL_SIZE_INFORMATION', 'PSAPI_WORKING_SET_EX_INFORMATION64', 'PRTL_OSVERSIONINFOEXW', '_RTL_USER_PROCESS_PARAMETERS', 'LPPARAMDESC', 'PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY', 'BG_JOB_TIMES', '_SYSTEM_VERIFIER_INFORMATION', '_TMPUNION_CMSG_CTRL_DECRYPT_PARA', '_TMP_WINTRUST_UNION_TYPE', 'RPC_IF_ID', 'UNICODE_STRING', 'PTOKEN_SOURCE', '_CONTEXT32', 'CERT_EXTENSION', '_PORT_MESSAGE64', 'RTL_DRIVE_LETTER_CURDIR', '_TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION', '_EXCEPTION_DEBUG_INFO', '_TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', 'PALPC_DATA_VIEW_ATTR64', '_PEB_LDR_DATA', '_TMP_DUMMYSTRUCTNAME', '_TOKEN_SECURITY_ATTRIBUTE_V1_UNION', 'SYSTEM_MODULE32', 'PMIB_UDPTABLE_OWNER_PID', '_ACCESS_DENIED_ACE', 'CRYPT_ATTRIBUTES', 'CRYPTCATATTRIBUTE', '_RTL_RELATIVE_NAME_U', 'PSAPI_WORKING_SET_EX_INFORMATION32', 'PSYSTEM_ALARM_CALLBACK_OBJECT_ACE', '_TOKEN_ELEVATION', '_DEBUG_PROCESSOR_IDENTIFICATION_IA64', '_XSAVE_FORMAT_32', 'MIDL_XmitDefs_0001', 'ACCESS_ALLOWED_OBJECT_ACE', '_ANON_TMP_variant_sub_union', 'COMVERSION', 'PCRYPT_DECRYPT_MESSAGE_PARA', 'PACL', 'PKEY_VALUE_BASIC_INFORMATION', 'SIP_INDIRECT_DATA_', 'MIB_TCP6ROW_OWNER_PID', 'WINTRUST_CERT_INFO_', 'SID_IDENTIFIER_AUTHORITY', 'ALPC_DATA_VIEW_ATTR64', 'PKEY_VALUE_FULL_INFORMATION', '_FILE_FS_FULL_SIZE_INFORMATION', 'ALPC_PORT_ATTRIBUTES64', 'LDR_DATA_TABLE_ENTRY', '_PORT_MESSAGE_TMP_SUBSTRUCT_S1', '_PORT_MESSAGE_TMP_SUBSTRUCT_S2', 'TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE', 'RTL_OSVERSIONINFOW', 'IMAGE_IMPORT_BY_NAME', '_ALPC_DATA_VIEW_ATTR64', 'PBITMAPFILEHEADER', 'RGBTRIPLE', '_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE', 'ALPC_DIRECT_ATTR64', 'PEB', 'PDEBUG_SYMBOL_PARAMETERS', 'FUNCDESC', '_IMAGE_IMPORT_DESCRIPTOR', 'CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO', '_MIB_IFROW', 'PSOLE_AUTHENTICATION_SERVICE', '_TOKEN_MANDATORY_LABEL', '_DEBUG_VALUE_TMP_SUBSTRUCT3', 'TMP_lowmid_union', 'CLIENT_ID64', '_MIB_UDPTABLE_OWNER_PID', '_SYSTEM_HANDLE', 'CERT_USAGE_MATCH', 'API_SET_NAMESPACE_ARRAY_V2', 'DEBUG_SYMBOL_PARAMETERS', 'DEBUG_MODULE_PARAMETERS', 'PMODLOAD_DATA', 'tagPROCESSENTRY32', '_ANON_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_BITFIELD', 'SYSTEM_MODULE_INFORMATION32', '_RTL_UNLOAD_EVENT_TRACE64', '_FILE_ACCESS_INFORMATION', 'API_SET_NAMESPACE_V6', '_API_SET_NAMESPACE_V6', 'PIMAGE_SECTION_HEADER', 'TMPUNION_CMSG_CTRL_DECRYPT_PARA', 'DEBUG_PROCESSOR_IDENTIFICATION_ALL', 'ACCESS_DENIED_ACE', 'CERT_STRONG_SIGN_PARA', 'PCERT_CHAIN_CONTEXT', 'PPSAPI_WORKING_SET_EX_BLOCK32', '_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION', '_TOKEN_ORIGIN', 'EXIT_THREAD_DEBUG_INFO', 'THREADENTRY32', 'PIMAGE_IMPORT_DESCRIPTOR', '_ALPC_HANDLE_ATTR64', 'PSID_IDENTIFIER_AUTHORITY', '_SID_AND_ATTRIBUTES_HASH', '_PUBLIC_OBJECT_BASIC_INFORMATION', 'PPSAPI_WORKING_SET_BLOCK32', 'REMOTE_PORT_VIEW', 'MIB_IFTABLE', '_CERT_ISSUER_SERIAL_NUMBER', 'CRYPTCATMEMBER_', '_API_SET_NAMESPACE_ENTRY', 'ELEMDESC', 'MODLOAD_DATA', 'LPBINDPTR', '_MIB_TCP6TABLE_OWNER_PID', '_API_SET_VALUE_ARRAY_V2', '_DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR', 'POBJECT_DIRECTORY_INFORMATION', '_CERT_KEY_CONTEXT', 'PEXCEPTION_RECORD32', 'LPVARIANT', 'API_SET_NAMESPACE_ENTRY_V2', 'ALPC_HANDLE_ATTR32', 'PPROCESSENTRY32W', 'DECIMAL', 'SID_AND_ATTRIBUTES', 'PCRYPT_SIGN_MESSAGE_PARA', 'FILE_FS_SECTOR_SIZE_INFORMATION', 'EXCEPTION_RECORD64', 'LOCALTHIS', '_ENUM_SERVICE_STATUS_PROCESSW', '_MIB_UDPROW_OWNER_PID', 'SYMBOL_INFO', '_CRYPT_ENCODE_PARA', '_ANON_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_UNION', 'PDEBUG_VALUE', '_CERT_INFO', '_CRYPT_KEY_PROV_INFO', 'PACCESS_ALLOWED_ACE', '_SYSTEM_MODULE_INFORMATION32', 'PSYSTEM_MODULE_INFORMATION64', 'PROCESSENTRY32W', 'PALPC_DIRECT_ATTR', 'PDEBUG_LAST_EVENT_INFO_SYSTEM_ERROR', '_LUID_AND_ATTRIBUTES', 'PALPC_SECURITY_ATTR', 'API_SET_NAMESPACE_ENTRY_V4', 'DEBUG_LAST_EVENT_INFO_LOAD_MODULE', '_DEBUG_LAST_EVENT_INFO_EXIT_THREAD', '_SYSTEM_MODULE_INFORMATION64', 'WINTRUST_CATALOG_INFO', 'DEBUG_VALUE_TMP_SUBSTRUCT2', 'PPROCESS_MITIGATION_ASLR_POLICY', '_FILE_GET_EA_INFORMATION', 'ALPC_CONTEXT_ATTR', 'PPSAPI_WORKING_SET_INFORMATION', '_EXCEPTION_RECORD64', 'LPPROCESSENTRY32W', 'PFILE_FS_CONTROL_INFORMATION', 'PDEBUG_PROCESSOR_IDENTIFICATION_ARM', 'PRLIST_ENTRY', 'POSVERSIONINFOA', '_CERT_SIMPLE_CHAIN', '_CRYPT_ENCRYPT_MESSAGE_PARA', 'LUID', '_CERT_CONTEXT', 'TOKEN_USER', 'EVT_VARIANT', 'CRL_INFO', 'LPPROCESS_INFORMATION', 'CLIENT_ID', 'CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', 'tagRGBTRIPLE', 'PTHREADENTRY32', 'PMIB_IPADDRTABLE', 'CTL_INFO', '_ENUM_SERVICE_STATUS_PROCESSA', 'PCRL_BLOB', 'LPWNDCLASSEXA', 'PCERT_EXTENSIONS', 'PAPI_SET_VALUE_ENTRY', 'POSVERSIONINFOW', 'TMP_SPC_LINK_UNION', 'PROCESS_MEMORY_COUNTERS_EX', 'PDEBUG_OFFSET_REGION', '_IMAGE_FILE_HEADER', 'EXCEPTION_RECORD', 'FILE_MODE_INFORMATION', 'CRYPT_ATTRIBUTE_TYPE_VALUE', 'PALPC_DATA_VIEW_ATTR', '_CMSG_RECIPIENT_ENCODE_INFO', '_FILE_STREAM_INFORMATION', '_OVERLAPPED', '_FILE_BASIC_INFORMATION', 'PLSA_UNICODE_STRING', '_CTL_INFO', 'PACCESS_ALLOWED_OBJECT_ACE', 'PDEBUG_LAST_EVENT_INFO_LOAD_MODULE', 'PALPC_CONTEXT_ATTR32', '_CALLFRAME_MARSHALCONTEXT', '_OBJECT_DIRECTORY_INFORMATION', 'PIMAGE_NT_HEADERS32', 'PSAPI_WORKING_SET_INFORMATION32', 'PCERT_CHAIN_PARA', 'LPSAFEARRAYBOUND', 'ALPC_WORK_ON_BEHALF_ATTR', 'PCONTEXT32', 'PTOKEN_SECURITY_ATTRIBUTE_V1', 'ACCESS_ALLOWED_CALLBACK_ACE', 'WINTRUST_CERT_INFO', '_ACL', 'CRL_BLOB', 'PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1', 'PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY', 'POBJECT_ATTRIBUTES', 'PCERT_CHAIN_ENGINE_CONFIG', 'PALPC_MESSAGE_ATTRIBUTES', 'SYSTEM_RESOURCE_ATTRIBUTE_ACE', 'PTOKEN_ELEVATION', 'PFILE_EA_INFORMATION', 'PPEB_LDR_DATA', '_CRL_INFO', 'KEY_VALUE_PARTIAL_INFORMATION', '_CERT_EXTENSION', 'tagWNDCLASSEXA', '_PORT_MESSAGE32', 'PCERT_REVOCATION_CRL_INFO', 'ACCESS_ALLOWED_ACE', 'CERT_EXTENSIONS', '_BG_FILE_PROGRESS', 'RTL_OSVERSIONINFOEXW', 'PFILE_DISPOSITION_INFORMATION', '_CTL_ENTRY', 'TOKEN_SECURITY_ATTRIBUTE_V1_UNION', 'LPBITMAPINFOHEADER', '_IMAGE_OPTIONAL_HEADER64', 'PALPC_WORK_ON_BEHALF_ATTR', 'MIB_IFROW', 'EXCEPTION_RECORD32', 'SYSTEM_PROCESS_TRUST_LABEL_ACE', '_PROCESS_INFORMATION', '_CERT_CHAIN_CONTEXT', '_SYSTEM_HANDLE_INFORMATION', '_MIB_UDP6ROW_OWNER_PID', 'LPSTARTUPINFOW', 'PTOKEN_ORIGIN', 'EVENTLOGRECORD', '_LSA_UNICODE_STRING', '_MIB_IPADDRTABLE', '_FILE_MODE_INFORMATION', 'PARAMDESC', '_ANON_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_BITFIELD', 'PM128A', 'TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION', 'CRL_CONTEXT', 'PPSAPI_WORKING_SET_EX_BLOCK', '_CERT_STRONG_SIGN_SERIALIZED_INFO', 'ALPC_PORT_ATTRIBUTES32', '_FILE_FS_ATTRIBUTE_INFORMATION', 'PMIB_TCPROW_OWNER_PID', 'DEBUG_SYMBOL_ENTRY', '_DEBUG_STACK_FRAME', 'PPROCESS_BASIC_INFORMATION', 'tagWNDCLASSEXW', '_WOW64_CONTEXT', 'tagTYPEATTR', 'ALPC_TOKEN_ATTR', '_UNLOAD_DLL_DEBUG_INFO', '_ALPC_DATA_VIEW_ATTR32', 'PFILE_NAME_INFORMATION', '_CRYPT_ATTRIBUTES', 'IP_INTERFACE_INFO', '_API_SET_VALUE_ARRAY_V4', 'PAPI_SET_VALUE_ARRAY_V2', 'CREATE_PROCESS_DEBUG_INFO', '_COAUTHIDENTITY', 'tagDISPPARAMS', 'PIP_INTERFACE_INFO', 'PFILE_ATTRIBUTE_TAG_INFORMATION', '_ANON_PEB_SYSTEM_DEPENDENT_02', 'PCERT_PUBLIC_KEY_INFO', '_PROCESS_MITIGATION_IMAGE_LOAD_POLICY', '_SYSTEM_RESOURCE_ATTRIBUTE_ACE', 'PCMSG_RECIPIENT_ENCODE_INFO', 'WINTRUST_SGNR_INFO', 'tagMULTI_QI', 'PALPC_HANDLE_ATTR64', 'PSAPI_WORKING_SET_BLOCK32', '_TOKEN_APPCONTAINER_INFORMATION', 'PRTL_UNLOAD_EVENT_TRACE', 'PSECURITY_ATTRIBUTES', 'PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY', 'PARAMDESCEX', 'PWINTRUST_CERT_INFO', '_TMP_signscale', '_API_SET_NAMESPACE_ENTRY_V6', '_SYSTEM_ALARM_CALLBACK_ACE', 'BITMAPINFO', 'CRYPTCATMEMBER', '_ITEMIDLIST', '_ANON_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_BITFIELD', 'CERT_CONTEXT', 'PRTLP_CURDIR_REF', '_BG_FILE_INFO', '_ANON_PEB_SYSTEM_DEPENDENT_06', 'LPRGBTRIPLE', 'ALPC_SERVER_INFORMATION_TMP_IN', '_RTLP_CURDIR_REF', '_OUTPUT_DEBUG_STRING_INFO', 'PDEBUG_PROCESSOR_IDENTIFICATION_AMD64', 'TOKEN_MANDATORY_POLICY', 'TOKEN_APPCONTAINER_INFORMATION', 'PRTL_DRIVE_LETTER_CURDIR', '_PORT_MESSAGE64_TMP_UNION', 'PSYSTEM_ALARM_OBJECT_ACE', '_SYSTEM_AUDIT_ACE', 'PDEBUG_LAST_EVENT_INFO_EXIT_THREAD', '_CONTEXT64', 'FILE_FS_DRIVER_PATH_INFORMATION', 'PBITMAPINFOHEADER', 'SYSTEM_MODULE_INFORMATION64', 'tagSAFEARRAY', 'DEBUG_MODULE_AND_ID', 'LPCLSID', '_CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION', 'WINTRUST_BLOB_INFO_', '_ANON_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_BITFIELD', '_SID_IDENTIFIER_AUTHORITY', '_CMSG_STREAM_INFO', '_ALPC_SERVER_INFORMATION_TMP_IN', 'PWOW64_CONTEXT', 'PPROCESS_MITIGATION_DYNAMIC_CODE_POLICY', 'CRYPT_BIT_BLOB', 'FILE_STREAM_INFORMATION', 'RTLP_CURDIR_REF', 'DEBUG_EXCEPTION_FILTER_PARAMETERS', 'FILE_FS_LABEL_INFORMATION', '_WINTRUST_DATA', 'TYPEATTR', 'RTL_RELATIVE_NAME_U', 'DEBUG_LAST_EVENT_INFO_EXIT_THREAD', 'PCRYPT_ENCODE_PARA', '_FILE_FS_SECTOR_SIZE_INFORMATION', '_ALPC_SERVER_INFORMATION_TMP_OUT', 'FILE_INTERNAL_INFORMATION', 'FILE_ALL_INFORMATION', '_IP_ADAPTER_INDEX_MAP', '_API_SET_NAMESPACE_ENTRY_V4', 'PEXCEPTION_POINTERS64', 'PPROCESS_INSTRUMENTATION_CALLBACK_INFORMATION', 'PDEBUG_SPECIFIC_FILTER_PARAMETERS', 'MIB_TCPROW_OWNER_PID', 'FILE_ACCESS_INFORMATION', 'FILE_NETWORK_OPEN_INFORMATION', '_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', '_API_SET_NAMESPACE_ARRAY_V2', 'PMIB_TCP6ROW_OWNER_PID', 'PROCESS_INFORMATION', 'PWINTRUST_SGNR_INFO', 'BITMAPFILEHEADER', 'CONTEXT64', '_CERT_ID', '_FILE_ATTRIBUTE_TAG_INFORMATION', 'JIT_DEBUG_INFO', 'PFILE_BASIC_INFORMATION', 'IMAGE_IMPORT_DESCRIPTOR', 'PACL_REVISION_INFORMATION', 'PEXCEPTION_RECORD64', 'PCERT_NAME_BLOB', 'PLUID', 'CRYPT_DECRYPT_MESSAGE_PARA', '_CERT_EXTENSIONS', 'PIMAGE_IMPORT_BY_NAME', 'PCCERT_SIMPLE_CHAIN', 'SPC_LINK', 'PMIB_IFTABLE', 'IMAGE_OPTIONAL_HEADER32', 'PALPC_PORT_ATTRIBUTES64', 'CRYPT_HASH_BLOB', 'PCIDLIST_ABSOLUTE', 'ALPC_CONTEXT_ATTR64', 'BG_FILE_PROGRESS', 'LPSERVICE_STATUS', 'MIB_TCPROW', 'PAPI_SET_NAMESPACE_ENTRY', 'PSAPI_WORKING_SET_EX_BLOCK', '_CERT_REVOCATION_INFO', 'PCRYPT_ALGORITHM_IDENTIFIER', '_DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE', 'PCRYPT_KEY_PROV_PARAM', 'LPOUTPUT_DEBUG_STRING_INFO', 'CRYPT_ATTRIBUTE', 'PCRYPT_VERIFY_MESSAGE_PARA', 'CERT_BLOB', 'tagTHREADENTRY32', 'CMSG_RECIPIENT_ENCODE_INFO', 'PCTL_INFO', 'CERT_SIMPLE_CHAIN', '_FILE_EA_INFORMATION', '_ANON_PROCESS_MITIGATION_DEP_POLICY_BITFIELD', 'PCCERT_CHAIN_CONTEXT', 'REFIID', '_PSAPI_WORKING_SET_EX_INFORMATION64', '_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1', '_MIB_IPADDRROW_XP', '_SHITEMID', 'SYSTEM_SCOPED_POLICY_ID_ACE', 'IMAGEHLP_MODULE64', '_ANON_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_UNION', 'PCERT_TRUST_STATUS', 'PROCESS_MITIGATION_ASLR_POLICY', 'PCMSG_ENVELOPED_ENCODE_INFO', 'PAPI_SET_NAMESPACE_ENTRY_V4', '_CTL_CONTEXT', 'SOLE_AUTHENTICATION_SERVICE', '_DEBUG_REGISTER_DESCRIPTION', 'LPVARIANTARG', 'PEVENTLOGRECORD', 'PSYSTEM_ALARM_CALLBACK_ACE', 'PSAPI_WORKING_SET_EX_BLOCK64', 'SYSTEM_ALARM_ACE', '_IMAGE_EXPORT_DIRECTORY', 'PFILE_FS_LABEL_INFORMATION', '_DEBUG_LAST_EVENT_INFO_EXIT_PROCESS', 'CLSID', 'DEBUG_LAST_EVENT_INFO_EXIT_PROCESS', 'API_SET_VALUE_ARRAY_V2', 'OSVERSIONINFOEXW', 'PSYSTEM_MANDATORY_LABEL_ACE', 'PBITMAP', 'TOKEN_PRIMARY_GROUP', 'TOKEN_OWNER', 'PFILE_FS_SECTOR_SIZE_INFORMATION', 'PAPI_SET_VALUE_ENTRY_V2', 'ALPC_SECURITY_ATTR', 'PCLAIM_SECURITY_ATTRIBUTE_V1', '_DEBUG_LAST_EVENT_INFO_EXCEPTION', '_SERVICE_STATUS', 'PSYSTEM_HANDLE_INFORMATION', 'FILE_GET_EA_INFORMATION', 'TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', '_TOKEN_GROUPS_AND_PRIVILEGES', 'CERT_CHAIN_ELEMENT', 'DEBUG_SYMBOL_SOURCE_ENTRY', '_ACL_REVISION_INFORMATION', 'CMSG_SIGNER_INFO', '_SYSTEM_MANDATORY_LABEL_ACE', '_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY', 'PTOKEN_PRIVILEGES', '_MIB_TCPROW_OWNER_PID', 'PRTL_UNLOAD_EVENT_TRACE32', '_CERT_PUBLIC_KEY_INFO', 'tagCOMVERSION', 'PCERT_ENHKEY_USAGE', 'ENUM_SERVICE_STATUS_PROCESSW', '_ALPC_PORT_ATTRIBUTES32', 'PIMAGE_NT_HEADERS64', 'ORPCTHIS', 'tagPROCESSENTRY32W', 'PXSAVE_FORMAT_64', 'PBITMAPCOREHEADER', 'CLAIM_SECURITY_ATTRIBUTES_INFORMATION', '_PORT_VIEW', 'PCRYPT_ATTRIBUTE', 'IMAGE_EXPORT_DIRECTORY', '_CMSG_ENVELOPED_ENCODE_INFO', 'PIP_ADAPTER_INDEX_MAP', 'PEB_LDR_DATA', 'IMAGE_BASE_RELOCATION', 'TOKEN_LINKED_TOKEN', 'PCERT_TRUST_LIST_INFO', 'PDEBUG_LAST_EVENT_INFO_EXIT_PROCESS', 'PMEMORY_BASIC_INFORMATION64', 'CALLFRAME_MARSHALCONTEXT', '_FILE_INTERNAL_INFORMATION', 'PCERT_INFO', '_OBJECT_ATTRIBUTES', 'CRYPT_KEY_PROV_INFO', '_SPC_SERIALIZED_OBJECT', 'SPC_LINK_', '_DEBUG_SPECIFIC_FILTER_PARAMETERS', 'PPSAPI_WORKING_SET_BLOCK', 'FILE_FS_SIZE_INFORMATION', 'ALPC_SECURITY_ATTR64', '_SYSTEM_ALARM_ACE', 'FILE_FS_OBJECTID_INFORMATION', '_PSAPI_WORKING_SET_BLOCK32', 'PTOKEN_GROUPS_AND_PRIVILEGES', '_PSAPI_WORKING_SET_INFORMATION32', 'CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE', 'FILE_BASIC_INFORMATION', 'PCRYPT_OBJID_BLOB', '_FILE_FS_OBJECTID_INFORMATION', 'CRYPT_ATTR_BLOB', 'M128A', 'PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION', 'CTL_USAGE', '_FILE_ALIGNMENT_INFORMATION', '_DEBUG_PROCESSOR_IDENTIFICATION_ALPHA', 'LPOSVERSIONINFOA', 'tagFUNCDESC', '_SYSTEM_SCOPED_POLICY_ID_ACE', 'PCERT_STRONG_SIGN_SERIALIZED_INFO', '_CLAIM_SECURITY_ATTRIBUTES_INFORMATION', '_SYSTEM_AUDIT_CALLBACK_ACE', '_XSAVE_FORMAT_64', 'SYSTEM_ALARM_CALLBACK_OBJECT_ACE', '_ANON_PROCESS_MITIGATION_ASLR_POLICY_BITFIELD', 'PCERT_STRONG_SIGN_PARA', 'LPENUM_SERVICE_STATUS_PROCESSA', 'tagPARAMDESC', '_TMPUNION_CERT_ID', 'LPTLIBATTR', 'PCCTL_CONTEXT', 'PSAPI_WORKING_SET_INFORMATION64', 'PTOKEN_ACCESS_INFORMATION', 'PTOKEN_SECURITY_ATTRIBUTES_INFORMATION', '_PEB', '_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', '_OSVERSIONINFOEXW', '_DEBUG_MODULE_AND_ID', 'CALLFRAMEPARAMINFO', '_FLOATING_SAVE_AREA', 'CATALOG_INFO', 'VARIANT', '_RTL_UNLOAD_EVENT_TRACE32', '_CREATE_PROCESS_DEBUG_INFO', 'PCRYPT_DIGEST_BLOB', 'LPPARAMDESCEX', 'PSYSTEMTIME', '_OSVERSIONINFOEXA', '_COSERVERINFO', '_TMP_lowmid', 'PPEB', 'PCRYPT_INTEGER_BLOB', 'PCERT_BLOB', '_ALPC_CONTEXT_ATTR32', '_FILE_STANDARD_INFORMATION', 'MEMORY_BASIC_INFORMATION', '_PORT_MESSAGE_TMP_UNION_U2', '_CERT_CHAIN_ENGINE_CONFIG', '_PORT_MESSAGE_TMP_UNION_U1', '_IP_INTERFACE_INFO', '_tagBRECORD', '_LDR_DATA_TABLE_ENTRY', 'LPEXIT_PROCESS_DEBUG_INFO', 'PCERT_REVOCATION_INFO', 'DEBUG_PROCESSOR_IDENTIFICATION_ALPHA', 'PEVT_VARIANT', 'CERT_CHAIN_CONTEXT', '_ANON_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_BITFIELD', 'PACCESS_DENIED_CALLBACK_OBJECT_ACE', 'PTOKEN_MANDATORY_POLICY', 'DEBUG_VALUE', 'ALPC_SERVER_INFORMATION', 'PIMAGE_DATA_DIRECTORY', '_ANON_PROCESS_MITIGATION_DEP_POLICY_UNION', 'PROCESS_MITIGATION_DEP_POLICY', 'PDEBUG_PROCESSOR_IDENTIFICATION_IA64', '_SYSTEM_AUDIT_OBJECT_ACE', '_MEMORY_BASIC_INFORMATION64', 'PORT_MESSAGE32', 'CRYPT_OBJID_BLOB', '_STARTUPINFOA', '_ALPC_HANDLE_ATTR', 'TOKEN_SOURCE', 'PALPC_SECURITY_ATTR32', '_STARTUPINFOW', '_CRYPT_BIT_BLOB', 'CERT_TRUST_STATUS', '_ALPC_DIRECT_ATTR', 'FILE_IS_REMOTE_DEVICE_INFORMATION', 'PFILE_GET_EA_INFORMATION', 'CERT_CHAIN_ENGINE_CONFIG', 'PPSAPI_WORKING_SET_EX_INFORMATION32', 'SYSTEM_AUDIT_CALLBACK_ACE', 'SYSTEM_VERIFIER_INFORMATION', 'CRL_ENTRY', '_PSAPI_WORKING_SET_INFORMATION64', 'PSAPI_WORKING_SET_EX_INFORMATION', 'PTOKEN_USER', 'PDEBUG_LAST_EVENT_INFO_UNLOAD_MODULE', '_ACCESS_DENIED_CALLBACK_OBJECT_ACE', 'DEBUG_PROCESSOR_IDENTIFICATION_ARM', 'PALPC_PORT_ATTRIBUTES32', 'NPBITMAP', '_PSAPI_WORKING_SET_EX_INFORMATION32', 'ALPC_CONTEXT_ATTR32', 'RGBQUAD', '_ACCESS_ALLOWED_CALLBACK_ACE', 'TMP_DUMMYSTRUCTNAME', 'PSYSTEM_MODULE_INFORMATION32', 'PBITMAPCOREINFO', 'CRYPT_VERIFY_MESSAGE_PARA', 'PCERT_USAGE_MATCH', 'PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO', '_DEBUG_PROCESSOR_IDENTIFICATION_AMD64', 'ACL_SIZE_INFORMATION', 'TOKEN_GROUPS', 'COAUTHIDENTITY', 'LPOVERLAPPED', '_MEMORY_BASIC_INFORMATION32', 'KEY_VALUE_BASIC_INFORMATION', 'PEXCEPTION_POINTERS32', 'PSECURITY_QUALITY_OF_SERVICE', 'PSYSTEM_AUDIT_CALLBACK_ACE', 'DEBUG_PROCESSOR_IDENTIFICATION_AMD64', 'PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE', '_SECURITY_DESCRIPTOR', 'SYSTEM_AUDIT_ACE', '_CURDIR', 'PWINTRUST_BLOB_INFO', 'TOKEN_MANDATORY_LABEL', 'API_SET_NAMESPACE_ENTRY', 'CERT_REVOCATION_INFO', '_ANON_PROCESS_MITIGATION_IMAGE_LOAD_POLICY_UNION', 'FLOATING_SAVE_AREA', '_PSAPI_WORKING_SET_EX_BLOCK', 'TMP_TYPEDESC_UNION', 'CRYPT_DATA_BLOB', 'PREMOTE_PORT_VIEW', '_ANON_evt_variant_sub_union', '_PSAPI_WORKING_SET_INFORMATION', 'PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', 'PROCESS_MITIGATION_IMAGE_LOAD_POLICY', 'PLDR_DATA_TABLE_ENTRY', 'RTL_UNLOAD_EVENT_TRACE64', '_FILE_FS_DEVICE_INFORMATION', 'tagSAFEARRAYBOUND', '_CRYPT_ALGORITHM_IDENTIFIER', 'RTL_UNLOAD_EVENT_TRACE', 'PACCESS_DENIED_ACE', '_FILE_ALL_INFORMATION', '_CLIENT_ID64', 'ACCESS_DENIED_OBJECT_ACE', 'PDEBUG_LAST_EVENT_INFO_EXCEPTION', '_CRYPT_KEY_VERIFY_MESSAGE_PARA', '_TOKEN_USER', 'tagIDLDESC', 'OUTPUT_DEBUG_STRING_INFO', 'ALPC_MESSAGE_ATTRIBUTES', '_MODLOAD_DATA', '_TMP_TYPEDESC_UNION', 'PPSAPI_WORKING_SET_EX_INFORMATION64', 'PMIB_TCPTABLE_OWNER_PID', 'PCERT_ISSUER_SERIAL_NUMBER', 'PCTL_ENTRY', 'LPCONTEXT32', 'CALLFRAMEINFO', '_FILE_NETWORK_OPEN_INFORMATION', 'PPORT_MESSAGE32', '_ALPC_HANDLE_ATTR32', '_EXIT_PROCESS_DEBUG_INFO', 'LPWNDCLASSEXW', 'MIB_UDP6TABLE_OWNER_PID', 'LPOSVERSIONINFOW', 'ARRAYDESC', '_ACCESS_DENIED_CALLBACK_ACE', '_FILE_DISPOSITION_INFORMATION', 'PEXCEPTION_RECORD', 'DEBUG_LAST_EVENT_INFO_BREAKPOINT', 'PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', '_ALPC_SECURITY_ATTR64', 'IMAGE_DATA_DIRECTORY', 'BITMAP', 'PKEY_VALUE_PARTIAL_INFORMATION', 'ALPC_HANDLE_ATTR64', '_FILE_FS_DRIVER_PATH_INFORMATION', 'TLIBATTR', 'PFILE_NETWORK_OPEN_INFORMATION', '_CRYPT_ATTRIBUTE_TYPE_VALUE', 'PORT_MESSAGE_TMP_UNION', 'PMIB_IPADDRROW_XP', 'PACCESS_ALLOWED_CALLBACK_OBJECT_ACE', 'PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY', 'STRING', 'PCMSG_STREAM_INFO', 'EXIT_PROCESS_DEBUG_INFO', 'TMP_CERT_STRONG_SIGN_PARA_UNION_TYPE', 'BINDPTR', '_TMP_SPC_LINK_UNION', '_TOKEN_LINKED_TOKEN', 'SYSTEM_ALARM_OBJECT_ACE', '_DEBUG_SYMBOL_ENTRY', 'PCERT_EXTENSION', 'WNDCLASSEXW', 'LPVARDESC', '_EVENTLOG_FULL_INFORMATION', 'PSYSTEM_MODULE64', 'tagBITMAPCOREINFO', 'MIB_UDPROW_OWNER_PID', 'PROCESS_MEMORY_COUNTERS', 'VARIANTARG', '_PROCESS_MITIGATION_ASLR_POLICY', 'PCRYPT_HASH_BLOB', '_CRYPTOAPI_BLOB', '_API_SET_VALUE_ENTRY', 'LPBITMAP', 'PWNDCLASSEXW', '_TOKEN_GROUPS', 'LPSTARTUPINFOEXW', 'SAFEARRAYBOUND', 'LPGUID', '_FILE_FS_CONTROL_INFORMATION', '__tagBRECORD', '_FILE_POSITION_INFORMATION', 'PWNDCLASSEXA', 'PPROCESSENTRY32', '_PSAPI_WORKING_SET_BLOCK', 'API_SET_NAMESPACE_ARRAY', 'PMIB_UDP6ROW_OWNER_PID', 'tagRGBQUAD', 'PMIB_TCPROW', 'OVERLAPPED', 'FILE_NAME_INFORMATION', '_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE', '_ALPC_DATA_VIEW_ATTR', '_DEBUG_VALUE_TMP_UNION', 'TOKEN_SECURITY_ATTRIBUTE_V1', 'UNLOAD_DLL_DEBUG_INFO', '_RTL_UNLOAD_EVENT_TRACE', 'EVENTLOG_FULL_INFORMATION', 'POSVERSIONINFOEXA', '_STRING', '_ALPC_DIRECT_ATTR64', '_TOKEN_DEFAULT_DACL', '_ALPC_CONTEXT_ATTR64', 'TMP_WINTRUST_UNION_TYPE', '_ANON_PEB_UNION_1', '_DEBUG_VALUE', 'MIB_IPADDRROW_XP', 'PCONTEXT64', 'SYSTEMTIME', '_FILE_IS_REMOTE_DEVICE_INFORMATION', '_RTL_DRIVE_LETTER_CURDIR', 'PIMAGE_OPTIONAL_HEADER64', 'CERT_PUBLIC_KEY_INFO', 'BITMAPCOREHEADER', 'DEBUG_SPECIFIC_FILTER_PARAMETERS', 'IMAGE_SECTION_HEADER', 'ACL', 'API_SET_VALUE_ENTRY', 'PCCERT_CHAIN_ELEMENT', '_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY', 'CERT_KEY_CONTEXT', 'DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE', '_MEMORY_BASIC_INFORMATION', '_CERT_CHAIN_PARA', 'PACCESS_ALLOWED_CALLBACK_ACE', 'PPROCESS_INFORMATION', 'LPBITMAPINFO', '_CERT_STRONG_SIGN_PARA', '_BG_JOB_TIMES', '_EXCEPTION_RECORD32', '_SYSTEM_ALARM_CALLBACK_OBJECT_ACE', 'CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE', 'ALPC_DATA_VIEW_ATTR', 'PDEBUG_EXCEPTION_FILTER_PARAMETERS', '_CTL_USAGE', 'PCCRL_CONTEXT', 'LPOSVERSIONINFOEXW', 'TMPUNION_CERT_ID', 'CERT_NAME_BLOB', 'PWINTRUST_DATA', 'CLAIM_SECURITY_ATTRIBUTE_V1', 'CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION', 'PSYSTEM_VERIFIER_INFORMATION', 'FILE_FS_ATTRIBUTE_INFORMATION', 'SPC_SERIALIZED_OBJECT', 'TYPEDESC', 'LPOSVERSIONINFOEXA', 'TMP_UNION_DEBUG_INFO', 'PFILE_STREAM_INFORMATION', '_IMAGE_IMPORT_BY_NAME', '_TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE', 'LPBITMAPCOREHEADER', 'STARTUPINFOA', '_TMP_UNION_IO_STATUS_BLOCK', 'DATA_BLOB', 'PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', 'PAPI_SET_NAMESPACE_ARRAY', '_TOKEN_SECURITY_ATTRIBUTE_V1', 'tagDEC', '_ANON_PEB_UNION_2', 'STARTUPINFOW', '_PROCESS_MEMORY_COUNTERS_EX', '_TOKEN_PRIVILEGES', 'PTOKEN_OWNER', 'PSAPI_WORKING_SET_EX_BLOCK32', '_IO_STATUS_BLOCK', 'PCCERT_STRONG_SIGN_PARA', 'PLUID_AND_ATTRIBUTES', 'MIB_UDP6ROW_OWNER_PID', '_LIST_ENTRY', '_TMP_VARDESC_UNION', '_TOKEN_OWNER', '_ANON_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_UNION', 'RIP_INFO', 'PCERT_CONTEXT', '_CRYPT_ATTRIBUTE', 'DEBUG_VALUE_TMP_SUBSTRUCT3', '_CRYPT_VERIFY_MESSAGE_PARA', 'PDEBUG_LAST_EVENT_INFO_BREAKPOINT', 'PTOKEN_LINKED_TOKEN', 'PPORT_VIEW', '_CERT_TRUST_STATUS', '_SECURITY_QUALITY_OF_SERVICE', 'VARDESC', 'PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO', 'tagELEMDESC', 'MIB_IPADDRTABLE', 'SYSTEM_MODULE64', '_CERT_TRUST_LIST_INFO', 'WINTRUST_DATA', 'SYSTEM_HANDLE', '_DEBUG_MODULE_PARAMETERS', '_ACE_HEADER', 'tagBITMAPCOREHEADER', 'ACCESS_DENIED_CALLBACK_OBJECT_ACE', '_M128A', 'PCCERT_CONTEXT', 'CRYPT_INTEGER_BLOB', 'CTL_CONTEXT', '_DEBUG_LAST_EVENT_INFO_LOAD_MODULE', 'PCRL_ENTRY', 'SPC_SP_OPUS_INFO', 'PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY', 'PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE', 'OSVERSIONINFOEXA', '_CMSG_CTRL_DECRYPT_PARA', '_DEBUG_SYMBOL_SOURCE_ENTRY', 'PRTL_OSVERSIONINFOW', 'tagBITMAPINFO', '_PROCESS_BASIC_INFORMATION', '_KEY_VALUE_BASIC_INFORMATION', 'FILE_ALIGNMENT_INFORMATION', '_DEBUG_EXCEPTION_FILTER_PARAMETERS', 'DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR', 'ITEMIDLIST', 'PDEBUG_BREAKPOINT_PARAMETERS', '_REMOTE_PORT_VIEW', 'TMP_VARDESC_UNION', 'DEBUG_REGISTER_DESCRIPTION', 'LPCREATE_PROCESS_DEBUG_INFO', '_API_SET_VALUE_ENTRY_V2', '_SPC_SP_OPUS_INFO', 'PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY', 'LPTYPEATTR', 'SERVICE_STATUS', 'PCMSG_CTRL_DECRYPT_PARA', '_FILE_FS_SIZE_INFORMATION', 'BITMAPINFOHEADER', 'PSAPI_WORKING_SET_INFORMATION', '_EXCEPTION_RECORD', 'tagARRAYDESC', 'PSYSTEM_MODULE32', 'TMP_UNION_IO_STATUS_BLOCK', 'CLAIM_SECURITY_ATTRIBUTE_V1_UNION', 'FILE_POSITION_INFORMATION', '_IMAGE_SECTION_HEADER', '_COAUTHINFO', 'LPSTARTUPINFOA', 'XSAVE_FORMAT_64', 'LPSERVICE_STATUS_PROCESS', '_SID_AND_ATTRIBUTES', 'CRYPT_ENCODE_PARA', 'WINTRUST_SGNR_INFO_', 'PDEBUG_PROCESSOR_IDENTIFICATION_X86', 'PIO_STATUS_BLOCK', 'CONTEXT32', 'PDEBUG_MODULE_PARAMETERS', 'ACE_HEADER', '_DEBUG_PROCESSOR_IDENTIFICATION_ARM', 'PTHREAD_BASIC_INFORMATION', 'IMAGE_OPTIONAL_HEADER64', 'PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY', 'PPUBLIC_OBJECT_TYPE_INFORMATION', 'PIMAGE_FILE_HEADER', 'RTL_USER_PROCESS_PARAMETERS', 'PDEBUG_PROCESSOR_IDENTIFICATION_ALPHA', 'tagBITMAP', '_EXCEPTION_POINTERS32', 'SYSTEM_AUDIT_CALLBACK_OBJECT_ACE', 'WNDCLASSEXA', 'PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY', '_PROCESS_MITIGATION_DEP_POLICY', 'CRYPT_ALGORITHM_IDENTIFIER', 'CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', 'API_SET_VALUE_ENTRY_V2', 'CRYPT_HASH_MESSAGE_PARA', 'TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', 'PDATA_BLOB', 'EXCEPTION_POINTERS32', '_IMAGEHLP_MODULE64', 'CERT_ID', '_CRYPT_SIGN_MESSAGE_PARA', 'CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1', '_ACL_SIZE_INFORMATION']) -enums = set(['PROCESS_INFORMATION_CLASS', 'BG_JOB_PROXY_USAGE', '_BG_JOB_PROXY_USAGE', '_IMAGEHLP_SYMBOL_TYPE_INFO', 'EVT_LOG_PROPERTY_ID', '_THREAD_INFORMATION_CLASS', 'TASK_COMPATIBILITY', 'tagCLSCTX', '_TASK_ACTION_TYPE', 'FS_INFORMATION_CLASS', 'SYSKIND', 'BG_JOB_TYPE', 'tag_WBEM_GENERIC_FLAG_TYPE', 'PROCESS_MITIGATION_POLICY', 'EVT_SYSTEM_PROPERTY_ID', 'ALPC_PORT_INFORMATION_CLASS', 'EVT_EVENT_METADATA_PROPERTY_ID', 'FILE_INFORMATION_CLASS', 'tag_WBEM_CHANGE_FLAG_TYPE', '_SC_ENUM_TYPE', '_CALLFRAME_COPY', '_IO_PRIORITY_HINT', 'SE_OBJECT_TYPE', '_EVT_SYSTEM_PROPERTY_ID', 'PSID_NAME_USE', 'TASK_CREATION', 'PTOKEN_ELEVATION_TYPE', '_BG_JOB_PRIORITY', '_TASK_TRIGGER_TYPE2', 'TASK_TRIGGER_TYPE2', 'tag_WBEM_CONNECT_OPTIONS', '_TASK_RUNLEVEL_TYPE', 'NET_FW_PROFILE_TYPE2', 'tag_WBEM_QUERY_FLAG_TYPE', '_EVT_RENDER_FLAGS', 'EVT_QUERY_FLAGS', '_ALPC_PORT_INFORMATION_CLASS', '_INTERNAL_IF_OPER_STATUS', 'SC_STATUS_TYPE', 'PTHREAD_INFORMATION_CLASS', 'PFILE_INFORMATION_CLASS', 'EVT_VARIANT_TYPE', 'TASK_INSTANCES_POLICY', '_SE_OBJECT_TYPE', 'BG_ERROR_CONTEXT', 'TASK_STATE', 'tagMSHLFLAGS', 'EVT_RENDER_CONTEXT_FLAGS', '_VARENUM', '_TASK_ENUM_FLAGS', '_BG_JOB_TYPE', 'PPROCESS_MITIGATION_POLICY', 'VARENUM', 'INTERNAL_IF_OPER_STATUS', 'TYPEKIND', 'tagCALLCONV', 'TASK_RUN_FLAGS', 'SC_ENUM_TYPE', 'WBEM_GENUS_TYPE', 'TASK_ENUM_FLAGS', '_TASK_INSTANCES_POLICY', 'UDP_TABLE_CLASS', 'INVOKEKIND', 'CLSCTX', 'tag_WBEM_GENUS_TYPE', 'IO_PRIORITY_HINT', '_SECURITY_IMPERSONATION_LEVEL', '_EVT_QUERY_FLAGS', '_PROCESS_MITIGATION_POLICY', '_SC_STATUS_TYPE', 'tagTYPEKIND', '_UDP_TABLE_CLASS', 'NET_FW_IP_PROTOCOL_', 'EVT_CHANNEL_TYPE', '_PROCESSINFOCLASS', '_EVT_CHANNEL_CONFIG_PROPERTY_ID', '_EVT_LOG_PROPERTY_ID', 'VARKIND', '_BG_ERROR_CONTEXT', 'PTOKEN_INFORMATION_CLASS', 'WBEM_CONNECT_OPTIONS', 'NET_FW_PROFILE_TYPE2_', 'ACL_INFORMATION_CLASS', 'PALPC_MESSAGE_INFORMATION_CLASS', 'PTOKEN_TYPE', 'tag_WBEMSTATUS', 'SECURITY_IMPERSONATION_LEVEL', '_EVT_OPEN_LOG_FLAGS', 'BG_JOB_PRIORITY', 'tagSYSKIND', 'SYM_TYPE', 'TOKEN_INFORMATION_CLASS', 'tagTOKEN_TYPE', 'TASK_LOGON_TYPE', 'COINIT', 'tag_WBEM_TIMEOUT_TYPE', 'THREAD_INFORMATION_CLASS', '_TASK_LOGON_TYPE', 'NET_FW_RULE_DIRECTION', 'EVT_OPEN_LOG_FLAGS', '_EVT_CHANNEL_TYPE', 'CALLFRAME_COPY', 'CALLFRAME_WALK', '_TOKEN_INFORMATION_CLASS', 'NDR_FORMAT_CHARACTER', 'FUNCKIND', 'tagCOINIT', 'TASK_ACTION_TYPE', 'NET_FW_ACTION', 'CALLCONV', '_FS_INFORMATION_CLASS', '_EVT_VARIANT_TYPE', 'WBEM_QUERY_FLAG_TYPE', 'OBJECT_INFORMATION_CLASS', 'COMSD', 'ALPC_MESSAGE_INFORMATION_CLASS', '_ALPC_MESSAGE_INFORMATION_CLASS', 'MIB_TCP_STATE', 'MSHLFLAGS', 'tagCOMSD', 'PROCESSINFOCLASS', 'SECTION_INHERIT', 'tagFUNCKIND', '_SYSTEM_INFORMATION_CLASS', 'SYSTEM_INFORMATION_CLASS', 'EVT_CHANNEL_CONFIG_PROPERTY_ID', 'TASK_RUNLEVEL_TYPE', 'tagDESCKIND', 'tagVARKIND', 'EVT_FORMAT_MESSAGE_FLAGS', '_TOKEN_ELEVATION_TYPE', 'PSECURITY_IMPERSONATION_LEVEL', 'SID_NAME_USE', '_TASK_CREATION', 'EVT_CHANNEL_ISOLATION_TYPE', '_EVT_PUBLISHER_METADATA_PROPERTY_ID', 'KEY_VALUE_INFORMATION_CLASS', 'MEMORY_INFORMATION_CLASS', '_TASK_COMPATIBILITY', '_SID_NAME_USE', 'WBEM_GENERIC_FLAG_TYPE', 'NET_FW_MODIFY_STATE', 'NET_FW_RULE_DIRECTION_', '_EVT_RENDER_CONTEXT_FLAGS', 'BG_JOB_STATE', '_TCP_TABLE_CLASS', 'WBEM_TIMEOUT_TYPE', 'DESCKIND', '_KEY_VALUE_INFORMATION_CLASS', 'tagINVOKEKIND', '_FILE_INFORMATION_CLASS', 'NET_FW_ACTION_', 'tagCALLFRAME_WALK', '_EVT_FORMAT_MESSAGE_FLAGS', '_BG_JOB_STATE', '_RTL_PATH_TYPE', 'WBEM_CHANGE_FLAG_TYPE', 'TCP_TABLE_CLASS', '_WELL_KNOWN_SID_TYPE', 'IMAGEHLP_SYMBOL_TYPE_INFO', 'TOKEN_ELEVATION_TYPE', '_MEMORY_INFORMATION_CLASS', '_EVT_CHANNEL_ISOLATION_TYPE', 'NET_FW_MODIFY_STATE_', '_MIB_TCP_STATE', 'WBEMSTATUS', 'RTL_PATH_TYPE', '_TASK_STATE', '_ACL_INFORMATION_CLASS', 'EVT_RENDER_FLAGS', '_OBJECT_INFORMATION_CLASS', 'WELL_KNOWN_SID_TYPE', '_EVT_EVENT_METADATA_PROPERTY_ID', 'TOKEN_TYPE', 'NET_FW_IP_PROTOCOL', '_SECTION_INHERIT', 'EVT_PUBLISHER_METADATA_PROPERTY_ID']) -functions = set(['EvtGetChannelConfigProperty', 'NtQuerySymbolicLinkObject', 'GetStdHandle', 'GetDriveTypeW', 'GetFileVersionInfoSizeA', 'CertFreeCertificateContext', 'GetModuleBaseNameA', 'ConvertSidToStringSidW', 'GetComputerNameA', 'CryptAcquireCertificatePrivateKey', 'AddVectoredContinueHandler', 'GetDriveTypeA', 'CryptEncrypt', 'DebugBreak', 'EvtOpenLog', 'GetProcessDEPPolicy', 'GetProcessMitigationPolicy', 'ConvertSidToStringSidA', 'GetExtendedTcpTable', 'CreatePipe', 'CreateWellKnownSid', 'GetSecurityDescriptorGroup', 'NtWow64ReadVirtualMemory64', 'DebugActiveProcessStop', 'SymInitialize', 'RegOpenKeyExW', 'SymLoadModuleEx', 'InitializeProcThreadAttributeList', 'CryptMsgGetParam', 'NtOpenSymbolicLinkObject', 'RegOpenKeyExA', 'QueryWorkingSetEx', 'CertEnumCTLsInStore', 'GetFirmwareEnvironmentVariableExW', 'CryptCATAdminCalcHashFromFileHandle2', 'CertCreateCertificateContext', 'EvtOpenEventMetadataEnum', 'CloseEventLog', 'CryptMsgUpdate', 'GetSecurityDescriptorDacl', 'NtAlpcDisconnectPort', 'WriteFile', 'WaitForSingleObject', 'EvtOpenPublisherMetadata', 'CoGetInterceptor', 'EvtRender', 'NtAlpcConnectPortEx', 'ConnectNamedPipe', 'GetProcessImageFileNameW', 'CoInitializeSecurity', 'EnumClipboardFormats', 'AllocConsole', 'GetProcessImageFileNameA', 'NtQueryInformationFile', 'CryptDestroyKey', 'PeekNamedPipe', 'LookupPrivilegeValueA', 'EvtFormatMessage', 'NtAlpcDeleteSecurityContext', 'OpenServiceA', 'WriteProcessMemory', 'NtSetContextThread', 'FindNextVolumeA', 'RegQueryValueExA', 'CryptCATCatalogInfoFromContext', 'OpenServiceW', 'NtEnumerateValueKey', 'LookupPrivilegeValueW', 'NtQueryValueKey', 'GetSecurityInfo', 'CryptEncodeObjectEx', 'NtAlpcDeletePortSection', 'RegQueryValueExW', 'NtQueryVirtualMemory', 'VerQueryValueA', 'FindWindowA', 'GetDesktopWindow', 'CryptCATGetAttrInfo', 'GetSidSubAuthority', 'ConvertStringSecurityDescriptorToSecurityDescriptorW', 'LoadLibraryExA', 'SetConsoleCtrlHandler', 'NtAlpcCreateSectionView', 'ConvertStringSecurityDescriptorToSecurityDescriptorA', 'LoadLibraryExW', 'ZwDuplicateObject', 'GetModuleBaseNameW', 'NtQuerySystemInformation', 'NtSetValueKey', 'GetSidSubAuthorityCount', 'CreateThread', 'CreateProcessAsUserA', 'GetExitCodeThread', 'SetNamedPipeHandleState', 'SetTcpEntry', 'CloseWindow', 'LocalFree', 'CoCreateInstanceEx', 'NtConnectPort', 'CreateProcessAsUserW', 'NtProtectVirtualMemory', 'SetPriorityClass', 'CoInitializeEx', 'EvtOpenPublisherEnum', 'SHGetPathFromIDListA', 'CryptCATGetMemberInfo', 'CryptExportKey', 'VirtualQuery', 'DebugActiveProcess', 'EvtGetPublisherMetadataProperty', 'CryptCATAdminAcquireContext', 'EqualSid', 'IsValidSecurityDescriptor', 'LdrLoadDll', 'SetThreadToken', 'GetCurrentThreadId', 'GetExtendedUdpTable', 'SleepEx', 'CryptUIDlgViewContext', 'GetSecurityDescriptorRMControl', 'CreateToolhelp32Snapshot', 'RtlInitUnicodeString', 'GetFirmwareEnvironmentVariableExA', 'RegCloseKey', 'NtAlpcImpersonateClientOfPort', 'NtSetInformationFile', 'GetVersionExW', 'OpenEventLogA', 'GetNumberOfEventLogRecords', 'CommitTransaction', 'GetVersionExA', 'GetSecurityDescriptorLength', 'CreateRemoteThread', 'NtAlpcSendWaitReceivePort', 'OpenProcessToken', 'WindowFromPoint', 'OpenProcess', 'EnumChildWindows', 'EvtGetLogInfo', 'GetTokenInformation', 'GetProcAddress', 'CryptSignMessage', 'GetComputerNameW', 'RtlAnsiStringToUnicodeString', 'SetWindowTextA', 'SetThreadContext', 'CertCompareCertificate', 'Wow64GetThreadContext', 'DebugBreakProcess', 'SymSetOptions', 'OpenEventLogW', 'SetWindowTextW', 'FreeConsole', 'CertEnumCertificateContextProperties', 'BringWindowToTop', 'lstrcmpW', 'GetAce', 'NtGetContextThread', 'NtQueryLicenseValue', 'StartServiceW', 'UpdateProcThreadAttribute', 'CryptCATAdminEnumCatalogFromHash', 'FreeLibrary', 'RemoveVectoredExceptionHandler', 'NtOpenEvent', 'EvtOpenChannelEnum', 'EvtNextChannelPath', 'VirtualAllocEx', 'NtCreateProcessEx', 'NtAlpcCreateSecurityContext', 'FindWindowW', 'EvtClose', 'GetInterfaceInfo', 'GlobalUnlock', 'WinVerifyTrust', 'NtOpenDirectoryObject', 'GetWindowThreadProcessId', 'CryptCATAdminReleaseCatalogContext', 'SizeofResource', 'Wow64DisableWow64FsRedirection', 'VirtualFreeEx', 'MoveWindow', 'ContinueDebugEvent', 'GetSecurityDescriptorOwner', 'CertDuplicateCTLContext', 'SetThreadAffinityMask', 'NtQueryObject', 'NtFreeVirtualMemory', 'ApiSetResolveToHost', 'CryptVerifyMessageSignatureWithKey', 'CryptCATEnumerateCatAttr', 'DuplicateTokenEx', 'GetWindowModuleFileNameA', 'CryptVerifyMessageHash', 'GetNamedSecurityInfoW', 'EnumServicesStatusExW', 'NtSetInformationProcess', 'GetModuleHandleA', 'NtUnmapViewOfSection', 'EmptyClipboard', 'GetWindowModuleFileNameW', 'Process32NextW', 'Wow64RevertWow64FsRedirection', 'MessageBoxW', 'GlobalLock', 'GetModuleHandleW', 'EnumServicesStatusExA', 'TpCallbackSendAlpcMessageOnCompletion', 'DeleteProcThreadAttributeList', 'GetFileVersionInfoA', 'NtAlpcQueryInformation', 'NtOpenKey', 'NtAlpcCreatePort', 'OpenSCManagerW', 'ObjectFromLresult', 'VirtualFree', 'GetFileVersionInfoW', 'GetVolumeInformationA', 'OpenSCManagerA', 'NtQueryInformationProcess', 'EvtGetEventMetadataProperty', 'NtOpenSection', 'GetForegroundWindow', 'CopySid', 'CertAddCertificateContextToStore', 'GetFileVersionInfoSizeW', 'SetWindowPos', 'GetProcessId', 'EvtQuery', 'GetCurrentProcess', 'NtReadVirtualMemory', 'SymLoadModuleExA', 'ConvertStringSidToSidA', 'OpenEventA', 'SymLoadModuleExW', 'GetThreadContext', 'GetCursorPos', 'SetStdHandle', 'PFXImportCertStore', 'LoadLibraryW', 'WaitForDebugEvent', 'GetNamedSecurityInfoA', 'CryptQueryObject', 'OpenThreadToken', 'GetSecurityDescriptorSacl', 'GetProcessMemoryInfo', 'CryptCATEnumerateMember', 'NtCreateFile', 'Thread32First', 'CryptMsgOpenToEncode', 'OpenTransaction', 'CertDuplicateCertificateContext', 'QueryDosDeviceA', 'CryptMsgVerifyCountersignatureEncodedEx', 'ResumeThread', 'GetMappedFileNameW', 'GetLogicalDriveStringsA', 'LoadResource', 'GetWindowTextW', 'GetLogicalDriveStringsW', 'QueryDosDeviceW', 'NtAlpcQueryInformationMessage', 'CryptCATAdminAcquireContext2', 'GetWindowTextA', 'GetCurrentThread', 'GetEventLogInformation', 'CryptVerifyMessageSignature', 'CertEnumCertificatesInStore', 'CryptMsgVerifyCountersignatureEncoded', 'OpenThread', 'GetClassInfoExW', 'CertStrToNameW', 'SuspendThread', 'GetModuleFileNameW', 'EnumWindows', 'RtlGetCompressionWorkSpaceSize', 'AddVectoredExceptionHandler', 'CertStrToNameA', 'GetClassInfoExA', 'ExitProcess', 'CryptCATEnumerateAttr', 'CertOpenStore', 'GetModuleFileNameA', 'GetAclInformation', 'LoadLibraryA', 'SetProcessMitigationPolicy', 'CloseServiceHandle', 'GetPriorityClass', 'NtQueryEaFile', 'GetMappedFileNameA', 'NtAlpcConnectPort', 'GetVolumeInformationW', 'Process32Next', 'MapViewOfFile', 'CryptGenKey', 'RtlDecompressBuffer', 'NtWriteVirtualMemory', 'GetVolumeNameForVolumeMountPointA', 'GetFirmwareEnvironmentVariableW', 'SetClipboardData', 'DebugSetProcessKillOnExit', 'NtSetEaFile', 'GetFirmwareEnvironmentVariableA', 'SymGetModuleInfo64', 'GetIpAddrTable', 'GetVolumeNameForVolumeMountPointW', 'ExitThread', 'CryptDecrypt', 'CryptDecodeObject', 'EvtGetObjectArraySize', 'CreateTransaction', 'ReadEventLogA', 'RtlGetUnloadEventTraceEx', 'TerminateProcess', 'EvtOpenChannelConfig', 'NtAlpcCreatePortSection', 'ConvertSecurityDescriptorToStringSecurityDescriptorW', 'GetWindowRect', 'NtAlpcCreateResourceReserve', 'GlobalAlloc', 'VirtualQueryEx', 'ReadEventLogW', 'SymGetTypeInfo', 'CryptCATAdminReleaseContext', 'GetClipboardFormatNameW', 'GetVersion', 'NtEnumerateSystemEnvironmentValuesEx', 'CryptHashCertificate', 'ConvertSecurityDescriptorToStringSecurityDescriptorA', 'StartServiceA', 'LookupAccountSidW', 'CertCreateSelfSignCertificate', 'TerminateThread', 'LookupPrivilegeNameA', 'OpenBackupEventLogW', 'DeviceIoControl', 'AlpcInitializeMessageAttribute', 'GetExitCodeProcess', 'LookupAccountSidA', 'Wow64SetThreadContext', 'VirtualProtect', 'DuplicateToken', 'OpenBackupEventLogA', 'NtAlpcAcceptConnectPort', 'GetParent', 'GetSystemMetrics', 'NtCreateThreadEx', 'NtCreateKey', 'GetWindowsDirectoryW', 'QueryWorkingSet', 'EvtCreateRenderContext', 'PfnCryptGetSignerCertificate', 'SHGetPathFromIDListW', 'CryptDecryptMessage', 'GetWindowsDirectoryA', 'NtAllocateVirtualMemory', 'VerQueryValueW', 'NtAlpcDeleteResourceReserve', 'StrStrIW', 'VirtualProtectEx', 'CreateFileMappingW', 'StrStrIA', 'CryptAcquireContextA', 'GetSidIdentifierAuthority', 'ReadProcessMemory', 'CreateFileTransactedA', 'NtQueryInformationThread', 'CertFindCertificateInStore', 'CryptMsgClose', 'CreateFileMappingA', 'Thread32Next', 'DuplicateHandle', 'CreateFileTransactedW', 'RtlDosPathNameToNtPathName_U', 'GetClassNameW', 'CertGetCertificateContextProperty', 'NtQueryDirectoryObject', 'GetProductInfo', 'NtCreateSection', 'CreateProcessA', 'CryptMsgOpenToDecode', 'FindFirstVolumeA', 'FreeSid', 'GetSidLengthRequired', 'CryptMsgControl', 'CreateFileW', 'CryptSignAndEncryptMessage', 'ShellExecuteW', 'NtWow64WriteVirtualMemory64', 'EvtNextPublisherId', 'CreateFileA', 'EvtNextEventMetadata', 'ShellExecuteA', 'FindFirstVolumeW', 'OpenClipboard', 'GetLastError', 'CLSIDFromProgID', 'GetShortPathNameW', 'CreateNamedPipeW', 'GetSecurityDescriptorControl', 'GlobalFree', 'OpenEventW', 'AlpcGetMessageAttribute', 'AdjustTokenPrivileges', 'CryptReleaseContext', 'GetProcessTimes', 'GetIfTable', 'CryptEncryptMessage', 'SymFromName', 'CreateNamedPipeA', 'GetShortPathNameA', 'NtMapViewOfSection', 'CreateProcessW', 'ConvertStringSidToSidW', 'FindNextVolumeW', 'GetCurrentProcessorNumber', 'RegGetValueW', 'LockResource', 'MessageBoxA', 'GetClassNameA', 'SetTokenInformation', 'Wow64EnableWow64FsRedirection', 'NtAlpcDeleteSectionView', 'CertGetCertificateChain', 'RegGetValueA', 'EvtGetObjectArrayProperty', 'Process32FirstW', 'LookupPrivilegeNameW', 'CoCreateInstance', 'RtlEqualUnicodeString', 'RealGetWindowClassW', 'lstrcmpA', 'RollbackTransaction', 'NtQueryVolumeInformationFile', 'NtQueryDirectoryFile', 'ReadFile', 'CryptCATAdminCalcHashFromFileHandle', 'GetClipboardData', 'CloseHandle', 'Process32First', 'GetLengthSid', 'GetClipboardFormatNameA', 'PFXExportCertStoreEx', 'RealGetWindowClassA', 'CryptAcquireContextW', 'CertFreeCTLContext', 'CertGetNameStringA', 'GetLongPathNameW', 'SymFromAddr', 'GetThreadId', 'RtlDecompressBufferEx', 'FindResourceW', 'NtAlpcRevokeSecurityContext', 'IsOS', 'GetLongPathNameA', 'Sleep', 'CertGetNameStringW', 'EvtNext', 'CloseClipboard', 'RtlInitString', 'FindResourceA', 'VirtualAlloc']) -interfaces = set(['IUnknown', 'ITypeInfo', 'ITaskService', 'INetFwPolicy2', 'IRunningTask', 'IRunningTaskCollection', 'IActionCollection', 'IShellLinkW', 'IBackgroundCopyJob', 'INetFwRules', 'IBackgroundCopyCallback', 'IWbemContext', 'INetFwServiceRestriction', 'ITypeComp', 'IShellLinkA', 'ICallFrame', 'IWbemQualifierSet', 'ICallInterceptor', 'IWbemObjectSink', 'IBackgroundCopyManager', 'IDispatch', 'ICallFrameEvents', 'ITypeLib', 'IPrincipal', 'ITaskSettings', 'IWbemLocator', 'INetFwRule', 'IExecAction', 'IWbemCallResult', 'ITaskFolder', 'ICallFrameWalker', 'ITaskNamedValueCollection', 'IWbemClassObject', 'IRegistrationInfo', 'IWbemServices', 'IIdleSettings', 'IEnumBackgroundCopyFiles', 'IEnumBackgroundCopyJobs', 'IComHandlerAction', 'ITaskFolderCollection', 'IBackgroundCopyError', 'IRepetitionPattern', 'INetworkSettings', 'ITrigger', 'IBackgroundCopyFile', 'IShowMessageAction', 'ITaskNamedValuePair', 'ITaskDefinition', 'IPersistFile', 'IRegisteredTask', 'IEnumVARIANT', 'IRegisteredTaskCollection', 'IEnumWbemClassObject', 'IEmailAction', 'IAction', 'ITriggerCollection']) +windef = set(['STATUS_SUSPEND_COUNT_EXCEEDED', 'EVENT_TRACE_FLAG_PROCESS', 'ERROR_BAD_NET_NAME', 'CMSG_ENVELOPED', 'STANDARD_RIGHTS_WRITE', 'RRF_RT_REG_QWORD', 'ERROR_SYSTEM_SHUTDOWN', 'PROV_FORTEZZA', 'STATUS_TRANSPORT_FULL', 'STATUS_ACPI_INCORRECT_ARGUMENT_COUNT', 'DBG_REPLY_LATER', 'AF_HYLINK', 'ERROR_INVALID_VARIANT', 'CMSG_HASH_DATA_PARAM', 'CMSG_CTRL_ADD_CRL', 'IMAGE_SCN_LNK_REMOVE', 'STGM_TRANSACTED', 'STATUS_BAD_REMOTE_ADAPTER', 'STATUS_DS_SAM_INIT_FAILURE', 'STATUS_VDM_DISALLOWED', 'CONTEXT_FULL', 'SE_DACL_PROTECTED', 'ERROR_CANTOPEN', 'STATUS_SXS_KEY_NOT_FOUND', 'CRYPT_ASN_ENCODING', 'DNS_TYPE_RRSIG', 'EXCEPTION_FLT_UNDERFLOW', 'CMSG_CMS_RECIPIENT_INDEX_PARAM', 'ERROR_BAD_NETPATH', 'OS_NT4ORGREATER', 'SYMBOLIC_LINK_ALL_ACCESS', 'STATUS_PIPE_BUSY', 'CERT_X500_NAME_STR', 'KEY_QUERY_VALUE', 'STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE', 'ERROR_EVT_INVALID_EVENT_DATA', 'STATUS_EVENT_PENDING', 'STATUS_PENDING', 'STATUS_TRANSACTION_FREEZE_IN_PROGRESS', 'SERVICE_DRIVER', 'ERROR_NO_SPOOL_SPACE', 'STATUS_LOG_CORRUPTION_DETECTED', 'IMAGE_DIRECTORY_ENTRY_TLS', 'NTE_PROVIDER_DLL_FAIL', 'STATUS_NOINTERFACE', 'SYSTEM_MANDATORY_LABEL_NO_WRITE_UP', 'CERT_QUERY_CONTENT_FLAG_PKCS10', 'ANYSIZE_ARRAY', 'PRODUCT_STANDARD_EVALUATION_SERVER', 'RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH', 'CLUSAPI_CHANGE_ACCESS', 'szOID_OIWSEC_desEDE', 'OS_WIN2000DATACENTER', 'STATUS_MAGAZINE_NOT_PRESENT', 'STATUS_TRANSACTIONS_NOT_FROZEN', 'STATUS_SXS_COMPONENT_STORE_CORRUPT', 'STATUS_FLT_INSTANCE_NAME_COLLISION', 'OS_WIN95_GOLD', 'STATUS_NOT_SNAPSHOT_VOLUME', 'STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION', 'OS_DOMAINMEMBER', 'STATUS_TOO_MANY_SECRETS', 'ERROR_EVT_MESSAGE_NOT_FOUND', 'STATUS_GRAPHICS_CANT_LOCK_MEMORY', 'AF_NS', 'ERROR_WOW_ASSERTION', 'STATUS_FILES_OPEN', 'STATUS_NO_BROWSER_SERVERS_FOUND', 'STATUS_THREADPOOL_RELEASED_DURING_OPERATION', 'CONTAINER_INHERIT_ACE', 'DIGSIG_E_CRYPTO', 'ERROR_DBG_TERMINATE_THREAD', 'ERROR_EVT_FILTER_UNSUPPORTEDOP', 'PAGE_EXECUTE_READ', 'SEC_COMMIT', 'STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE', 'SID_HASH_SIZE', 'STATUS_AGENTS_EXHAUSTED', 'DNS_TYPE_SINK', 'SE_GROUP_INTEGRITY_ENABLED', 'ERROR_BAD_UNIT', 'STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER', 'szOID_RSA_SHA384RSA', 'ERROR_PAGE_FAULT_TRANSITION', 'ERROR_HANDLE_DISK_FULL', 'szOID_TRUSTED_CLIENT_AUTH_CA_LIST', 'CERT_PUBKEY_ALG_PARA_PROP_ID', 'ERROR_PWD_HISTORY_CONFLICT', 'CMSG_CTRL_ADD_CMS_SIGNER_INFO', 'STATUS_LOG_NOT_ENOUGH_CONTAINERS', 'RPC_NT_ZERO_DIVIDE', 'SERVICE_TRIGGER_TYPE_CUSTOM', 'STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED', 'STATUS_DISK_RESET_FAILED', 'CERT_TRUST_HAS_KEY_MATCH_ISSUER', 'STATUS_INTERNAL_ERROR', 'STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER', 'szOID_OIWSEC_mdc2RSA', 'STATUS_FWP_SUBLAYER_NOT_FOUND', 'STATUS_INVALID_DOMAIN_ROLE', 'STATUS_LOG_POLICY_ALREADY_INSTALLED', 'ERROR_REGISTRY_CORRUPT', 'RPC_NT_UNKNOWN_AUTHZ_SERVICE', 'ERROR_PROCESS_NOT_IN_JOB', 'STATUS_HOPLIMIT_EXCEEDED', 'RPC_NT_INVALID_NET_ADDR', 'CMSG_SIGNED_AND_ENVELOPED', 'STATUS_TRANSACTION_NOT_FOUND', 'SC_MANAGER_ENUMERATE_SERVICE', 'STATUS_NO_CALLBACK_ACTIVE', 'SERVICE_STOP_PENDING', 'SERVICE_TRIGGER_TYPE_FIREWALL_PORT_EVENT', 'szOID_RSA_certExtensions', 'ERROR_EVT_CONFIGURATION_ERROR', 'EXCEPTION_ARRAY_BOUNDS_EXCEEDED', 'STATUS_CANT_WAIT', 'KEY_WOW64_32KEY', 'STATUS_WMI_GUID_NOT_FOUND', 'TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY', 'SEMAPHORE_MODIFY_STATE', 'ERROR_RING2_STACK_IN_USE', 'STATUS_CLUSTER_NETWORK_NOT_INTERNAL', 'CERT_E_VALIDITYPERIODNESTING', 'IMAGE_DLLCHARACTERISTICS_NO_BIND', 'STATUS_NO_SUCH_DOMAIN', 'STATUS_FILE_CLOSED', 'ERROR_NOTIFY_CLEANUP', 'FILE_OPEN_REQUIRING_OPLOCK', 'ERROR_RESOURCE_REQUIREMENTS_CHANGED', 'IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA', 'szOID_TRUSTED_SERVER_AUTH_CA_LIST', 'STATUS_DATA_LATE_ERROR', 'SEC_IMAGE', 'DNS_TYPE_UINFO', 'PIPE_SERVER_END', 'CERT_SYSTEM_STORE_USERS_ID', 'DNS_TYPE_UNSPEC', 'STATUS_VIRUS_DELETED', 'RPC_NT_INVALID_ASYNC_CALL', 'STATUS_FLT_NOT_SAFE_TO_POST_OPERATION', 'CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE', 'EXCEPTION_BREAKPOINT', 'RPC_NT_ENTRY_NOT_FOUND', 'STATUS_PASSWORD_EXPIRED', 'STATUS_DATA_OVERRUN', 'STATUS_INVALID_EA_FLAG', 'PIPE_CLIENT_END', 'EXCEPTION_POSSIBLE_DEADLOCK', 'STATUS_INVALID_TASK_INDEX', 'STATUS_CONNECTION_ABORTED', 'STATUS_WMI_READ_ONLY', 'CERT_MD5_HASH_PROP_ID', 'CMSG_DATA', 'STATUS_LOG_PINNED_RESERVATION', 'STATUS_LICENSE_VIOLATION', 'szOID_X957_SHA1DSA', 'ERROR_INVALID_AT_INTERRUPT_TIME', 'STATUS_PKINIT_NAME_MISMATCH', 'TRUST_E_EXPLICIT_DISTRUST', 'STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED', 'STATUS_NO_TRUST_LSA_SECRET', 'FILE_FLAG_POSIX_SEMANTICS', 'STATUS_PORT_DISCONNECTED', 'SERVICE_CONTROL_DEVICEEVENT', 'ERROR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED', 'STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP', 'PROCESS_SET_LIMITED_INFORMATION', 'STATUS_INVALID_VOLUME_LABEL', 'ALPC_HANDLEFLG_DUPLICATE_SAME_ACCESS', 'STATUS_REQUEST_OUT_OF_SEQUENCE', 'STATUS_CLUSTER_NODE_ALREADY_MEMBER', 'FAX_PORT_QUERY', 'szOID_PKCS_8', 'szOID_PKCS_9', 'CERT_SYSTEM_STORE_LOCAL_MACHINE', 'szOID_PKCS_4', 'szOID_PKCS_5', 'szOID_PKCS_6', 'szOID_PKCS_7', 'NTE_INTERNAL_ERROR', 'szOID_PKCS_1', 'szOID_PKCS_2', 'szOID_PKCS_3', 'FILE_ATTRIBUTE_REPARSE_POINT', 'STATUS_PNP_IRQ_TRANSLATION_FAILED', 'ACCESS_MAX_MS_V4_ACE_TYPE', 'CERT_SYSTEM_STORE_LOCATION_SHIFT', 'ERROR_BACKUP_CONTROLLER', 'DEBUG_PROCESS', 'STATUS_FVE_BAD_METADATA_POINTER', 'ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE', 'CERT_QUERY_CONTENT_CTL', 'szOID_RSA_envelopedData', 'STATUS_WX86_EXCEPTION_CHAIN', 'DEBUG_EVENT_CHANGE_DEBUGGEE_STATE', 'STATUS_DUPLICATE_OBJECTID', 'SE_LOCK_MEMORY_NAME', 'STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY', 'STATUS_CANNOT_BREAK_OPLOCK', 'STATUS_VERIFIER_STOP', 'ERROR_NETNAME_DELETED', 'PORT_ALL_ACCESS', 'szOID_OIWDIR_HASH', 'STATUS_CONNECTION_REFUSED', 'STATUS_FILE_IDENTITY_NOT_PERSISTENT', 'STATUS_BAD_DESCRIPTOR_FORMAT', 'STATUS_FVE_TPM_NO_VMK', 'STATUS_APP_INIT_FAILURE', 'STATUS_NOT_A_REPARSE_POINT', 'szOID_INTENT_TO_SEAL', 'STATUS_MP_PROCESSOR_MISMATCH', 'STATUS_NDIS_DOT11_MEDIA_IN_USE', 'CERT_NAME_EMAIL_TYPE', 'SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE', 'STATUS_PROCESS_IS_PROTECTED', 'szOID_RSA_SMIMECapabilities', 'STATUS_GRAPHICS_INVALID_TOTAL_REGION', 'CERT_QUERY_CONTENT_FLAG_CERT_PAIR', 'LPC_DEBUG_EVENT', 'STATUS_EVENTLOG_FILE_CORRUPT', 'WTD_STATEACTION_CLOSE', 'ERROR_TIMER_RESUME_IGNORED', 'TXFS_MINIVERSION_DEFAULT_VIEW', 'STATUS_NDIS_ERROR_READING_FILE', 'STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER', 'IMAGE_SCN_MEM_WRITE', 'CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED', 'PROCESS_SET_INFORMATION', 'SE_CREATE_PAGEFILE_NAME', 'STATUS_CONTENT_BLOCKED', 'STATUS_NOT_MAPPED_VIEW', 'STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS', 'STATUS_INVALID_HW_PROFILE', 'ERROR_INSUFFICIENT_LOGON_INFO', 'STATUS_FAILED_DRIVER_ENTRY', 'STATUS_INVALID_PARAMETER', 'MS_DEF_PROV_A', 'STATUS_LOG_HARD_ERROR', 'ERROR_TRANSLATION_COMPLETE', 'TH32CS_SNAPHEAPLIST', 'STATUS_FVE_OLD_METADATA_COPY', 'FILE_CREATE_PIPE_INSTANCE', 'szOID_OIWSEC_desCFB', 'IMAGE_SCN_MEM_DISCARDABLE', 'MS_DEF_PROV_W', 'STATUS_DLL_MIGHT_BE_INCOMPATIBLE', 'EVENT_TRACE_FLAG_MEMORY_HARD_FAULTS', 'FILE_SUPPORTS_TRANSACTIONS', 'STATUS_UNABLE_TO_UNLOAD_MEDIA', 'szOID_PKCS_9_SEQUENCE_NUMBER', 'STATUS_CTX_NOT_CONSOLE', 'MEM_4MB_PAGES', 'STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS', 'STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS', 'STATUS_HANDLES_CLOSED', 'STATUS_INCOMPATIBLE_FILE_MAP', 'STATUS_NO_RANGES_PROCESSED', 'NTE_PROV_TYPE_NO_MATCH', 'PKCS_7_NDR_ENCODING', 'STATUS_SMARTCARD_IO_ERROR', 'ERROR_IO_PENDING', 'CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY', 'API_SET_SCHEMA_ENTRY_FLAGS_SEALED', 'STATUS_NDIS_OFFLOAD_POLICY', 'ERROR_WMI_READ_ONLY', 'STATUS_GRAPHICS_PVP_HFS_FAILED', 'ERROR_DBG_EXCEPTION_HANDLED', 'ERROR_SIGNAL_PENDING', 'RPC_NT_INVALID_PIPE_OPERATION', 'STATUS_FWP_DUPLICATE_KEYMOD', 'STATUS_REMOTE_STORAGE_MEDIA_ERROR', 'STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES', 'STATUS_LAST_ADMIN', 'X509_CERT_CRL_TO_BE_SIGNED', 'STATUS_SYSTEM_DEVICE_NOT_FOUND', 'EXCEPTION_INVALID_DISPOSITION', 'NTE_BUFFER_TOO_SMALL', 'STATUS_CALLBACK_RETURNED_THREAD_AFFINITY', 'IO_COMPLETION_MODIFY_STATE', 'CMSG_ENCRYPTED_DIGEST', 'CERT_FIND_SUBJECT_INFO_ACCESS', 'PRODUCT_MEDIUMBUSINESS_SERVER_SECURITY', 'STATUS_FLT_DO_NOT_DETACH', 'STATUS_CLUSTER_NO_SECURITY_CONTEXT', 'NTE_BAD_DATA', 'LPC_CLIENT_DIED', 'AT_KEYEXCHANGE', 'STATUS_NO_MEDIA_IN_DEVICE', 'IMAGE_REL_BASED_DIR64', 'PRODUCT_ESSENTIALBUSINESS_SERVER_MGMTSVC', 'CERT_IE30_RESERVED_PROP_ID', 'STATUS_TRANSACTION_NO_RELEASE', 'STATUS_ACPI_INVALID_ARGUMENT', 'CMSG_MAX_LENGTH_FLAG', 'CMSG_CTRL_ENABLE_STRONG_SIGNATURE', 'szOID_RSA_unstructAddr', 'STATUS_DEVICE_ALREADY_ATTACHED', 'STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED', 'STATUS_DATATYPE_MISALIGNMENT_ERROR', 'STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND', 'THREAD_SUSPEND_RESUME', 'LPC_ERROR_EVENT', 'TH32CS_INHERIT', 'STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET', 'COM_EXECUTE_REMOTE', 'IMAGE_SCN_LNK_NRELOC_OVFL', 'STATUS_INVALID_FILE_FOR_SECTION', 'CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT', 'SC_MANAGER_CREATE_SERVICE', 'NTE_KEYSET_ENTRY_BAD', 'szOID_RSA_DH', 'ERROR_ACPI_ERROR', 'STATUS_INVALID_MESSAGE', 'STATUS_CTX_SHADOW_INVALID', 'szOID_RSA_HASH', 'STATUS_OBJECT_NAME_EXISTS', 'FC_DONT_FREE', 'IMAGE_SCN_MEM_SHARED', 'EXCEPTION_FLT_INEXACT_RESULT', 'ERROR_TRANSACTION_NOT_REQUESTED', 'STATUS_FWP_CALLOUT_NOTIFICATION_FAILED', 'STATUS_LOG_BLOCK_INCOMPLETE', 'FILE_SHARE_READ', 'PRODUCT_CORE_COUNTRYSPECIFIC', 'ACCESS_DENIED_OBJECT_ACE_TYPE', 'RPC_NT_SS_CANNOT_GET_CALL_HANDLE', 'INHERIT_PARENT_AFFINITY', 'STATUS_LOG_POLICY_INVALID', 'EVENT_HEADER_FLAG_PROCESSOR_INDEX', 'PRODUCT_ENTERPRISE_SERVER', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64', 'OBJ_KERNEL_HANDLE', 'CMSG_HASHED', 'ERROR_VOLSNAP_HIBERNATE_READY', 'ALPC_MSGFLG_SYNC_REQUEST', 'CERT_OID_NAME_STR', 'STATUS_CALLBACK_RETURNED_LDR_LOCK', 'ERROR_FAIL_NOACTION_REBOOT', 'STATUS_EXPIRED_HANDLE', 'STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET', 'EVT_VARIANT_TYPE_ARRAY', 'STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED', 'BIND_IF_SYNTAX_NDR64', 'CERT_FORTEZZA_DATA_PROP_ID', 'szOID_RSA_counterSign', 'STATUS_CTX_INVALID_MODEMNAME', 'CREATE_NEW_CONSOLE', 'STATUS_DS_CROSS_DOM_MOVE_FAILED', 'STATUS_FWP_INVALID_ACTION_TYPE', 'X509_CERT', 'EVENT_TRACE_FILE_MODE_NEWFILE', 'ERROR_CACHE_PAGE_LOCKED', 'STATUS_THREAD_NOT_IN_PROCESS', 'CERT_KEY_CONTEXT_PROP_ID', 'DNS_TYPE_MR', 'STATUS_NDIS_MULTICAST_NOT_FOUND', 'ANY_SIZE', 'NTE_SILENT_CONTEXT', 'ERROR_WRITE_PROTECT', 'CERT_FIND_PUBKEY_MD5_HASH', 'szOID_INFOSEC_SuiteAConfidentiality', 'STATUS_INVALID_LOGON_HOURS', 'ERROR_LOST_WRITEBEHIND_DATA', 'STATUS_REQUEST_ABORTED', 'CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID', 'SM_CYKANJIWINDOW', 'STATUS_UNWIND_CONSOLIDATE', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_FQBN', 'ERROR_SYSTEM_POWERSTATE_TRANSITION', 'SM_CYMIN', 'CERT_KEY_SPEC_PROP_ID', 'SEC_WRITECOMBINE', 'STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP', 'DIRECTORY_TRAVERSE', 'STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED', 'DNS_QUERY_RESERVED', 'SM_CYVIRTUALSCREEN', 'CERT_TRUST_HAS_PREFERRED_ISSUER', 'DNS_TYPE_PX', 'EVENT_TRACE_FILE_MODE_NONE', 'AF_IPX', 'FILE_EXISTS', 'OS_WELCOMELOGONUI', 'X509_KEY_USAGE_RESTRICTION', 'SE_SACL_PROTECTED', 'SM_CYMAXTRACK', 'STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET', 'STATUS_INVALID_LOCK_SEQUENCE', 'WTD_STATEACTION_IGNORE', 'STATUS_GRAPHICS_TRY_AGAIN_NOW', 'CERT_TRUST_IS_EXPLICIT_DISTRUST', 'STATUS_IO_REPARSE_TAG_MISMATCH', 'CERT_INFO_NOT_BEFORE_FLAG', 'DNS_TYPE_ADDRS', 'STATUS_WX86_SINGLE_STEP', 'DIGSIG_E_DECODE', 'ERROR_TOO_MANY_CMDS', 'STATUS_BAD_TOKEN_TYPE', 'OBJ_CASE_INSENSITIVE', 'STATUS_DS_INIT_FAILURE_CONSOLE', 'BG_JOB_ENUM_ALL_USERS', 'STATUS_REDIRECTOR_STARTED', 'API_SET_SCHEMA_ENTRY_FLAGS_EXTENSION', 'THREAD_GET_CONTEXT', 'CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID', 'STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG', 'STATUS_DEBUG_ATTACH_FAILED', 'REG_RESOURCE_REQUIREMENTS_LIST', 'STATUS_VALIDATE_CONTINUE', 'AF_INET', 'STATUS_NO_GUID_TRANSLATION', 'STATUS_FVE_REBOOT_REQUIRED', 'AF_NETDES', 'ERROR_FAIL_RESTART', 'STATUS_ISSUING_CA_UNTRUSTED', 'SM_CXMENUSIZE', 'STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY', 'CERT_SYSTEM_STORE_SERVICES', 'STATUS_FVE_FS_NOT_EXTENDED', 'STATUS_IPSEC_CLEAR_TEXT_DROP', 'STATUS_PRIVILEGED_INSTRUCTION', 'STATUS_INVALID_BLOCK_LENGTH', 'STATUS_INVALID_PAGE_PROTECTION', 'STATUS_FVE_TPM_DISABLED', 'STATUS_MEMBERS_PRIMARY_GROUP', 'STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED', 'MEM_RESET', 'DIGSIG_E_EXTENSIBILITY', 'EXCEPTION_FLT_INVALID_OPERATION', 'API_SET_LOOKUP_ORDINAL', 'SERVICE_ACTIVE', 'STATUS_LOGON_SESSION_EXISTS', 'STATUS_BAD_WORKING_SET_LIMIT', 'ERROR_IMAGE_NOT_AT_BASE', 'RPC_NT_PIPE_CLOSED', 'ERROR_CURRENT_DIRECTORY', 'STATUS_INVALID_PORT_HANDLE', 'RPC_S_UNSUPPORTED_TRANS_SYN', 'STATUS_END_OF_FILE', 'ERROR_DUP_NAME', 'STATUS_RESOURCE_IN_USE', 'ERROR_TIMER_NOT_CANCELED', 'RPC_NT_NO_BINDINGS', 'STATUS_LOG_NO_RESTART', 'FILE_ATTRIBUTE_ARCHIVE', 'CERT_QUERY_CONTENT_CERT_PAIR', 'IMAGE_SCN_ALIGN_512BYTES', 'DNS_TYPE_DHCID', 'FAX_CONFIG_SET', 'NMPWAIT_WAIT_FOREVER', 'CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID', 'STATUS_IMPLEMENTATION_LIMIT', 'ERROR_NOT_TINY_STREAM', 'ERROR_SECTOR_NOT_FOUND', 'STATUS_PIPE_CONNECTED', 'ERROR_INVALID_ACCESS', 'CERT_STORE_PROV_PKCS7', 'STATUS_UNHANDLED_EXCEPTION', 'STATUS_LOCAL_USER_SESSION_KEY', 'HKEY_USERS', 'STATUS_SECTION_NOT_EXTENDED', 'NTE_UI_REQUIRED', 'szOID_RSA_MD2', 'STATUS_IPSEC_BAD_SPI', 'szOID_RSA_MD5', 'szOID_RSA_MD4', 'OS_WEBSERVER', 'DEBUG_EVENT_EXIT_THREAD', 'SM_CYDOUBLECLK', 'DNS_TYPE_NSEC3', 'STGFMT_FILE', 'STATUS_ALLOCATE_BUCKET', 'STATUS_NOT_SUPPORTED', 'STATUS_RECEIVE_PARTIAL', 'STATUS_ENLISTMENT_NOT_SUPERIOR', 'STATUS_MONITOR_NO_DESCRIPTOR', 'szOID_RSA_SMIMEalgCMS3DESwrap', 'CMSG_ENCRYPTED', 'CERT_COMPARE_SHA1_HASH', 'ERROR_NOT_CAPABLE', 'WTD_UI_NOBAD', 'szOID_ECDSA_SHA1', 'DEBUG_EVENT_CHANGE_SYMBOL_STATE', 'ACCESS_ALLOWED_ACE_TYPE', 'CRYPT_SF', 'szOID_INFOSEC_SuiteASignature', 'SPC_MINIMAL_CRITERIA_OBJID', 'SM_CYVSCROLL', 'CERT_QUERY_FORMAT_BASE64_ENCODED', 'ERROR_USER_PROFILE_LOAD', 'STATUS_TOO_MANY_SESSIONS', 'CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED', 'STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES', 'STATUS_LOG_FILE_FULL', 'STD_INPUT_HANDLE', 'CRYPT_KEK', 'TH32CS_SNAPALL', 'ERROR_DOMAIN_CTRLR_CONFIG_ERROR', 'CMSG_ENCODED_MESSAGE', 'ERROR_NET_WRITE_FAULT', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_SID', 'STATUS_BAD_SERVICE_ENTRYPOINT', 'STATUS_PARAMETER_QUOTA_EXCEEDED', 'IMAGE_FILE_MACHINE_ARM', 'CREATE_DEFAULT_ERROR_MODE', 'STATUS_TRANSACTION_NO_MATCH', 'CERT_SOURCE_LOCATION_PROP_ID', 'ERROR_SYNCHRONIZATION_REQUIRED', 'DNS_TYPE_NSAP', 'STATUS_PRIVILEGE_NOT_HELD', 'STATUS_FWP_INJECT_HANDLE_STALE', 'PRODUCT_ULTIMATE', 'ERROR_DISK_CHANGE', 'SERVICE_START_PENDING', 'STATUS_RESOURCE_DATA_NOT_FOUND', 'SERVICE_START', 'IMAGE_SCN_ALIGN_128BYTES', 'STATUS_CONVERT_TO_LARGE', 'STATUS_EVALUATION_EXPIRATION', 'SW_SHOWMAXIMIZED', 'STATUS_PAGEFILE_QUOTA', 'STATUS_WX86_CREATEWX86TIB', 'SM_CXMENUCHECK', 'DNS_QUERY_NO_HOSTS_FILE', 'ERROR_BADSTARTPOSITION', 'CERT_INFO_SERIAL_NUMBER_FLAG', 'STATUS_FWP_IN_USE', 'CERT_FIND_PUBLIC_KEY', 'RPC_NT_INCOMPLETE_NAME', 'szOID_PKCS_12', 'CERT_COMPARE_SHIFT', 'STATUS_FVE_PARTIAL_METADATA', 'ERROR_BAD_COMPRESSION_BUFFER', 'STATUS_WRONG_VOLUME', 'PROV_RSA_AES', 'STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH', 'STATUS_DEVICE_CONFIGURATION_ERROR', 'IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP', 'STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH', 'CERT_COMPARE_MASK', 'ERROR_WAIT_3', 'ERROR_WAIT_2', 'ERROR_WAIT_1', 'ALPC_MESSAGE_TOKEN_ATTRIBUTE', 'szOID_NIST_sha256', 'COMPRESSION_ENGINE_MAXIMUM', 'STATUS_CTX_MODEM_RESPONSE_TIMEOUT', 'CERT_QUERY_OBJECT_BLOB', 'STATUS_NOT_A_DIRECTORY', 'STATUS_FLOAT_INVALID_OPERATION', 'IMAGE_DLLCHARACTERISTICS_NX_COMPAT', 'ERROR_DRIVER_CANCEL_TIMEOUT', 'ERROR_INVALID_TRANSACTION', 'EXCEPTION_PRIV_INSTRUCTION', 'STATUS_MFT_TOO_FRAGMENTED', 'DNS_TYPE_LOC', 'PRODUCT_SB_SOLUTION_SERVER', 'STATUS_INVALID_PARAMETER_8', 'FILE_ACTION_RENAMED_NEW_NAME', 'STATUS_NDIS_ADAPTER_NOT_READY', 'STATUS_DISK_QUOTA_EXCEEDED', 'STATUS_PAGE_FAULT_COPY_ON_WRITE', 'DIRECTORY_QUERY', 'IMAGE_SCN_ALIGN_16BYTES', 'COM_ACTIVATE_LOCAL', 'ERROR_DBG_PRINTEXCEPTION_C', 'STATUS_TOO_MANY_CONTEXT_IDS', 'STATUS_BUFFER_ALL_ZEROS', 'AF_IRDA', 'CERT_ARCHIVED_PROP_ID', 'DIRECTORY_ALL_ACCESS', 'GROUP_SECURITY_INFORMATION', 'RPC_C_AUTHN_LEVEL_PKT', 'PIPE_WAIT', 'STATUS_INVALID_READ_MODE', 'PRODUCT_ENTERPRISE_SERVER_V', 'MAXIMUM_ALLOWED', 'SERVICE_TRIGGER_TYPE_CUSTOM_SYSTEM_STATE_CHANGE', 'EXCEPTION_DATATYPE_MISALIGNMENT', 'COMPRESSION_FORMAT_NONE', 'HIGH_PRIORITY_CLASS', 'STATUS_DOMAIN_LIMIT_EXCEEDED', 'STATUS_FLT_NO_WAITER_FOR_REPLY', 'PRODUCT_HOME_PREMIUM', 'STATUS_FLOAT_MULTIPLE_FAULTS', 'STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM', 'STATUS_PARTITION_FAILURE', 'STATUS_FLT_FILTER_NOT_READY', 'NORMAL_PRIORITY_CLASS', 'ERROR_FAIL_SHUTDOWN', 'STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET', 'STATUS_DRIVER_UNABLE_TO_LOAD', 'ASYNC_MODE_COMPATIBILITY', 'X509_CERT_TO_BE_SIGNED', 'szOID_RSA_RC4', 'STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO', 'szOID_DSALG_SIGN', 'STATUS_CTX_LOGON_DISABLED', 'FC_POINTER_DEREF', 'STATUS_FILE_IS_A_DIRECTORY', 'STATUS_CRASH_DUMP', 'STATUS_ACPI_INVALID_ARGTYPE', 'NTE_EXISTS', 'STATUS_FLT_IO_COMPLETE', 'ERROR_REPARSE', 'SERVICE_PAUSED', 'IMAGE_SIZEOF_SHORT_NAME', 'CMSG_RECIPIENT_COUNT_PARAM', 'szOID_RSA_challengePwd', 'SERVICE_ACCEPT_SESSIONCHANGE', 'STATUS_HIBERNATION_FAILURE', 'CMSG_ENCODING_TYPE_MASK', 'IMAGE_SCN_ALIGN_64BYTES', 'ERROR_EA_LIST_INCONSISTENT', 'STATUS_RXACT_COMMIT_FAILURE', 'STATUS_RANGE_LIST_CONFLICT', 'ERROR_CANT_ENABLE_DENY_ONLY', 'SE_DACL_DEFAULTED', 'STATUS_JOURNAL_ENTRY_DELETED', 'SE_OWNER_DEFAULTED', 'ERROR_EVALUATION_EXPIRATION', 'STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED', 'szOID_RSA_ENCRYPT', 'CERT_COMPARE_PUBKEY_MD5_HASH', 'STATUS_CLUSTER_INVALID_REQUEST', 'PRODUCT_ESSENTIALBUSINESS_SERVER_ADDL', 'PRODUCT_DATACENTER_SERVER', 'STATUS_TM_IDENTITY_MISMATCH', 'STARTF_USESHOWWINDOW', 'ERROR_GUID_SUBSTITUTION_MADE', 'DEBUG_EVENT_CREATE_PROCESS', 'STATUS_LOG_METADATA_CORRUPT', 'STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED', 'IMAGE_SCN_ALIGN_1BYTES', 'STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME', 'OS_TERMINALSERVER', 'ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE', 'STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED', 'STATUS_CLUSTER_INVALID_NETWORK_PROVIDER', 'NTE_PROV_TYPE_ENTRY_BAD', 'EXCEPTION_CONTINUE_SEARCH', 'EVENTLOG_SEEK_READ', 'REG_FULL_RESOURCE_DESCRIPTOR', 'MEM_MAPPED', 'STATUS_STREAM_MINIVERSION_NOT_FOUND', 'STATUS_FWP_DUPLICATE_CONDITION', 'STATUS_FVE_KEYFILE_NOT_FOUND', 'STATUS_DRIVER_BLOCKED_CRITICAL', 'JOB_OBJECT_TERMINATE', 'STATUS_CANNOT_ACCEPT_TRANSACTED_WORK', 'DNS_TYPE_ISDN', 'STATUS_IO_TIMEOUT', 'CERT_FIND_EXISTING', 'STATUS_NO_LOG_SPACE', 'KEY_ALL_ACCESS', 'TOKEN_IMPERSONATE', 'ERROR_INVALID_LEVEL', 'ERROR_THREAD_WAS_SUSPENDED', 'CERT_COMPARE_HASH', 'RRF_RT_REG_DWORD', 'STATUS_FWP_TIMEOUT', 'TRUST_E_SUBJECT_FORM_UNKNOWN', 'ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND', 'STATUS_NDIS_MULTICAST_EXISTS', 'DNS_TYPE_NXT', 'STATUS_LOG_POLICY_NOT_INSTALLED', 'RPC_C_IMP_LEVEL_IMPERSONATE', 'ERROR_INVALID_OPLOCK_PROTOCOL', 'FILE_GENERIC_READ', 'NTE_BAD_PUBLIC_KEY', 'STATUS_LINK_TIMEOUT', 'IMAGE_REL_BASED_LOW', 'STATUS_MESSAGE_LOST', 'SERVICE_CONTROL_POWEREVENT', 'SERVICE_STATE_ALL', 'STATUS_INVALID_ID_AUTHORITY', 'SERVICE_ACCEPT_PAUSE_CONTINUE', 'STATUS_GRAPHICS_START_DEFERRED', 'STATUS_INVALID_IMAGE_NOT_MZ', 'STATUS_ARRAY_BOUNDS_EXCEEDED', 'ERROR_ATOMIC_LOCKS_NOT_SUPPORTED', 'STATUS_FLOPPY_ID_MARK_NOT_FOUND', 'STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER', 'EVENT_TRACE_FLAG_NETWORK_TCPIP', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID', 'UNLOAD_DLL_DEBUG_EVENT', 'STATUS_LICENSE_QUOTA_EXCEEDED', 'STATUS_UNABLE_TO_DECOMMIT_VM', 'STATUS_MEDIA_CHANGED', 'STATUS_COULD_NOT_RESIZE_LOG', 'EVENT_TRACE_TYPE_CONFIG_LOGICALDISK', 'SERVICE_TRIGGER_DATA_TYPE_LEVEL', 'SPC_PE_IMAGE_DATA_OBJID', 'FILE_NAMED_STREAMS', 'STATUS_VOLSNAP_PREPARE_HIBERNATE', 'STATUS_GRAPHICS_ALLOCATION_BUSY', 'STATUS_STACK_OVERFLOW', 'SYSTEM_AUDIT_ACE_TYPE', 'STATUS_VHD_PARENT_VHD_ACCESS_DENIED', 'RPC_C_QOS_CAPABILITIES_DEFAULT', 'SE_BACKUP_NAME', 'IMAGE_FILE_BYTES_REVERSED_HI', 'STATUS_CTX_INVALID_PD', 'STATUS_RESUME_HIBERNATION', 'STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET', 'FILE_SUPPORTS_SPARSE_FILES', 'ERROR_MEDIA_CHECK', 'PKCS_ATTRIBUTE', 'STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY', 'ERROR_EVT_FILTER_UNEXPECTEDTOKEN', 'STATUS_LPC_REQUESTS_NOT_ALLOWED', 'IMAGE_DIRECTORY_ENTRY_BASERELOC', 'STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE', 'EVENT_TRACE_TYPE_CONFIG_POWER', 'SM_CXEDGE', 'STATUS_NO_DATA_DETECTED', 'CRYPT_ACQUIRE_SILENT_FLAG', 'CERT_COMPARE_ISSUER_OF', 'szOID_OIWSEC_desMAC', 'STATUS_REMOTE_SESSION_LIMIT', 'STATUS_WAS_LOCKED', 'CRYPT_ACQUIRE_NO_HEALING', 'SE_AUDIT_NAME', 'STATUS_SERVER_UNAVAILABLE', 'ERROR_EVT_INVALID_QUERY', 'STATUS_NTLM_BLOCKED', 'STATUS_FLT_INVALID_CONTEXT_REGISTRATION', 'STATUS_THREAD_WAS_SUSPENDED', 'GENERIC_ALL', 'THREAD_DIRECT_IMPERSONATION', 'CERT_OCSP_RESPONSE_PROP_ID', 'EVENT_TRACE_TYPE_CONFIG_SERVICES', 'CERT_E_MALFORMED', 'WTD_UI_ALL', 'STATUS_IO_REISSUE_AS_CACHED', 'RPC_NT_INVALID_OBJECT', 'STATUS_DUPLICATE_NAME', 'DEBUG_EVENT_SYSTEM_ERROR', 'CERT_SYSTEM_STORE_CURRENT_SERVICE', 'ERROR_STOPPED_ON_SYMLINK', 'RPC_NT_ENTRY_ALREADY_EXISTS', 'AF_PUP', 'CERT_STORE_PROV_SYSTEM_REGISTRY_A', 'STATUS_PROCESS_NOT_IN_JOB', 'ERROR_DLL_INIT_FAILED_LOGOFF', 'STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED', 'IMAGE_FILE_MACHINE_ARMNT', 'NTE_BAD_HASH_STATE', 'MEM_PRIVATE', 'STATUS_NO_MATCH', 'szOID_RSA_extCertAttrs', 'PRODUCT_STANDARD_SERVER_CORE', 'szOID_ECC_CURVE_P521', 'SE_PRIVILEGE_REMOVED', 'STATUS_PROFILING_NOT_STOPPED', 'STATUS_NOLOGON_SERVER_TRUST_ACCOUNT', 'STATUS_IPSEC_WRONG_SA', 'PRODUCT_MULTIPOINT_PREMIUM_SERVER', 'STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS', 'STATUS_LOG_ARCHIVE_IN_PROGRESS', 'STATUS_NOT_MAPPED_DATA', 'WTD_CHOICE_FILE', 'ERROR_CARDBUS_NOT_SUPPORTED', 'STATUS_PATH_NOT_COVERED', 'CMSG_SIGNER_COUNT_PARAM', 'ERROR_TOO_MANY_SESS', 'OS_XPORGREATER', 'CERT_INFO_EXTENSION_FLAG', 'SM_CXDOUBLECLK', 'STATUS_WORKING_SET_QUOTA', 'ALPC_PORFLG_ALLOW_LPC_REQUESTS', 'STATUS_NOTHING_TO_TERMINATE', 'STG_LAYOUT_SEQUENTIAL', 'STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG', 'STATUS_INVALID_LOCK_RANGE', 'SERVICE_ACCEPT_HARDWAREPROFILECHANGE', 'NTE_BAD_KEYSET', 'CERT_STORE_ADD_REPLACE_EXISTING', 'CMSG_COMPUTED_HASH_PARAM', 'ERROR_TRANSACTION_REQUEST_NOT_VALID', 'AF_UNSPEC', 'CMSG_SIGNER_UNAUTH_ATTR_PARAM', 'ATTRIBUTE_SECURITY_INFORMATION', 'RPC_RESPONSE_TYPE_BIND_OK', 'ERROR_NOT_SAME_DEVICE', 'ERROR_EVT_PUBLISHER_DISABLED', 'ERROR_REQ_NOT_ACCEP', 'STATUS_ALREADY_COMMITTED', 'USAGE_MATCH_TYPE_AND', 'SE_ENABLE_DELEGATION_NAME', 'STATUS_NOT_REGISTRY_FILE', 'DRIVE_FIXED', 'SECTION_QUERY', 'SERVICE_TRIGGER_DATA_TYPE_BINARY', 'ERROR_BUFFER_ALL_ZEROS', 'CERT_QUERY_CONTENT_FLAG_ALL', 'STATUS_NDIS_INVALID_PACKET', 'ERROR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE', 'STARTF_USESTDHANDLES', 'PROV_SPYRUS_LYNKS', 'STATUS_CLUSTER_NO_NET_ADAPTERS', 'STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET', 'AF_DECnet', 'STATUS_IO_PRIVILEGE_FAILED', 'PROCESS_CREATE_PROCESS', 'RPC_NT_OBJECT_NOT_FOUND', 'CERT_DATE_STAMP_PROP_ID', 'ERROR_EVT_FILTER_PARSEERR', 'szOID_RSA_unstructName', 'ACCESS_MIN_MS_ACE_TYPE', 'STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED', 'STATUS_UNSUCCESSFUL', 'STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM', 'STATUS_ILLEGAL_FUNCTION', 'STATUS_FVE_CONV_WRITE_ERROR', 'SM_MENUDROPALIGNMENT', 'CRYPT_E_INVALID_MSG_TYPE', 'STATUS_IPSEC_DOSP_MAX_ENTRIES', 'STATUS_NDIS_FILE_NOT_FOUND', 'RRF_RT_REG_SZ', 'STATUS_FLT_INTERNAL_ERROR', 'DNS_TYPE_MX', 'STATUS_DS_RIDMGR_INIT_ERROR', 'ERROR_BAD_FUNCTION_TABLE', 'DNS_TYPE_MB', 'STATUS_FT_READ_RECOVERY_FROM_BACKUP', 'DNS_TYPE_MG', 'DNS_TYPE_MF', 'DNS_TYPE_MD', 'STATUS_SERIAL_MORE_WRITES', 'SEC_PROTECTED_IMAGE', 'SERVICE_RUNS_IN_SYSTEM_PROCESS', 'STATUS_SYSTEM_SHUTDOWN', 'STATUS_LOGON_SESSION_COLLISION', 'CMSG_LENGTH_ONLY_FLAG', 'ACCESS_MAX_MS_V2_ACE_TYPE', 'ERROR_INVALID_HW_PROFILE', 'IMAGE_FILE_MACHINE_M32R', 'PRODUCT_WEB_SERVER', 'STATUS_SYSTEM_HIVE_TOO_LARGE', 'STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED', 'IMAGE_SCN_MEM_NOT_PAGED', 'STATUS_INVALID_CONNECTION', 'SE_IMPERSONATE_NAME', 'CALLBACK_MODIFY_STATE', 'SE_GROUP_INTEGRITY', 'ERROR_BAD_SERVICE_ENTRYPOINT', 'STATUS_KEY_HAS_CHILDREN', 'ERROR_OPLOCK_SWITCHED_TO_NEW_HANDLE', 'ERROR_DBG_UNABLE_TO_PROVIDE_HANDLE', 'CERT_COMPARE_SUBJECT_INFO_ACCESS', 'DNS_TYPE_ALL', 'CERT_COMPARE_NAME_STR_A', 'STATUS_INVALID_LEVEL', 'ERROR_INVALID_EXE_SIGNATURE', 'STATUS_IP_ADDRESS_CONFLICT1', 'ERROR_TOO_MANY_OPEN_FILES', 'CERT_E_INVALID_POLICY', 'STATUS_SXS_MANIFEST_PARSE_ERROR', 'ERROR_BROKEN_PIPE', 'CREATE_IGNORE_SYSTEM_DEFAULT', 'CERT_TRUST_INVALID_POLICY_CONSTRAINTS', 'STATUS_GRACEFUL_DISCONNECT', 'EVENTLOG_AUDIT_SUCCESS', 'CERT_COMPARE_NAME_STR_W', 'FILE_ACTION_MODIFIED', 'ERROR_NETWORK_BUSY', 'STATUS_BAD_MASTER_BOOT_RECORD', 'IMAGE_DLLCHARACTERISTICS_APPCONTAINER', 'STATUS_NO_SUCH_PRIVILEGE', 'ERROR_SEM_USER_LIMIT', 'STATUS_BAD_INHERITANCE_ACL', 'szOID_INFOSEC_mosaicKMandSig', 'STATUS_SMARTCARD_NO_CARD', 'ERROR_SYSTEM_POWERSTATE_COMPLEX_TRANSITION', 'STATUS_INVALID_PARAMETER_10', 'FILE_FLAG_OPEN_NO_RECALL', 'SM_MOUSEHORIZONTALWHEELPRESENT', 'FILE_NO_INTERMEDIATE_BUFFERING', 'ERROR_PIPE_LOCAL', 'X509_NAME_VALUE', 'ERROR_FILE_SYSTEM_LIMITATION', 'CERT_STORE_PROV_MEMORY', 'STATUS_INVALID_USER_BUFFER', 'TOKEN_MANDATORY_POLICY_OFF', 'STATUS_NONCONTINUABLE_EXCEPTION', 'STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY', 'STATUS_MAPPED_ALIGNMENT', 'STATUS_DEVICE_OFF_LINE', 'STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE', 'STATUS_RECOVERY_FAILURE', 'IMAGE_SCN_TYPE_NOLOAD', 'ALPC_PORFLG_SYSTEM_PROCESS', 'szOID_OIWSEC_keyHashSeal', 'STATUS_FWP_INCOMPATIBLE_TXN', 'ERROR_PAGE_FAULT_COPY_ON_WRITE', 'E_UNEXPECTED', 'STATUS_SOURCE_ELEMENT_EMPTY', 'ERROR_EXE_MACHINE_TYPE_MISMATCH', 'LABEL_SECURITY_INFORMATION', 'STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION', 'STATUS_REPARSE_OBJECT', 'DNS_QUERY_DNSSEC_CHECKING_DISABLED', 'RPC_C_IMP_LEVEL_ANONYMOUS', 'STATUS_CTX_SHADOW_DENIED', 'ERROR_INVALID_DRIVE', 'STATUS_ILL_FORMED_SERVICE_ENTRY', 'STATUS_ADDRESS_ALREADY_EXISTS', 'STATUS_FWP_INVALID_ENUMERATOR', 'SE_GROUP_MANDATORY', 'RPC_NT_NO_MORE_BINDINGS', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN', 'CERT_KEY_PROV_HANDLE_PROP_ID', 'STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN', 'IMAGE_SCN_MEM_FARDATA', 'TOKEN_ALL_ACCESS_P', 'STATUS_INVALID_GROUP_ATTRIBUTES', 'STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST', 'STATUS_SECTION_PROTECTION', 'STATUS_WMI_SET_FAILURE', 'GENERIC_READ', 'STATUS_WMI_TRY_AGAIN', 'szOID_RSA_RC5_CBCPad', 'DNS_TYPE_A', 'STATUS_CTX_CLIENT_LICENSE_IN_USE', 'STATUS_WAIT_63', 'OS_WIN2000PRO', 'STATUS_MUI_FILE_NOT_FOUND', 'CMSG_CMS_SIGNER_INFO_PARAM', 'ERROR_MAX_SESSIONS_REACHED', 'SM_DIGITIZER', 'RPC_NT_INTERFACE_NOT_FOUND', 'CMSG_TYPE_PARAM', 'SE_INC_BASE_PRIORITY_NAME', 'MS_STRONG_PROV', 'JOB_OBJECT_ALL_ACCESS', 'SEC_NOCACHE', 'CRYPT_ARCHIVABLE', 'STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN', 'STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER', 'ERROR_IP_ADDRESS_CONFLICT2', 'ERROR_IP_ADDRESS_CONFLICT1', 'STATUS_ASSERTION_FAILURE', 'REG_QWORD', 'RPC_NT_INVALID_NETWORK_OPTIONS', 'ERROR_USER_APC', 'SM_CXMIN', 'CMSG_VERSION_PARAM', 'ERROR_CANNOT_MAKE', 'EVENTLOG_INFORMATION_TYPE', 'STATUS_FWP_KM_CLIENTS_ONLY', 'BG_NOTIFY_JOB_TRANSFERRED', 'STATUS_NO_MORE_ENTRIES', 'STATUS_FWP_PROVIDER_NOT_FOUND', 'STATUS_SXS_IDENTITIES_DIFFERENT', 'RPC_NT_INVALID_ASYNC_HANDLE', 'FILE_OPEN_IF', 'STATUS_ORDINAL_NOT_FOUND', 'CREATE_BREAKAWAY_FROM_JOB', 'STATUS_TOO_LATE', 'STATUS_PORT_UNREACHABLE', 'IMAGE_SCN_CNT_INITIALIZED_DATA', 'STATUS_VOLUME_MOUNTED', 'STATUS_JOURNAL_DELETE_IN_PROGRESS', 'PRODUCT_ENTERPRISE', 'STATUS_GRAPHICS_INVALID_CLIENT_TYPE', 'STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE', 'STATUS_INVALID_DOMAIN_STATE', 'DNS_TYPE_AFSDB', 'STATUS_INSUFFICIENT_RESOURCES', 'IMAGE_DLLCHARACTERISTICS_NO_ISOLATION', 'STATUS_PORT_ALREADY_SET', 'STATUS_SXS_CORRUPTION', 'STATUS_LM_CROSS_ENCRYPTION_REQUIRED', 'STATUS_DATA_NOT_ACCEPTED', 'X509_EXTENSIONS', 'RPC_C_AUTHN_LEVEL_NONE', 'STATUS_SERIAL_COUNTER_TIMEOUT', 'STATUS_ABANDONED', 'STATUS_UNDEFINED_CHARACTER', 'ERROR_ASSERTION_FAILURE', 'STATUS_GRAPHICS_INVALID_STRIDE', 'STATUS_INVALID_CID', 'STATUS_NDIS_ALREADY_MAPPED', 'SM_CXMINSPACING', 'STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION', 'STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR', 'szOID_INFOSEC_sdnsIntegrity', 'CERT_NAME_FRIENDLY_DISPLAY_TYPE', 'IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR', 'STATUS_CLUSTER_NODE_UNREACHABLE', 'STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST', 'ERROR_REM_NOT_LIST', 'STATUS_FILE_INVALID', 'STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS', 'STATUS_WAIT_0', 'SM_CXSMICON', 'STATUS_ONLY_IF_CONNECTED', 'STATUS_FLT_BUFFER_TOO_SMALL', 'STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY', 'STATUS_ISSUING_CA_UNTRUSTED_KDC', 'szOID_TRUSTED_CODESIGNING_CA_LIST', 'ERROR_NO_ACE_CONDITION', 'REPORT_NO_PRIVATE_KEY', 'STATUS_TRANSACTIONMANAGER_NOT_FOUND', 'STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED', 'STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT', 'STGM_CREATE', 'CERT_SHA1_HASH_PROP_ID', 'STATUS_REPLY_MESSAGE_MISMATCH', 'DNS_TYPE_TEXT', 'STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME', 'STATUS_GRAPHICS_OPM_INVALID_HANDLE', 'CERT_STORE_PROV_SYSTEM_REGISTRY', 'MEM_IMAGE', 'CRYPT_USER_KEYSET', 'STATUS_FWP_NO_TXN_IN_PROGRESS', 'STATUS_EFS_ALG_BLOB_TOO_BIG', 'CMSG_BARE_CONTENT_FLAG', 'ERROR_SEGMENT_NOTIFICATION', 'szOID_RSA_preferSignedData', 'ERROR_SAME_DRIVE', 'ERROR_NOACCESS', 'X509_PUBLIC_KEY_INFO', 'ERROR_EVT_CHANNEL_NOT_FOUND', 'SE_INC_WORKING_SET_NAME', 'KEY_EXECUTE', 'EXCEPTION_INVALID_HANDLE', 'IO_COMPLETION_ALL_ACCESS', 'RPC_NT_UNKNOWN_AUTHN_LEVEL', 'MS_DEF_RSA_SIG_PROV', 'NTE_BAD_ALGID', 'RPC_S_UNKNOWN_IF', 'STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG', 'szOID_SEALING_SIGNATURE', 'FILE_OPEN_BY_FILE_ID', 'RPC_NT_UNSUPPORTED_NAME_SYNTAX', 'STATUS_NOT_TINY_STREAM', 'SW_SHOWNA', 'CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT', 'STATUS_FS_DRIVER_REQUIRED', 'szOID_OIWSEC_md4RSA', 'szOID_NESTED_SIGNATURE', 'CERT_CHAIN_REVOCATION_CHECK_END_CERT', 'STATUS_LOG_EPHEMERAL', 'S_OK', 'ERROR_NO_MORE_MATCHES', 'IMAGE_FILE_MACHINE_MIPS16', 'SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP', 'STATUS_AUDITING_DISABLED', 'STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY', 'FILE_ADD_FILE', 'STATUS_FLT_NO_HANDLER_DEFINED', 'EXCEPTION_FLT_STACK_CHECK', 'CMSG_BARE_CONTENT_PARAM', 'EVENT_TRACE_PRIVATE_LOGGER_MODE', 'TRUST_E_FAIL', 'STATUS_SERVER_DISABLED', 'ERROR_PROFILING_NOT_STOPPED', 'SERVICE_DEMAND_START', 'STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED', 'RPC_NT_SS_HANDLES_MISMATCH', 'STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION', 'CONTROL_C_EXIT', 'STATUS_REGISTRY_CORRUPT', 'MS_DEF_RSA_SIG_PROV_A', 'STATUS_NDIS_UNSUPPORTED_REVISION', 'CERT_ENCODING_TYPE_MASK', 'STATUS_PNP_TRANSLATION_FAILED', 'STATUS_RESOURCEMANAGER_READ_ONLY', 'SE_RELABEL_NAME', 'ERROR_QUOTA_LIST_INCONSISTENT', 'STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE', 'ERROR_STACK_OVERFLOW', 'szOID_ECC_PUBLIC_KEY', 'DNS_TYPE_SIG', 'ERROR_SEM_TIMEOUT', 'CMSG_UNPROTECTED_ATTR_PARAM', 'FILE_SUPPORTS_OBJECT_IDS', 'STATUS_INVALID_QUOTA_LOWER', 'STATUS_NDIS_RESET_IN_PROGRESS', 'EVENTLOG_SEQUENTIAL_READ', 'IMAGE_SCN_CNT_CODE', 'CERT_NAME_DISABLE_IE4_UTF8_FLAG', 'STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR', 'ABOVE_NORMAL_PRIORITY_CLASS', 'PROV_DSS', 'STATUS_CLUSTER_NODE_ALREADY_DOWN', 'ERROR_INVALID_FLAG_NUMBER', 'SM_CYBORDER', 'IMAGE_SCN_GPREL', 'szOID_RFC3161_counterSign', 'ERROR_FILE_INVALID', 'STATUS_RM_METADATA_CORRUPT', 'ERROR_OPLOCK_NOT_GRANTED', 'ERROR_INVALID_SEGDPL', 'PRODUCT_DATACENTER_SERVER_CORE_V', 'ERROR_ABIOS_ERROR', 'RPC_NT_BYTE_COUNT_TOO_SMALL', 'DNS_TYPE_RT', 'RPC_RESPONSE_TYPE_SUCCESS', 'DNS_TYPE_RP', 'X509_KEY_ATTRIBUTES', 'OS_ANYSERVER', 'STATUS_TRANSACTION_NOT_ENLISTED', 'WTD_UI_NONE', 'STATUS_GRAPHICS_ALLOCATION_CLOSED', 'FILE_ATTRIBUTE_SYSTEM', 'X509_OCTET_STRING', 'STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION', 'FILE_WRITE_ATTRIBUTES', 'ERROR_NO_TOKEN', 'ERROR_INVALID_ORDINAL', 'PRODUCT_STORAGE_EXPRESS_SERVER', 'IMAGE_DIRECTORY_ENTRY_SECURITY', 'STATUS_INVALID_SID', 'STATUS_FLOAT_STACK_CHECK', 'STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST', 'IMAGE_SCN_MEM_READ', 'STATUS_CRED_REQUIRES_CONFIRMATION', 'STATUS_FLT_VOLUME_NOT_FOUND', 'ERROR_MAX_THRDS_REACHED', 'SPC_INDIRECT_DATA_OBJID', 'SERVICE_CONTROL_NETBINDADD', 'X509_ANY_STRING', 'ERROR_EAS_NOT_SUPPORTED', 'STATUS_GRAPHICS_INVALID_FREQUENCY', 'CONTEXT_CONTROL', 'szOID_RSA_SHA256RSA', 'PAGE_EXECUTE_WRITECOPY', 'SM_CXSCREEN', 'CRYPT_E_NOT_DECRYPTED', 'STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED', 'SM_CXDLGFRAME', 'STATUS_GRAPHICS_OPM_NOT_SUPPORTED', 'STATUS_DRIVER_BLOCKED', 'ERROR_REGISTRY_RECOVERED', 'SECURITY_MANDATORY_SYSTEM_RID', 'CREATE_SEPARATE_WOW_VDM', 'STATUS_NDIS_DEVICE_FAILED', 'ERROR_ENVVAR_NOT_FOUND', 'ERROR_INVALID_FLAGS', 'DBG_PRINTEXCEPTION_C', 'STATUS_FVE_AUTH_INVALID_CONFIG', 'STARTF_FORCEOFFFEEDBACK', 'ERROR_TOO_MANY_NAMES', 'SERVICE_INTERACTIVE_PROCESS', 'STATUS_ACPI_POWER_REQUEST_FAILED', 'STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED', 'OS_NT', 'CREATE_THREAD_DEBUG_EVENT', 'ERROR_EVENT_PENDING', 'STATUS_INVALID_EA_NAME', 'ERROR_TRANSACTION_ALREADY_COMMITTED', 'X509_AUTHORITY_KEY_ID', 'ERROR_FORMS_AUTH_REQUIRED', 'PRODUCT_STANDARD_SERVER_V', 'MS_ENH_RSA_AES_PROV_XP_W', 'STATUS_FLOPPY_UNKNOWN_ERROR', 'STATUS_PROCESS_IS_TERMINATING', 'ERROR_CALL_NOT_IMPLEMENTED', 'IMAGE_FILE_MACHINE_MIPSFPU', 'STATUS_TIMER_RESUME_IGNORED', 'DNS_QUERY_NO_RECURSION', 'STATUS_INVALID_DISPOSITION', 'CERT_TRUST_IS_OFFLINE_REVOCATION', 'SM_ARRANGE', 'SW_SHOWNORMAL', 'CRYPT_ENCODE_DECODE_NONE', 'MS_ENHANCED_PROV_W', 'PROV_DSS_DH', 'STATUS_INTEGER_OVERFLOW', 'CMSG_CERT_PARAM', 'ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE', 'STATUS_ILLEGAL_CHARACTER', 'ERROR_FILE_NOT_FOUND', 'CRYPT_DEFAULT_CONTAINER_OPTIONAL', 'ERROR_DBG_CONTROL_BREAK', 'STATUS_IPSEC_INTEGRITY_CHECK_FAILED', 'szOID_DSALG_RSA', 'RPC_NT_INVALID_BOUND', 'STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE', 'ERROR_ABANDON_HIBERFILE', 'STATUS_LOCK_NOT_GRANTED', 'ERROR_FLOPPY_VOLUME', 'AF_UNKNOWN1', 'PIPE_ACCESS_OUTBOUND', 'SERVICE_CONTROL_NETBINDENABLE', 'RPC_NT_NO_INTERFACES', 'STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE', 'szOID_RSA_signEnvData', 'STATUS_NO_SUCH_USER', 'SECTION_MAP_READ', 'STATUS_UNEXPECTED_IO_ERROR', 'STATUS_WRONG_PASSWORD_CORE', 'SECTION_MAP_EXECUTE', 'STATUS_CTX_CONSOLE_CONNECT', 'EVENT_ALL_ACCESS', 'STATUS_WRONG_EFS', 'STATUS_WMI_INSTANCE_NOT_FOUND', 'DNS_QUERY_DONT_RESET_TTL_VALUES', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_UINT64', 'CERT_QUERY_OBJECT_FILE', 'DNS_TYPE_PTR', 'SCOPE_SECURITY_INFORMATION', 'STATUS_FLT_DUPLICATE_ENTRY', 'IMAGE_FILE_AGGRESIVE_WS_TRIM', 'STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER', 'STATUS_TOO_MANY_GUIDS_REQUESTED', 'STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED', 'ERROR_BAD_FILE_TYPE', 'STATUS_MUST_BE_KDC', 'szOID_INFOSEC_mosaicConfidentiality', 'DNS_QUERY_ADDRCONFIG', 'STATUS_NDIS_BAD_VERSION', 'STATUS_TRANSACTION_RECORD_TOO_LONG', 'ERROR_NO_CALLBACK_ACTIVE', 'ERROR_GEN_FAILURE', 'CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED', 'FILE_SHARE_DELETE', 'STATUS_ACPI_FATAL', 'CRYPT_E_UNEXPECTED_ENCODING', 'CERT_STORE_PROV_SYSTEM_A', 'STATUS_CTX_TD_ERROR', 'STATUS_DS_VERSION_CHECK_FAILURE', 'STATUS_IN_PAGE_ERROR', 'NTE_BAD_KEY', 'ERROR_CALLBACK_POP_STACK', 'ERROR_INTERRUPT_VECTOR_ALREADY_CONNECTED', 'CERT_TRUST_IS_NOT_TIME_VALID', 'SERVICE_ACCEPT_STOP', 'CMSG_VERIFY_SIGNER_CERT', 'CERT_STORE_PROV_SYSTEM_W', 'STANDARD_RIGHTS_REQUIRED', 'RPC_NT_INVALID_BINDING', 'DNS_TYPE_HINFO', 'ERROR_UNEXPECTED_MM_MAP_ERROR', 'STATUS_NOT_SERVER_SESSION', 'STATUS_INVALID_SUB_AUTHORITY', 'STATUS_ACPI_ADDRESS_NOT_MAPPED', 'SERVICE_RECOGNIZER_DRIVER', 'ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND', 'CAT_MEMBERINFO_OBJID', 'RRF_RT_ANY', 'CERT_INFO_VERSION_FLAG', 'CERT_TRUST_IS_COMPLEX_CHAIN', 'CRYPT_USER_PROTECTED', 'STATUS_ENCRYPTION_FAILED', 'ERROR_FS_DRIVER_REQUIRED', 'FILE_CASE_SENSITIVE_SEARCH', 'IMAGE_DLLCHARACTERISTICS_GUARD_CF', 'STATUS_DS_DOMAIN_RENAME_IN_PROGRESS', 'STATUS_INVALID_TASK_NAME', 'STATUS_ACPI_MUTEX_NOT_OWNER', 'TOKEN_SECURITY_ATTRIBUTE_CUSTOM_FLAGS', 'STATUS_NOT_SAME_DEVICE', 'NTE_SYS_ERR', 'STATUS_LPC_RECEIVE_BUFFER_EXPECTED', 'STGM_PRIORITY', 'STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL', 'STATUS_EVENTLOG_FILE_CHANGED', 'STATUS_CRM_PROTOCOL_ALREADY_EXISTS', 'STATUS_CONFLICTING_ADDRESSES', 'SW_SHOWMINIMIZED', 'STATUS_RECOVERY_NOT_NEEDED', 'STATUS_DS_HAVE_PRIMARY_MEMBERS', 'STATUS_POSSIBLE_DEADLOCK', 'ERROR_DRIVER_FAILED_PRIOR_UNLOAD', 'PROCESS_QUERY_LIMITED_INFORMATION', 'STGM_DIRECT_SWMR', 'STATUS_BAD_CLUSTERS', 'RPC_NT_INVALID_PIPE_OBJECT', 'STATUS_WX86_FLOAT_STACK_CHECK', 'STATUS_INSUFFICIENT_POWER', 'SM_CYCAPTION', 'CMSG_CMS_RECIPIENT_INFO_PARAM', 'CERT_INFO_ISSUER_UNIQUE_ID_FLAG', 'szOID_ECDSA_SHA384', 'szOID_RSA_SMIMEalgCMSRC2wrap', 'STATUS_SEMAPHORE_LIMIT_EXCEEDED', 'SE_CREATE_TOKEN_NAME', 'DRIVE_NO_ROOT_DIR', 'MS_ENHANCED_PROV', 'CERT_SUBJECT_NAME_MD5_HASH_PROP_ID', 'STATUS_FVE_KEYFILE_INVALID', 'TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN', 'STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE', 'szOID_NIST_AES192_CBC', 'STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED', 'CMSG_CTRL_VERIFY_SIGNATURE_EX', 'STATUS_SXS_FILE_HASH_MISMATCH', 'ERROR_OUT_OF_STRUCTURES', 'CMSG_RECIPIENT_INDEX_PARAM', 'IMAGE_FILE_MACHINE_R4000', 'STATUS_CANT_OPEN_ANONYMOUS', 'RPC_NT_INVALID_STRING_BINDING', 'STATUS_TXF_METADATA_ALREADY_PRESENT', 'COMPRESSION_ENGINE_STANDARD', 'STATUS_FWP_NOT_FOUND', 'MUTANT_QUERY_STATE', 'STATUS_WRONG_COMPARTMENT', 'SPC_COMMERCIAL_SP_KEY_PURPOSE_OBJID', 'STATUS_PKU2U_CERT_FAILURE', 'SM_CLEANBOOT', 'ERROR_WAIT_63', 'STATUS_GRAPHICS_NO_PREFERRED_MODE', 'IMAGE_SCN_ALIGN_1024BYTES', 'SE_SELF_RELATIVE', 'STATUS_OPEN_FAILED', 'CRYPT_E_MSG_ERROR', 'ERROR_CANCEL_VIOLATION', 'ERROR_READ_FAULT', 'ERROR_EXTRANEOUS_INFORMATION', 'STATUS_PWD_TOO_SHORT', 'CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED', 'CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS', 'FILE_FLAG_SEQUENTIAL_SCAN', 'STATUS_NOT_EXPORT_FORMAT', 'STATUS_CHECKOUT_REQUIRED', 'STATUS_OBJECT_PATH_INVALID', 'STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE', 'STATUS_CTX_LICENSE_NOT_AVAILABLE', 'OUTPUT_DEBUG_STRING_EVENT', 'CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT', 'STATUS_DRIVER_FAILED_SLEEP', 'STATUS_GRAPHICS_MODE_NOT_PINNED', 'STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS', 'CMSG_VERIFY_SIGNER_NULL', 'KEY_CREATE_LINK', 'szOID_INFOSEC_mosaicSignature', 'ERROR_INVALID_ADDRESS', 'PROV_DH_SCHANNEL', 'FILE_NOTIFY_CHANGE_FILE_NAME', 'STATUS_CROSSREALM_DELEGATION_FAILURE', 'ERROR_INVALID_LOCK_RANGE', 'STATUS_PNP_INVALID_ID', 'KEY_ENUMERATE_SUB_KEYS', 'CERT_STORE_CRL_CONTEXT', 'SECTION_EXTEND_SIZE', 'STATUS_GRAPHICS_DATASET_IS_EMPTY', 'STATUS_INVALID_IMAGE_WIN_32', 'ERROR_NO_VOLUME_LABEL', 'CALLBACK_ALL_ACCESS', 'ERROR_REGISTRY_HIVE_RECOVERED', 'CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY', 'STATUS_TRANSACTION_TIMED_OUT', 'STATUS_BREAKPOINT', 'STATUS_CLUSTER_INVALID_NETWORK', 'SERVICE_CONTROL_NETBINDREMOVE', 'STATUS_INCOMPATIBLE_DRIVER_BLOCKED', 'EVENT_TRACE_TYPE_CONFIG_NIC', 'szOID_INFOSEC', 'STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST', 'SPC_FINANCIAL_CRITERIA_OBJID', 'PROCESS_VM_READ', 'DNS_ATMA_MAX_ADDR_LENGTH', 'TOKEN_ALL_ACCESS', 'STATUS_POLICY_ONLY_IN_DS', 'STATUS_FLT_VOLUME_ALREADY_MOUNTED', 'STATUS_CURRENT_TRANSACTION_NOT_VALID', 'STATUS_AUTHIP_FAILURE', 'NTE_INVALID_PARAMETER', 'NTE_SIGNATURE_FILE_BAD', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_INT64', 'ERROR_NO_PAGEFILE', 'PROCESS_TRUST_LABEL_SECURITY_INFORMATION', 'ERROR_UNRECOGNIZED_VOLUME', 'CMSG_CTRL_DEL_CRL', 'RPC_NT_NO_PROTSEQS_REGISTERED', 'STATUS_ABANDON_HIBERFILE', 'STATUS_IMAGE_ALREADY_LOADED', 'CRYPT_NDR_ENCODING', 'STATUS_ENTRYPOINT_NOT_FOUND', 'ERROR_NOTIFY_ENUM_DIR', 'STATUS_ALPC_CHECK_COMPLETION_LIST', 'DNS_QUERY_DNSSEC_OK', 'RPC_NT_ALREADY_LISTENING', 'FILE_NOTIFY_CHANGE_LAST_ACCESS', 'ERROR_PORT_NOT_SET', 'OS_APPLIANCE', 'SM_CXICONSPACING', 'CERT_SYSTEM_STORE_CURRENT_USER_ID', 'SEMAPHORE_ALL_ACCESS', 'STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS', 'ERROR_CRASH_DUMP', 'ERROR_LOCK_VIOLATION', 'DEBUG_EVENT_EXIT_PROCESS', 'MEM_RELEASE', 'STATUS_PTE_CHANGED', 'ALPC_HANDLEFLG_DUPLICATE_INHERIT', 'STATUS_PARITY_ERROR', 'CMSG_CMS_ENCAPSULATED_CONTENT_FLAG', 'STATUS_IPSEC_QUEUE_OVERFLOW', 'INHERIT_CALLER_PRIORITY', 'IMAGE_SCN_NO_DEFER_SPEC_EXC', 'STATUS_NDIS_OPEN_FAILED', 'STATUS_PNP_REBOOT_REQUIRED', 'STATUS_WMI_ALREADY_DISABLED', 'ERROR_OBJECT_NAME_EXISTS', 'EVENT_TRACE_FILE_MODE_APPEND', 'FAX_JOB_MANAGE', 'STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED', 'EVENT_TRACE_FLAG_DBGPRINT', 'ERROR_BAD_DRIVER_LEVEL', 'AF_INET6', 'STATUS_FWP_CONDITION_NOT_FOUND', 'PIPE_ACCESS_INBOUND', 'ERROR_BUFFER_OVERFLOW', 'STATUS_INVALID_VIEW_SIZE', 'NTE_BAD_KEY_STATE', 'STATUS_IPSEC_DOSP_INVALID_PACKET', 'SERVICE_ACCEPT_TIMECHANGE', 'STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED', 'STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY', 'CERT_TRUST_IS_PEER_TRUSTED', 'STATUS_IPSEC_DOSP_RECEIVED_MULTICAST', 'szOID_OIWSEC_shaDSA', 'KEY_CREATE_SUB_KEY', 'SM_CXCURSOR', 'STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET', 'E_INVALIDARG', 'PKCS12_PREFER_CNG_KSP', 'STATUS_DEVICE_NOT_READY', 'PROCESS_TRACE_MODE_EVENT_RECORD', 'SDDL_REVISION_1', 'SERVICE_AUTO_START', 'OS_HOME', 'WTD_CHOICE_CATALOG', 'CERT_STORE_PROV_PKCS12', 'RPC_NT_UNKNOWN_MGR_TYPE', 'STATUS_CALLBACK_RETURNED_THREAD_PRIORITY', 'SM_CYMINSPACING', 'STATUS_NOT_SUPPORTED_ON_SBS', 'ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE', 'RPC_NT_PROTSEQ_NOT_FOUND', 'STATUS_GRAPHICS_PRESENT_OCCLUDED', 'SM_XVIRTUALSCREEN', 'TOKEN_ADJUST_GROUPS', 'CMSG_SIGNER_INFO_PARAM', 'DBG_EXCEPTION_NOT_HANDLED', 'FILE_SUPPORTS_EXTENDED_ATTRIBUTES', 'DNS_QUERY_RETURN_MESSAGE', 'STATUS_NO_SUCH_ALIAS', 'NTE_BUFFERS_OVERLAP', 'X509_MULTI_BYTE_INTEGER', 'STATUS_SXS_VERSION_CONFLICT', 'STATUS_IO_REPARSE_DATA_INVALID', 'IMAGE_DLLCHARACTERISTICS_NO_SEH', 'ACCESS_DENIED_ACE_TYPE', 'STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE', 'ERROR_EVT_FILTER_TOO_COMPLEX', 'szOID_INFOSEC_sdnsTokenProtection', 'STATUS_AUDIT_FAILED', 'STATUS_QUOTA_LIST_INCONSISTENT', 'STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED', 'PRODUCT_PROFESSIONAL', 'HKEY_CLASSES_ROOT', 'IMAGE_FILE_MACHINE_TRICORE', 'STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS', 'EXCEPTION_ACCESS_VIOLATION', 'ACCESS_ALLOWED_COMPOUND_ACE_TYPE', 'X509_BASIC_CONSTRAINTS', 'PERSIST_E_SIZEDEFINITE', 'STATUS_MAX_REFERRALS_EXCEEDED', 'STATUS_BAD_BINDINGS', 'ERROR_BAD_ENVIRONMENT', 'STATUS_WMI_NOT_SUPPORTED', 'SPC_COMMON_NAME_OBJID', 'STATUS_WOW_ASSERTION', 'REG_SZ', 'EXIT_THREAD_DEBUG_EVENT', 'CRYPT_SILENT', 'STATUS_CLIENT_SERVER_PARAMETERS_INVALID', 'ERROR_DEVICE_ALREADY_ATTACHED', 'STATUS_LOG_RESERVATION_INVALID', 'STATUS_TM_INITIALIZATION_FAILED', 'DNS_TYPE_ANY', 'CERT_STORE_DELETE_FLAG', 'ERROR_NO_YIELD_PERFORMED', 'szOID_DSALG', 'STATUS_GRAPHICS_I2C_NOT_SUPPORTED', 'STATUS_CLUSTER_NODE_NOT_MEMBER', 'SERVICE_KERNEL_DRIVER', 'SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE', 'szOID_OIWSEC_desCBC', 'ERROR_HANDLES_CLOSED', 'SERVICE_CONTROL_TRIGGEREVENT', 'STATUS_PAGE_FAULT_TRANSITION', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING', 'SERVICE_CONTROL_SESSIONCHANGE', 'CERT_ENROLLMENT_PROP_ID', 'DNS_QUERY_DUAL_ADDR', 'STATUS_NAME_TOO_LONG', 'szOID_NIST_AES256_WRAP', 'PAGE_READWRITE', 'STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING', 'STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED', 'STATUS_TIMEOUT', 'SE_SYSTEMTIME_NAME', 'SERVICE_TRIGGER_DATA_TYPE_STRING', 'STATUS_CTX_SECURITY_LAYER_ERROR', 'STATUS_TOO_MANY_THREADS', 'MEM_TOP_DOWN', 'CERT_NAME_URL_TYPE', 'SM_YVIRTUALSCREEN', 'SM_MAXIMUMTOUCHES', 'ERROR_FT_READ_RECOVERY_FROM_BACKUP', 'STATUS_SXS_ASSEMBLY_MISSING', 'SERVICE_CONTROL_PRESHUTDOWN', 'ERROR_DBG_CONTROL_C', 'ERROR_PIPE_LISTENING', 'STATUS_KDC_CERT_REVOKED', 'ALPC_SECFLG_CREATE_HANDLE', 'szOID_INFOSEC_sdnsSignature', 'ERROR_BAD_STACK', 'STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION', 'CRYPT_NEWKEYSET', 'DNS_TYPE_CERT', 'CERT_FIND_PROPERTY', 'RPC_NT_NOT_RPC_ERROR', 'STATUS_INVALID_LDT_DESCRIPTOR', 'FILE_ACTION_ADDED', 'szOID_NIST_sha512', 'ACE_OBJECT_TYPE_PRESENT', 'STATUS_FATAL_APP_EXIT', 'STATUS_ILL_FORMED_PASSWORD', 'CERT_REQUEST_ORIGINATOR_PROP_ID', 'FILE_ATTRIBUTE_READONLY', 'STATUS_MARSHALL_OVERFLOW', 'szOID_RSA_SHA1RSA', 'STATUS_INVALID_PARAMETER_2', 'DNS_QUERY_NO_LOCAL_NAME', 'ERROR_BAD_ACCESSOR_FLAGS', 'SPECIFIC_RIGHTS_ALL', 'STATUS_LOG_CONTAINER_READ_FAILED', 'MEM_COMMIT', 'FILE_NOTIFY_CHANGE_CREATION', 'STATUS_SXS_INVALID_DEACTIVATION', 'ERROR_WMI_DP_FAILED', 'STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK', 'szOID_DH_SINGLE_PASS_STDDH_SHA256_KDF', 'STATUS_CORRUPT_SYSTEM_FILE', 'STATUS_GRAPHICS_INVALID_GAMMA_RAMP', 'STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN', 'STATUS_CANNOT_MAKE', 'ERROR_RELOC_CHAIN_XEEDS_SEGLIM', 'TOKEN_SECURITY_ATTRIBUTE_MANDATORY', 'ERROR_WMI_INVALID_MOF', 'COM_EXECUTE', 'CERT_QUERY_CONTENT_SERIALIZED_CRL', 'SPC_SP_OPUS_INFO_OBJID', 'STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET', 'DNS_TYPE_NAPTR', 'FILE_ACTION_REMOVED', 'RRF_RT_DWORD', 'RPC_S_PROTOCOL_ERROR', 'X509_INTEGER', 'STATUS_INVALID_VARIANT', 'szOID_DSALG_HASH', 'STATUS_SAM_NEED_BOOTKEY_FLOPPY', 'STATUS_HANDLE_NO_LONGER_VALID', 'STATUS_WX86_BREAKPOINT', 'DRIVE_RAMDISK', 'STATUS_PAGE_FAULT_PAGING_FILE', 'STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED', 'szOID_RSA_RC2CBC', 'ERROR_EA_TABLE_FULL', 'CERT_FIND_ISSUER_STR_W', 'STATUS_NDIS_UNSUPPORTED_MEDIA', 'STATUS_RM_NOT_ACTIVE', 'ERROR_DIR_NOT_ROOT', 'STATUS_VOLUME_DISMOUNTED', 'PAGE_EXECUTE_READWRITE', 'STATUS_BAD_INITIAL_PC', 'STATUS_PRENT4_MACHINE_ACCOUNT', 'STATUS_TRANSACTION_NOT_JOINED', 'CMSG_CMS_RECIPIENT_COUNT_PARAM', 'STATUS_GRAPHICS_MODE_NOT_IN_MODESET', 'RPC_NT_UNSUPPORTED_TYPE', 'CERT_FIND_ISSUER_STR_A', 'STATUS_ALLOTTED_SPACE_EXCEEDED', 'CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE', 'szOID_DSALG_CRPT', 'STATUS_CSS_RESETS_EXHAUSTED', 'EVENT_TRACE_ADD_HEADER_MODE', 'FILE_SYNCHRONOUS_IO_NONALERT', 'DUPLICATE_CLOSE_SOURCE', 'IMAGE_SCN_ALIGN_4096BYTES', 'DACL_SECURITY_INFORMATION', 'STATUS_FLT_INSTANCE_ALTITUDE_COLLISION', 'OBJ_OPENLINK', 'STATUS_BAD_COMPRESSION_BUFFER', 'STATUS_MEMBER_IN_ALIAS', 'STATUS_AUTHENTICATION_FIREWALL_FAILED', 'STATUS_EA_CORRUPT_ERROR', 'THREAD_IMPERSONATE', 'CMSG_VERIFY_SIGNER_CHAIN', 'PRODUCT_STORAGE_WORKGROUP_SERVER_CORE', 'CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID', 'CERT_TRUST_IS_UNTRUSTED_ROOT', 'STATUS_FLOPPY_BAD_REGISTERS', 'SE_TRUSTED_CREDMAN_ACCESS_NAME', 'SW_RESTORE', 'ERROR_CORRUPT_SYSTEM_FILE', 'FILE_NO_EA_KNOWLEDGE', 'STATUS_IPSEC_INVALID_PACKET', 'STATUS_NOT_ALL_ASSIGNED', 'CRYPT_ACQUIRE_COMPARE_KEY_FLAG', 'CRYPT_E_UNKNOWN_ALGO', 'STATUS_ACCESS_AUDIT_BY_POLICY', 'STATUS_FWP_INVALID_NET_MASK', 'STATUS_FLT_MUST_BE_NONPAGED_POOL', 'ERROR_NETWORK_ACCESS_DENIED', 'STATUS_NETWORK_SESSION_EXPIRED', 'PROV_RSA_FULL', 'ERROR_ELEVATION_REQUIRED', 'ERROR_PNP_BAD_MPS_TABLE', 'ERROR_FILENAME_EXCED_RANGE', 'STATUS_FVE_PIN_INVALID', 'EPT_NT_CANT_CREATE', 'PRODUCT_SERVER_FOR_SB_SOLUTIONS_EM', 'ERROR_DIRECT_ACCESS_HANDLE', 'STATUS_FT_WRITE_RECOVERY', 'STATUS_PORT_NOT_SET', 'STATUS_FLOAT_DIVIDE_BY_ZERO', 'ERROR_SYSTEM_HIVE_TOO_LARGE', 'STATUS_CLUSTER_NODE_EXISTS', 'INHERIT_ONLY_ACE', 'FILE_DOES_NOT_EXIST', 'STATUS_IO_REPARSE_TAG_INVALID', 'EVENT_HEADER_FLAG_TRACE_MESSAGE', 'szOID_RSA_MGF1', 'EVENT_QUERY_STATE', 'STATUS_GRAPHICS_MCA_INTERNAL_ERROR', 'SE_CREATE_SYMBOLIC_LINK_NAME', 'LPC_REPLY', 'ERROR_SEM_IS_SET', 'RPC_NT_SS_IN_NULL_CONTEXT', 'PROCESS_TERMINATE', 'SM_CYFULLSCREEN', 'STATUS_FVE_TRANSIENT_STATE', 'RPC_NT_INVALID_NAF_ID', 'STATUS_INVALID_PARAMETER_11', 'EVENT_HEADER_FLAG_CLASSIC_HEADER', 'ALPC_MSGFLG_RELEASE_MESSAGE', 'ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE', 'WTD_REVOKE_NONE', 'szOID_NIST_AES192_WRAP', 'STATUS_HASH_NOT_PRESENT', 'STATUS_SXS_CANT_GEN_ACTCTX', 'ERROR_DBG_EXCEPTION_NOT_HANDLED', 'STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST', 'STATUS_DS_CANT_MOD_OBJ_CLASS', 'FILE_SUPPORTS_ENCRYPTION', 'DBG_COMMAND_EXCEPTION', 'STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET', 'STATUS_LOG_CLIENT_NOT_REGISTERED', 'STATUS_LOG_BLOCKS_EXHAUSTED', 'szOID_OIWSEC_dsaCommSHA', 'STATUS_INVALID_OPLOCK_PROTOCOL', 'DNS_TYPE_DNSKEY', 'PRODUCT_HOME_BASIC', 'CERT_STORE_PROV_SYSTEM', 'STATUS_DLL_MIGHT_BE_INSECURE', 'STATUS_KDC_CERT_EXPIRED', 'SM_CYSCREEN', 'CERT_STORE_PROV_MSG', 'STATUS_LOGON_TYPE_NOT_GRANTED', 'STATUS_DS_DUPLICATE_ID_FOUND', 'STATUS_NO_S4U_PROT_SUPPORT', 'STATUS_LOG_METADATA_INVALID', 'ERROR_INSUFFICIENT_POWER', 'STATUS_LOG_TAIL_INVALID', 'szOID_OIWSEC_dhCommMod', 'STATUS_LOG_PINNED', 'ERROR_EA_ACCESS_DENIED', 'SYMSEARCH_RECURSE', 'STATUS_ARBITRATION_UNHANDLED', 'STATUS_ACPI_STACK_OVERFLOW', 'CERT_AUTO_ENROLL_RETRY_PROP_ID', 'STATUS_ACPI_ALREADY_INITIALIZED', 'STATUS_INVALID_CRUNTIME_PARAMETER', 'SACL_SECURITY_INFORMATION', 'STATUS_CLUSTER_NETINTERFACE_EXISTS', 'STATUS_SHARED_IRQ_BUSY', 'PRODUCT_ENTERPRISE_SERVER_CORE_V', 'ERROR_NESTING_NOT_ALLOWED', 'STATUS_FAILED_STACK_SWITCH', 'KEY_WRITE', 'STATUS_RM_ALREADY_STARTED', 'CREATE_UNICODE_ENVIRONMENT', 'STATUS_ELEVATION_REQUIRED', 'ERROR_NOT_SUBSTED', 'STATUS_IO_REPARSE_TAG_NOT_HANDLED', 'ERROR_BAD_LENGTH', 'RPC_C_AUTHN_LEVEL_CALL', 'STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION', 'IMAGE_SCN_MEM_PRELOAD', 'RPC_NT_NOTHING_TO_EXPORT', 'ERROR_BAD_FORMAT', 'ERROR_EVT_QUERY_RESULT_STALE', 'szOID_OIWSEC_sha1RSASign', 'szOID_RSA_digestedData', 'DNS_TYPE_SOA', 'STATUS_TRANSACTION_INVALID_TYPE', 'IMAGE_FILE_MACHINE_MIPSFPU16', 'STATUS_PIPE_LISTENING', 'STATUS_FVE_BAD_INFORMATION', 'ERROR_UNSUPPORTED_COMPRESSION', 'VER_NT_DOMAIN_CONTROLLER', 'RPC_NT_SS_CONTEXT_DAMAGED', 'CMSG_CTRL_DEL_SIGNER', 'ATM_ADDR_SIZE', 'SE_SYNC_AGENT_NAME', 'DNS_TYPE_NS', 'FILE_OVERWRITE_IF', 'STATUS_XMLDSIG_ERROR', 'STATUS_GRAPHICS_PRESENT_DENIED', 'SERVICE_INTERROGATE', 'EXPORT_PRIVATE_KEYS', 'STATUS_NDIS_INVALID_PORT', 'STATUS_DS_SAM_INIT_FAILURE_CONSOLE', 'X509_UNICODE_ANY_STRING', 'STATUS_NDIS_INDICATION_REQUIRED', 'STATUS_UNRECOGNIZED_MEDIA', 'STATUS_LOGON_FAILURE', 'IMAGE_FILE_MACHINE_R3000', 'PRODUCT_DATACENTER_EVALUATION_SERVER', 'STATUS_DEVICE_PAPER_EMPTY', 'STATUS_FVE_KEYFILE_NO_VMK', 'STATUS_RM_DISCONNECTED', 'THREAD_TERMINATE', 'ERROR_TRANSACTION_ALREADY_ABORTED', 'STATUS_INTERNAL_DB_CORRUPTION', 'TOKEN_QUERY', 'STATUS_NO_EVENT_PAIR', 'CERT_FIND_ISSUER_NAME', 'CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT', 'STATUS_NOT_IMPLEMENTED', 'SM_TABLETPC', 'ERROR_ARENA_TRASHED', 'STATUS_INVALID_LABEL', 'RPC_NT_WRONG_ES_VERSION', 'OPEN_EXISTING', 'STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY', 'IMAGE_REL_BASED_HIGH', 'FILE_MAP_READ', 'STATUS_FWP_NOTIFICATION_DROPPED', 'IMAGE_FILE_MACHINE_WCEMIPSV2', 'EVENT_TRACE_USE_GLOBAL_SEQUENCE', 'ACCESS_MAX_MS_V3_ACE_TYPE', 'PROV_REPLACE_OWF', 'TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE', 'STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE', 'STATUS_DS_SRC_SID_EXISTS_IN_FOREST', 'STATUS_INVALID_ACE_CONDITION', 'STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER', 'STARTF_RUNFULLSCREEN', 'STATUS_SECTION_TOO_BIG', 'RPC_NT_TYPE_ALREADY_REGISTERED', 'MAX_PATH', 'CERT_QUERY_CONTENT_FLAG_CRL', 'THREAD_QUERY_INFORMATION', 'STATUS_ALREADY_WIN32', 'ERROR_DBG_CONTINUE', 'DNS_TYPE_CNAME', 'IMAGE_SCN_LNK_COMDAT', 'SC_MANAGER_QUERY_LOCK_STATUS', 'EPT_NT_NOT_REGISTERED', 'ALPC_CANCELFLGP_FLUSH', 'ERROR_META_EXPANSION_TOO_LONG', 'SPC_GLUE_RDN_OBJID', 'STATUS_VIRTDISK_NOT_VIRTUAL_DISK', 'szOID_INFOSEC_mosaicKeyManagement', 'szOID_INFOSEC_SuiteAKeyManagement', 'STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON', 'STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED', 'EVENT_MODIFY_STATE', 'OS_FASTUSERSWITCHING', 'DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE', 'EVENT_TRACE_CONTROL_QUERY', 'STATUS_ACPI_ACQUIRE_GLOBAL_LOCK', 'CAT_MEMBERINFO2_OBJID', 'FILE_OPEN_REMOTE_INSTANCE', 'ERROR_EVT_QUERY_RESULT_INVALID_POSITION', 'NTE_BAD_PROVIDER', 'STATUS_SMARTCARD_NO_KEYSET', 'STATUS_NDIS_ADAPTER_REMOVED', 'ERROR_DELETE_PENDING', 'STATUS_NO_KERB_KEY', 'SM_CXBORDER', 'STATUS_NETLOGON_NOT_STARTED', 'SERVICE_CONTROL_PARAMCHANGE', 'ERROR_DRIVER_DATABASE_ERROR', 'STATUS_WRONG_PASSWORD', 'STATUS_NDIS_INVALID_OID', 'STATUS_SXS_SECTION_NOT_FOUND', 'STATUS_NO_EFS', 'CERT_TRUST_REVOCATION_STATUS_UNKNOWN', 'SM_REMOTESESSION', 'STATUS_SXS_ASSEMBLY_NOT_FOUND', 'ERROR_TOO_MANY_THREADS', 'szOID_TIMESTAMP_TOKEN', 'CERT_STORE_OPEN_EXISTING_FLAG', 'RPC_NT_CALL_CANCELLED', 'STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER', 'STATUS_INVALID_DEVICE_STATE', 'STATUS_NO_PA_DATA', 'ERROR_CANTFETCHBACKWARDS', 'STATUS_INSUFF_SERVER_RESOURCES', 'STATUS_ACPI_INVALID_OPCODE', 'CERT_SMART_CARD_DATA_PROP_ID', 'CERT_COMPARE_SUBJECT_CERT', 'STATUS_SMARTCARD_NO_KEY_CONTAINER', 'STATUS_NOT_LOCKED', 'ERROR_SHARING_BUFFER_EXCEEDED', 'SERVICE_WIN32', 'STATUS_FWP_FILTER_NOT_FOUND', 'SM_MOUSEWHEELPRESENT', 'EXTENDED_STARTUPINFO_PRESENT', 'STATUS_PROCESS_IN_JOB', 'STATUS_REQUEST_NOT_ACCEPTED', 'FILE_OVERWRITE', 'SM_CXMAXTRACK', 'VALID_INHERIT_FLAGS', 'ERROR_NO_PROC_SLOTS', 'STGM_WRITE', 'ERROR_EVT_FILTER_INVTEST', 'STATUS_LOG_READ_MODE_INVALID', 'szOID_X957', 'ERROR_BAD_ARGUMENTS', 'STATUS_FLOAT_INEXACT_RESULT', 'STATUS_ADAPTER_HARDWARE_ERROR', 'STATUS_SXS_CORRUPT_ACTIVATION_STACK', 'PRODUCT_STORAGE_EXPRESS_SERVER_CORE', 'FILE_DIRECTORY_FILE', 'FILE_FLAG_DELETE_ON_CLOSE', 'PIPE_NOWAIT', 'ERROR_CHILD_MUST_BE_VOLATILE', 'PAGE_EXECUTE', 'STATUS_FWP_TYPE_MISMATCH', 'TOKEN_ADJUST_SESSIONID', 'CERT_TRUST_IS_SELF_SIGNED', 'CONTEXT_EXTENDED_REGISTERS', 'ERROR_EAS_DIDNT_FIT', 'PROTECTED_DACL_SECURITY_INFORMATION', 'STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE', 'STATUS_DS_OBJ_CLASS_VIOLATION', 'MS_ENH_RSA_AES_PROV_W', 'STATUS_HMAC_NOT_SUPPORTED', 'ERROR_INVALID_LDT_DESCRIPTOR', 'ERROR_MULTIPLE_FAULT_VIOLATION', 'PRODUCT_ENTERPRISE_EVALUATION', 'STATUS_SXS_IDENTITY_PARSE_ERROR', 'STATUS_CRYPTO_SYSTEM_INVALID', 'FILE_NOTIFY_CHANGE_SECURITY', 'MS_ENH_RSA_AES_PROV_A', 'STGM_DELETEONRELEASE', 'STATUS_INVALID_LDT_SIZE', 'SM_SERVERR2', 'STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST', 'STATUS_INSUFFICIENT_LOGON_INFO', 'STATUS_REPARSE', 'RPC_NT_UNSUPPORTED_AUTHN_LEVEL', 'ERROR_BAD_EXE_FORMAT', 'CERT_STORE_PROV_PHYSICAL_W', 'BG_NOTIFY_DISABLE', 'DEBUG_EVENT_SESSION_STATUS', 'STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED', 'STATUS_FVE_NO_FEATURE_LICENSE', 'FILE_ADD_SUBDIRECTORY', 'ERROR_LABEL_TOO_LONG', 'CERT_SYSTEM_STORE_LOCAL_MACHINE_ID', 'MS_DEF_RSA_SIG_PROV_W', 'CERT_AIA_URL_RETRIEVED_PROP_ID', 'ACCESS_ALLOWED_CALLBACK_ACE_TYPE', 'SM_CYMENUSIZE', 'RPC_NT_INVALID_TAG', 'RPC_NT_ADDRESS_ERROR', 'AF_12844', 'STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR', 'SERVICE_ENUMERATE_DEPENDENTS', 'GENERIC_WRITE', 'STATUS_CTX_WINSTATION_NAME_COLLISION', 'STATUS_PIPE_EMPTY', 'SE_GROUP_ENABLED', 'STATUS_CANCELLED', 'DNS_QUERY_NO_NETBT', 'ERROR_EVENT_DONE', 'FILE_DELETE_ON_CLOSE', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING', 'STATUS_DEVICE_DATA_ERROR', 'BG_NOTIFY_JOB_MODIFICATION', 'STATUS_NO_LOGON_SERVERS', 'STATUS_NONEXISTENT_SECTOR', 'STATUS_TM_VOLATILE', 'ERROR_RESUME_HIBERNATION', 'STATUS_CLUSTER_NODE_ALREADY_UP', 'STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP', 'STATUS_DISK_OPERATION_FAILED', 'ERROR_CLIENT_SERVER_PARAMETERS_INVALID', 'CERT_STORE_UPDATE_KEYID_FLAG', 'STATUS_TOO_MANY_NAMES', 'CMSG_VERIFY_SIGNER_PUBKEY', 'STATUS_SECURITY_STREAM_IS_INCONSISTENT', 'EXCEPTION_NONCONTINUABLE_EXCEPTION', 'STATUS_NDIS_OFFLOAD_PATH_REJECTED', 'STATUS_CRC_ERROR', 'ERROR_HANDLE_EOF', 'CERT_STORE_READONLY_FLAG', 'STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA', 'IMAGE_FILE_BYTES_REVERSED_LO', 'ERROR_CANT_TERMINATE_SELF', 'STATUS_DEVICE_NOT_CONNECTED', 'X509_BASIC_CONSTRAINTS2', 'STATUS_CLUSTER_NETWORK_EXISTS', 'STATUS_KDC_UNABLE_TO_REFER', 'STATUS_BAD_VALIDATION_CLASS', 'DBG_TERMINATE_PROCESS', 'REG_MULTI_SZ', 'STATUS_FWP_NET_EVENTS_DISABLED', 'STATUS_DS_NO_RIDS_ALLOCATED', 'STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME', 'FILE_NO_COMPRESSION', 'ERROR_OPERATION_ABORTED', 'STATUS_MORE_ENTRIES', 'AF_VOICEVIEW', 'STATUS_DOMAIN_TRUST_INCONSISTENT', 'STATUS_SERVER_SHUTDOWN_IN_PROGRESS', 'szOID_NIST_sha384', 'SM_CXPADDEDBORDER', 'STATUS_INVALID_PARAMETER_MIX', 'SERVICE_ERROR_IGNORE', 'ERROR_THREAD_1_INACTIVE', 'FILE_FLAG_WRITE_THROUGH', 'STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM', 'PRODUCT_STORAGE_STANDARD_EVALUATION_SERVER', 'FILE_RESERVE_OPFILTER', 'STATUS_PURGE_FAILED', 'ERROR_WAKE_SYSTEM', 'RPC_NT_BAD_STUB_DATA', 'STATUS_FVE_NO_LICENSE', 'CMSG_DETACHED_FLAG', 'STATUS_LOG_METADATA_INCONSISTENT', 'ERROR_NO_SIGNAL_SENT', 'STATUS_SPECIAL_USER', 'STATUS_INVALID_TRANSACTION', 'szOID_OIWSEC', 'ERROR_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING', 'CREATE_SHARED_WOW_VDM', 'STATUS_DESTINATION_ELEMENT_FULL', 'SM_CYSMSIZE', 'STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET', 'SERVICE_ACCEPT_TRIGGEREVENT', 'ERROR_FIRMWARE_UPDATED', 'CRYPT_ACQUIRE_USE_PROV_INFO_FLAG', 'API_SET_SCHEMA_FLAGS_HOST_EXTENSION', 'STATUS_INVALID_PARAMETER_9', 'RPC_NT_INVALID_STRING_UUID', 'STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE', 'FILE_MAP_COPY', 'STATUS_DS_NAME_NOT_UNIQUE', 'STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA', 'ERROR_ILLEGAL_CHARACTER', 'NTE_BAD_UID', 'FILE_READ_ONLY_VOLUME', 'BG_NOTIFY_JOB_ERROR', 'STATUS_INVALID_IMAGE_PROTECT', 'szOID_OIW', 'FILE_ATTRIBUTE_HIDDEN', 'STATUS_GRAPHICS_OPM_INTERNAL_ERROR', 'ERROR_EVT_FILTER_INVTYPE', 'IMAGE_DIRECTORY_ENTRY_EXCEPTION', 'DNS_TYPE_GPOS', 'STATUS_GRAPHICS_STALE_MODESET', 'STATUS_FVE_NOT_DATA_VOLUME', 'STATUS_CTX_CLIENT_LICENSE_NOT_SET', 'STATUS_PAGEFILE_CREATE_FAILED', 'ALPC_MESSAGE_SECURITY_ATTRIBUTE', 'SE_GROUP_OWNER', 'CREATE_FORCEDOS', 'szOID_OIWSEC_md4RSA2', 'STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK', 'SYSTEM_MANDATORY_LABEL_ACE_TYPE', 'ERROR_CAN_NOT_COMPLETE', 'PRODUCT_CORE_ARM', 'STATUS_SINGLE_STEP', 'STATUS_OBJECT_NAME_INVALID', 'STATUS_ACCOUNT_RESTRICTION', 'TH32CS_SNAPPROCESS', 'STATUS_CLUSTER_NETWORK_NOT_FOUND', 'CMSG_CONTENT_PARAM', 'STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE', 'SM_CXMINTRACK', 'STATUS_CTX_MODEM_RESPONSE_BUSY', 'PAGE_WRITECOPY', 'CERT_E_EXPIRED', 'ERROR_PRINT_CANCELLED', 'STATUS_DS_GC_REQUIRED', 'RPC_NT_NOT_ALL_OBJS_UNEXPORTED', 'ERROR_BAD_THREADID_ADDR', 'CERT_STORE_PROV_PHYSICAL', 'EVENT_TRACE_FLAG_THREAD', 'szOID_OIWSEC_rsaXchg', 'STATUS_SERVER_NOT_DISABLED', 'STATUS_LOG_CONTAINER_OPEN_FAILED', 'szOID_ECC_CURVE_P384', 'CMSG_INDEFINITE_LENGTH', 'DNS_TYPE_OPT', 'ERROR_CONVERT_TO_LARGE', 'ERROR_INVALID_EVENT_COUNT', 'STATUS_GRAPHICS_INVALID_POINTER', 'STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED', 'DBG_APP_NOT_IDLE', 'RPC_NT_SS_CHAR_TRANS_SHORT_FILE', 'IMAGE_DIRECTORY_ENTRY_RESOURCE', 'STATUS_VIRTDISK_PROVIDER_NOT_FOUND', 'STATUS_ADDRESS_ALREADY_ASSOCIATED', 'STATUS_NETWORK_OPEN_RESTRICTION', 'CMSG_CRYPT_RELEASE_CONTEXT_FLAG', 'STATUS_UNEXPECTED_MM_EXTEND_ERR', 'S_FALSE', 'AF_OSI', 'EVENT_HEADER_FLAG_STRING_ONLY', 'ERROR_SEM_OWNER_DIED', 'ERROR_BAD_MCFG_TABLE', 'RPC_NT_PROXY_ACCESS_DENIED', 'EPT_NT_INVALID_ENTRY', 'NTE_NO_MORE_ITEMS', 'SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE', 'ERROR_EVT_INVALID_CHANNEL_PATH', 'ERROR_KEY_DELETED', 'STATUS_ACPI_NOT_INITIALIZED', 'STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED', 'STATUS_MEMBER_IN_GROUP', 'FILE_MAP_EXECUTE', 'STATUS_MUTANT_NOT_OWNED', 'SM_CXDRAG', 'STATUS_INVALID_LDT_OFFSET', 'STATUS_VARIABLE_NOT_FOUND', 'WTD_CHOICE_SIGNER', 'OS_DATACENTER', 'ALPC_MESSAGE_DIRECT_ATTRIBUTE', 'STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST', 'TOKEN_MANDATORY_POLICY_NO_WRITE_UP', 'NTE_NO_KEY', 'SM_PENWINDOWS', 'STATUS_MUI_INVALID_LOCALE_NAME', 'CERT_QUERY_CONTENT_PKCS7_SIGNED', 'STATUS_NDIS_MULTICAST_FULL', 'STATUS_LONGJUMP', 'CERT_FIND_SUBJECT_ATTR', 'ACCESS_MAX_MS_V5_ACE_TYPE', 'STATUS_CONNECTION_IN_USE', 'STATUS_CTX_SHADOW_NOT_RUNNING', 'OS_WIN2000TERMINAL', 'STATUS_DS_CANT_ON_NON_LEAF', 'FILE_APPEND_DATA', 'STATUS_SXS_THREAD_QUERIES_DISABLED', 'SERVICE_TYPE_ALL', 'STATUS_NO_SUCH_PACKAGE', 'RPC_NT_PROTSEQ_NOT_SUPPORTED', 'ERROR_FAIL_I24', 'STATUS_LOGIN_TIME_RESTRICTION', 'PRODUCT_MULTIPOINT_STANDARD_SERVER', 'STATUS_TOO_MANY_LUIDS_REQUESTED', 'SERVICE_CONTROL_CONTINUE', 'CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT', 'STATUS_FWP_CANNOT_PEND', 'SM_CYMAXIMIZED', 'X509_KEY_USAGE', 'NTE_BAD_SIGNATURE', 'GENERIC_EXECUTE', 'STATUS_GRAPHICS_INVALID_VIDPN', 'STATUS_ILLEGAL_DLL_RELOCATION', 'CERT_TRUST_IS_NOT_TIME_NESTED', 'RPC_NT_SERVER_UNAVAILABLE', 'ERROR_RXACT_COMMITTED', 'ERROR_IS_SUBST_PATH', 'STATUS_LOG_RESIZE_INVALID_SIZE', 'STATUS_INVALID_IMAGE_LE_FORMAT', 'FILE_ACTION_RENAMED_OLD_NAME', 'CERT_QUERY_CONTENT_FLAG_PFX', 'STATUS_FLOAT_DENORMAL_OPERAND', 'PRODUCT_SOLUTION_EMBEDDEDSERVER', 'FILE_NOTIFY_CHANGE_DIR_NAME', 'DBG_UNABLE_TO_PROVIDE_HANDLE', 'SM_CYVTHUMB', 'STATUS_MEMBER_NOT_IN_GROUP', 'STATUS_DATATYPE_MISALIGNMENT', 'STATUS_SXS_EARLY_DEACTIVATION', 'STATUS_INSUFFICIENT_NVRAM_RESOURCES', 'STATUS_FAIL_CHECK', 'CERT_TRUST_INVALID_NAME_CONSTRAINTS', 'TOKEN_ADJUST_PRIVILEGES', 'ERROR_THREAD_MODE_NOT_BACKGROUND', 'MEM_FREE', 'STATUS_CANNOT_ABORT_TRANSACTIONS', 'EVENT_TRACE_CONTROL_UPDATE', 'CERT_STORE_ENUM_ARCHIVED_FLAG', 'FILE_MAP_ALL_ACCESS', 'LPC_LOST_REPLY', 'CERT_STORE_MAXIMUM_ALLOWED_FLAG', 'STATUS_LOG_PINNED_ARCHIVE_TAIL', 'PRODUCT_SMALLBUSINESS_SERVER', 'CREATE_NEW', 'CERT_STORE_PROV_FILE', 'szOID_RSA_SHA512RSA', 'PRODUCT_HYPERV', 'SW_SHOWDEFAULT', 'szOID_OIWDIR', 'STGM_SIMPLE', 'NTE_DOUBLE_ENCRYPT', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_STRING', 'ERROR_WMI_SET_FAILURE', 'FILE_LIST_DIRECTORY', 'STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE', 'DNS_TYPE_WKS', 'DNS_QUERY_WIRE_ONLY', 'FILE_OPEN_REPARSE_POINT', 'DIRECTORY_CREATE_SUBDIRECTORY', 'SE_DACL_AUTO_INHERITED', 'IMAGE_FILE_MACHINE_ALPHA64', 'IO_COMPLETION_QUERY_STATE', 'STATUS_NDIS_MEDIA_DISCONNECTED', 'STATUS_RECEIVE_EXPEDITED', 'STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT', 'FILE_ATTRIBUTE_NOT_CONTENT_INDEXED', 'STATUS_GRAPHICS_INVALID_COLORBASIS', 'SE_MANAGE_VOLUME_NAME', 'ERROR_MISSING_SYSTEMFILE', 'STATUS_BAD_LOGON_SESSION_STATE', 'X509_NAME', 'STATUS_PORT_CONNECTION_REFUSED', 'STATUS_INVALID_WORKSTATION', 'IMAGE_SCN_TYPE_DSECT', 'AF_CHAOS', 'RPC_NT_DUPLICATE_ENDPOINT', 'STATUS_NOT_SAFE_MODE_DRIVER', 'PRODUCT_BUSINESS', 'DNS_TYPE_TSIG', 'ERROR_RECEIVE_EXPEDITED', 'PAGE_NOCACHE', 'STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING', 'CRYPT_VOLATILE', 'CERT_STORE_PROV_LDAP', 'BELOW_NORMAL_PRIORITY_CLASS', 'PROV_EC_ECDSA_FULL', 'ERROR_IS_JOIN_TARGET', 'STATUS_RESTART_BOOT_APPLICATION', 'STATUS_EAS_NOT_SUPPORTED', 'STATUS_ACPI_INVALID_SUPERNAME', 'STATUS_EOM_OVERFLOW', 'ERROR_MEMORY_HARDWARE', 'CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL', 'STATUS_FWP_INCOMPATIBLE_AUTH_METHOD', 'STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE', 'ERROR_WX86_ERROR', 'STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND', 'STATUS_RXACT_COMMITTED', 'STATUS_RXACT_COMMIT_NECESSARY', 'ERROR_INVALID_VERIFY_SWITCH', 'ERROR_BADDB', 'FILE_ATTRIBUTE_DIRECTORY', 'STATUS_INSTANCE_NOT_AVAILABLE', 'STATUS_RECEIVE_PARTIAL_EXPEDITED', 'CREATE_NEW_PROCESS_GROUP', 'szOID_SEALING_TIMESTAMP', 'CMSG_ENVELOPE_ALGORITHM_PARAM', 'STGFMT_DOCUMENT', 'IMAGE_SCN_ALIGN_32BYTES', 'TXFS_MINIVERSION_DIRTY_VIEW', 'IMAGE_FILE_DEBUG_STRIPPED', 'PRODUCT_STORAGE_WORKGROUP_SERVER', 'CMSG_RECIPIENT_INFO_PARAM', 'STATUS_BAD_DEVICE_TYPE', 'STATUS_THREAD_IS_TERMINATING', 'STATUS_NO_IMPERSONATION_TOKEN', 'RPC_NT_INVALID_NAME_SYNTAX', 'szOID_OIWSEC_mdc2', 'SERVICE_PAUSE_PENDING', 'CERT_NAME_RDN_TYPE', 'SM_CYDLGFRAME', 'FILE_OPEN_FOR_FREE_SPACE_QUERY', 'STATUS_FWP_TCPIP_NOT_READY', 'STATUS_CLUSTER_POISONED', 'NTE_KEYSET_NOT_DEF', 'ERROR_VOLUME_MOUNTED', 'STATUS_LOG_STATE_INVALID', 'CMSG_ENCRYPT_PARAM', 'ERROR_WRITE_FAULT', 'STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED', 'STATUS_PIPE_CLOSING', 'FILE_FILE_COMPRESSION', 'STATUS_DISK_REPAIR_DISABLED', 'RPC_NT_WRONG_PIPE_VERSION', 'STATUS_LOGON_NOT_GRANTED', 'STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE', 'STATUS_INVALID_COMPUTER_NAME', 'CERT_RENEWAL_PROP_ID', 'STATUS_ILLEGAL_INSTRUCTION', 'STATUS_NOT_FOUND', 'STATUS_CHECKING_FILE_SYSTEM', 'CERT_QUERY_CONTENT_SERIALIZED_CTL', 'SW_HIDE', 'STATUS_FVE_DRY_RUN_FAILED', 'szOID_OIWSEC_desECB', 'MS_STRONG_PROV_W', 'ERROR_UNEXPECTED_MM_EXTEND_ERR', 'STATUS_INVALID_PARAMETER_4', 'CERT_COMPARE_CERT_ID', 'CLUSAPI_ALL_ACCESS', 'STATUS_FVE_DEBUGGER_ENABLED', 'STATUS_DS_SHUTTING_DOWN', 'STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY', 'szOID_RSA_signingTime', 'EVENT_TRACE_FLAG_DISK_FILE_IO', 'ERROR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR', 'STATUS_NO_SUCH_FILE', 'STATUS_IPSEC_REPLAY_CHECK_FAILED', 'CERT_E_PURPOSE', 'RPC_C_QOS_IDENTITY_DYNAMIC', 'ERROR_NOINTERFACE', 'STATUS_NO_TGT_REPLY', 'SM_CXVSCROLL', 'szOID_OIWSEC_dsaCommSHA1', 'STATUS_FWP_LIFETIME_MISMATCH', 'FILE_SUPPORTS_REPARSE_POINTS', 'STATUS_DRIVER_ENTRYPOINT_NOT_FOUND', 'IMAGE_SCN_TYPE_COPY', 'ERROR_VALIDATE_CONTINUE', 'DNS_TYPE_WINS', 'ERROR_SUBST_TO_JOIN', 'LPC_CONNECTION_REQUEST', 'STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE', 'RPC_RESPONSE_TYPE_FAIL', 'EXCEPTION_DEBUG_EVENT', 'REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY', 'SM_CXSMSIZE', 'STATUS_VOLSNAP_HIBERNATE_READY', 'IMAGE_DIRECTORY_ENTRY_IAT', 'EVENT_TRACE_TYPE_CONFIG_PHYSICALDISK', 'TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT', 'ERROR_HIBERNATED', 'CMSG_CRL_COUNT_PARAM', 'SERVICE_CONTROL_PAUSE', 'FILE_SUPERSEDED', 'STATUS_HOST_UNREACHABLE', 'DNS_TYPE_NULL', 'CONTEXT_ALL', 'ERROR_CHILD_NOT_COMPLETE', 'DNS_QUERY_TREAT_AS_FQDN', 'STATUS_RANGE_NOT_FOUND', 'SYSTEM_MANDATORY_LABEL_NO_READ_UP', 'STATUS_TRUSTED_RELATIONSHIP_FAILURE', 'CERT_TRUST_NO_ERROR', 'STATUS_TOO_MANY_PAGING_FILES', 'STATUS_DS_INVALID_GROUP_TYPE', 'STATUS_CTX_LICENSE_EXPIRED', 'STATUS_IPSEC_AUTH_FIREWALL_DROP', 'FILE_VALID_MAILSLOT_OPTION_FLAGS', 'CERT_FIND_CROSS_CERT_DIST_POINTS', 'STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN', 'STATUS_USER_MAPPED_FILE', 'ERROR_NOT_ALL_ASSIGNED', 'EVENT_TRACE_BUFFERING_MODE', 'ERROR_CANTREAD', 'ERROR_VIRUS_DELETED', 'FAILED_ACCESS_ACE_FLAG', 'RPC_NT_SEC_PKG_ERROR', 'IMAGE_SCN_ALIGN_MASK', 'NTE_BAD_TYPE', 'X509_KEYGEN_REQUEST_TO_BE_SIGNED', 'ERROR_FULLSCREEN_MODE', 'STATUS_COMMITMENT_LIMIT', 'NTE_BAD_FLAGS', 'CERT_STORE_SHARE_CONTEXT_FLAG', 'STATUS_FWP_INCOMPATIBLE_SA_STATE', 'ERROR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR', 'SM_CYMINTRACK', 'SERVICE_ACCEPT_PARAMCHANGE', 'OS_TERMINALCLIENT', 'FILE_SEQUENTIAL_ONLY', 'STATUS_IMAGE_CHECKSUM_MISMATCH', 'SM_IMMENABLED', 'STATUS_IMAGE_MACHINE_TYPE_MISMATCH', 'STILL_ACTIVE', 'STATUS_REQUEST_CANCELED', 'PRODUCT_CORE_LANGUAGESPECIFIC', 'CERT_STORE_CTL_CONTEXT', 'STATUS_EVENTLOG_CANT_START', 'NTE_BAD_HASH', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_BOOLEAN', 'STATUS_WAS_UNLOCKED', 'SE_MACHINE_ACCOUNT_NAME', 'CREATE_PROCESS_DEBUG_EVENT', 'ERROR_CANTWRITE', 'STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT', 'CERT_NAME_UPN_TYPE', 'SERVICE_ERROR_SEVERE', 'STATUS_RESOURCEMANAGER_NOT_FOUND', 'STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED', 'STATUS_INVALID_IMAGE_WIN_64', 'STATUS_IMAGE_ALREADY_LOADED_AS_DLL', 'DNS_ATMA_FORMAT_AESA', 'STATUS_GRAPHICS_INVALID_DRIVER_MODEL', 'STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE', 'szOID_ECDSA_SHA256', 'ERROR_INVALID_PARAMETER', 'STATUS_REGISTRY_HIVE_RECOVERED', 'OBJECT_INHERIT_ACE', 'DBG_NO_STATE_CHANGE', 'STATUS_FILE_RENAMED', 'szOID_RSA_MD4RSA', 'CMSG_CTRL_ADD_ATTR_CERT', 'STATUS_NOT_CAPABLE', 'STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED', 'STATUS_NO_SAVEPOINT_WITH_OPEN_FILES', 'SW_SHOWNOACTIVATE', 'PKCS12_INCLUDE_EXTENDED_PROPERTIES', 'RPC_REQUEST_TYPE_BIND', 'NTE_INVALID_HANDLE', 'STATUS_BUS_RESET', 'STATUS_FLT_INVALID_NAME_REQUEST', 'STATUS_CLUSTER_NODE_PAUSED', 'PROCESS_DUP_HANDLE', 'STATUS_PROTOCOL_UNREACHABLE', 'ERROR_COMPRESSION_DISABLED', 'FILE_FLAG_BACKUP_SEMANTICS', 'STATUS_OBJECTID_NOT_FOUND', 'ERROR_OPEN_FAILED', 'CRYPT_CREATE_IV', 'PRODUCT_SMALLBUSINESS_SERVER_PREMIUM', 'STATUS_FVE_NOT_OS_VOLUME', 'FILE_VOLUME_QUOTAS', 'NTE_PROV_TYPE_NOT_DEF', 'RPC_C_AUTHN_LEVEL_DEFAULT', 'STATUS_FWP_MATCH_TYPE_MISMATCH', 'REG_EXPAND_SZ', 'CRYPT_E_ATTRIBUTES_MISSING', 'FILE_VALID_PIPE_OPTION_FLAGS', 'STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER', 'CERT_FIND_SUBJECT_NAME', 'RPC_NT_NOT_CANCELLED', 'STATUS_FWP_OUT_OF_BOUNDS', 'FILE_READ_DATA', 'EXCEPTION_FLT_DENORMAL_OPERAND', 'SE_SHUTDOWN_NAME', 'szOID_OIWSEC_sha1', 'ERROR_FSFILTER_OP_COMPLETED_SUCCESSFULLY', 'STATUS_CTX_NO_OUTBUF', 'RPC_NT_BINDING_INCOMPLETE', 'SM_CYFRAME', 'STATUS_CTX_LICENSE_CLIENT_INVALID', 'STATUS_NO_MEDIA', 'STATUS_SOME_NOT_MAPPED', 'SPC_INDIVIDUAL_SP_KEY_PURPOSE_OBJID', 'STATUS_BAD_NETWORK_PATH', 'ERROR_WAS_LOCKED', 'FILE_GENERIC_EXECUTE', 'szOID_INFOSEC_mosaicUpdatedSig', 'EXCEPTION_STACK_OVERFLOW', 'CERT_TRUST_HAS_ISSUANCE_CHAIN_POLICY', 'IMAGE_FILE_MACHINE_SH5', 'PRODUCT_ENTERPRISE_SERVER_CORE', 'STATUS_AMBIGUOUS_SYSTEM_DEVICE', 'szOID_OIWSEC_dsa', 'SERVICE_DISABLED', 'STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET', 'FILE_NOTIFY_CHANGE_LAST_WRITE', 'STATUS_CTX_WINSTATION_ACCESS_DENIED', 'DNS_QUERY_NO_WIRE_QUERY', 'CERT_COMPARE_ATTR', 'STATUS_OBJECT_TYPE_MISMATCH', 'SPC_SIGINFO_OBJID', 'STATUS_GRAPHICS_RESOURCES_NOT_RELATED', 'PRODUCT_ESSENTIALBUSINESS_SERVER_ADDLSVC', 'CWCSTORAGENAME', 'IMAGE_FILE_LOCAL_SYMS_STRIPPED', 'CERT_STORE_CERTIFICATE_CONTEXT', 'API_SET_SCHEMA_FLAGS_SEALED', 'CERT_ENHKEY_USAGE_PROP_ID', 'SE_PRIVILEGE_ENABLED', 'SYMSEARCH_GLOBALSONLY', 'IDLE_PRIORITY_CLASS', 'STATUS_NO_TRACKING_SERVICE', 'STATUS_SECTION_NOT_IMAGE', 'STATUS_IPSEC_DOSP_BLOCK', 'STATUS_FIRMWARE_UPDATED', 'STATUS_PROFILING_AT_LIMIT', 'STATUS_PAGE_FAULT_GUARD_PAGE', 'STATUS_FVE_FAILED_BAD_FS', 'EVENT_TRACE_FLAG_VOLMGR', 'MAX_INTERFACE_NAME_LEN', 'STATUS_HEAP_CORRUPTION', 'MS_ENH_RSA_AES_PROV_XP_A', 'STATUS_CONTROL_C_EXIT', 'INHERITED_ACE', 'STATUS_SETMARK_DETECTED', 'PRODUCT_STORAGE_ENTERPRISE_SERVER', 'STATUS_MOUNT_POINT_NOT_RESOLVED', 'STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET', 'STATUS_RESOURCE_ENUM_USER_STOP', 'ERROR_PATH_BUSY', 'ERROR_THREAD_MODE_ALREADY_BACKGROUND', 'szOID_OIWSEC_md2RSASign', 'MAX_ADAPTER_NAME', 'OS_TABLETPC', 'STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE', 'ERROR_TOO_MANY_POSTS', 'STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL', 'CONTEXT_SEGMENTS', 'STATUS_LOG_START_OF_LOG', 'ERROR_NO_MORE_FILES', 'STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED', 'STGM_SHARE_DENY_READ', 'EVENT_HEADER_FLAG_32_BIT_HEADER', 'CERT_QUERY_CONTENT_PKCS7_UNSIGNED', 'STATUS_FILE_LOCKED_WITH_ONLY_READERS', 'DBG_EXCEPTION_HANDLED', 'STATUS_ADVANCED_INSTALLER_FAILED', 'IMAGE_FILE_MACHINE_AMD64', 'ERROR_NET_OPEN_FAILED', 'CRYPT_CREATE_SALT', 'FILE_OPEN_NO_RECALL', 'RPC_NT_NO_ENTRY_NAME', 'szOID_ANSI_X942', 'JOB_OBJECT_SET_ATTRIBUTES', 'SM_CXFOCUSBORDER', 'STATUS_WAIT_3', 'STATUS_VIRUS_INFECTED', 'STATUS_WAIT_1', 'SECURITY_MANDATORY_UNTRUSTED_RID', 'STATUS_INVALID_IMAGE_HASH', 'CRYPT_E_OID_FORMAT', 'CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT', 'STATUS_GRAPHICS_UAB_NOT_SUPPORTED', 'STATUS_TRUST_FAILURE', 'STATUS_CTX_WINSTATION_NAME_INVALID', 'SW_MAXIMIZE', 'EXCEPTION_INT_DIVIDE_BY_ZERO', 'STG_LAYOUT_INTERLEAVED', 'IMAGE_FILE_SYSTEM', 'EVT_VARIANT_TYPE_MASK', 'AF_DLI', 'RPC_NT_UUID_NO_ADDRESS', 'ERROR_TRANSACTION_NOT_ACTIVE', 'STATUS_EA_TOO_LARGE', 'STATUS_USER2USER_REQUIRED', 'STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME', 'CERT_QUERY_CONTENT_SERIALIZED_STORE', 'CERT_FIND_KEY_IDENTIFIER', 'RPC_NT_NO_MORE_ENTRIES', 'PROCESS_TRACE_MODE_REAL_TIME', 'STG_TOEND', 'STATUS_TIME_DIFFERENCE_AT_DC', 'CMSG_CTRL_KEY_AGREE_DECRYPT', 'SM_CYSMICON', 'STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE', 'ERROR_THREAD_NOT_IN_PROCESS', 'ERROR_WMI_INSTANCE_NOT_FOUND', 'PKCS12_ALWAYS_CNG_KSP', 'CERT_SYSTEM_STORE_USERS', 'OBJ_FORCE_ACCESS_CHECK', 'STATUS_ACCESS_DISABLED_BY_POLICY_PATH', 'STATUS_VOLMGR_MIRROR_NOT_SUPPORTED', 'ERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY', 'RPC_NT_INVALID_ES_ACTION', 'STATUS_PIPE_BROKEN', 'ERROR_EVT_EVENT_DEFINITION_NOT_FOUND', 'CERT_COMPARE_SIGNATURE_HASH', 'szOID_INFOSEC_sdnsConfidentiality', 'STATUS_WMI_ITEMID_NOT_FOUND', 'STATUS_FVE_TOO_SMALL', 'RPC_NT_COMM_FAILURE', 'ERROR_DIR_NOT_EMPTY', 'ERROR_PNP_RESTART_ENUMERATION', 'NTE_DECRYPTION_FAILURE', 'SM_DBCSENABLED', 'STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS', 'DNS_TYPE_AAAA', 'STATUS_QUOTA_EXCEEDED', 'DBG_CONTROL_C', 'ERROR_RXACT_STATE_CREATED', 'FC_ALLOCATE_ALL_NODES', 'STATUS_FLT_NO_DEVICE_OBJECT', 'RSA_CSP_PUBLICKEYBLOB', 'STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE', 'RPC_X_BAD_STUB_DATA', 'KEY_WOW64_RES', 'ERROR_TOO_MANY_MUXWAITERS', 'STATUS_PAGEFILE_QUOTA_EXCEEDED', 'RPC_C_QOS_IDENTITY_STATIC', 'SE_TCB_NAME', 'ALPC_PORFLG_WAITABLE_PORT', 'SECURITY_MANDATORY_HIGH_RID', 'ERROR_DBG_REPLY_LATER', 'ERROR_PNP_REBOOT_REQUIRED', 'STATUS_COPY_PROTECTION_FAILURE', 'X509_NDR_ENCODING', 'STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL', 'THREAD_SET_THREAD_TOKEN', 'ERROR_DRIVE_LOCKED', 'STATUS_FLT_INSTANCE_NOT_FOUND', 'CERT_FIND_HASH', 'ERROR_ACCESS_AUDIT_BY_POLICY', 'STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED', 'szOID_RSAES_OAEP', 'ERROR_BAD_COMMAND', 'AF_SNA', 'STATUS_NDIS_CLOSING', 'CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD', 'STATUS_MONITOR_INVALID_MANUFACTURE_DATE', 'STATUS_FWP_TXN_ABORTED', 'szOID_RSA_SSA_PSS', 'SE_REMOTE_SHUTDOWN_NAME', 'SM_RESERVED4', 'DNS_TYPE_ATMA', 'SM_RESERVED1', 'SM_RESERVED3', 'SM_RESERVED2', 'STATUS_TRANSACTION_NOT_REQUESTED', 'ALPC_MSGFLG_WAIT_USER_MODE', 'SE_SACL_DEFAULTED', 'STATUS_CANNOT_DELETE', 'STATUS_TRANSACTION_ABORTED', 'RPC_C_QOS_CAPABILITIES_MAKE_FULLSIC', 'STATUS_MAPPED_FILE_SIZE_ZERO', 'STATUS_PLUGPLAY_QUERY_VETOED', 'PRODUCT_STORAGE_WORKGROUP_EVALUATION_SERVER', 'szOID_RSA_MD5RSA', 'MS_ENHANCED_PROV_A', 'SE_UNDOCK_NAME', 'szOID_INFOSEC_mosaicUpdatedInteg', 'CERT_TRUST_INVALID_EXTENSION', 'STATUS_CTX_CLOSE_PENDING', 'CERT_STORE_NO_CRYPT_RELEASE_FLAG', 'STATUS_FVE_VOLUME_NOT_BOUND', 'EVENT_TRACE_DELAY_OPEN_FILE_MODE', 'ERROR_DISK_FULL', 'SE_CREATE_GLOBAL_NAME', 'STATUS_SMARTCARD_CARD_BLOCKED', 'STATUS_INVALID_IMAGE_FORMAT', 'STATUS_FILE_IS_OFFLINE', 'ERROR_LONGJUMP', 'CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY', 'CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY', 'STATUS_UNEXPECTED_NETWORK_ERROR', 'NTE_HMAC_NOT_SUPPORTED', 'MAILSLOT_NO_MESSAGE', 'SPC_STATEMENT_TYPE_OBJID', 'STATUS_OBJECT_NAME_COLLISION', 'STATUS_PRINT_QUEUE_FULL', 'STATUS_NDIS_INVALID_DATA', 'szOID_RSA_data', 'ERROR_ALREADY_ASSIGNED', 'ERROR_WAKE_SYSTEM_DEBUGGER', 'EVENT_TRACE_FLAG_VAMAP', 'STATUS_TRANSACTION_OBJECT_EXPIRED', 'CERT_E_UNTRUSTEDROOT', 'STATUS_WX86_CONTINUE', 'CERT_E_UNTRUSTEDCA', 'STATUS_DOMAIN_EXISTS', 'FILE_ATTRIBUTE_DEVICE', 'STATUS_DIRECTORY_NOT_EMPTY', 'NMPWAIT_NOWAIT', 'STATUS_FLT_CBDQ_DISABLED', 'OS_PERSONALTERMINALSERVER', 'CERT_ARCHIVED_KEY_HASH_PROP_ID', 'RPC_NT_INVALID_RPC_PROTSEQ', 'STATUS_NETWORK_ACCESS_DENIED', 'ERROR_APP_INIT_FAILURE', 'STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT', 'EVENT_TRACE_FLAG_MEMORY_PAGE_FAULTS', 'szOID_OIWSEC_md5RSA', 'REG_LINK', 'STATUS_BUFFER_OVERFLOW', 'STATUS_LOG_SECTOR_INVALID', 'STATUS_CALLBACK_POP_STACK', 'SERVICE_TRIGGER_TYPE_NETWORK_ENDPOINT', 'FILE_ATTRIBUTE_ENCRYPTED', 'STATUS_FVE_FAILED_AUTHENTICATION', 'EVENT_TRACE_USE_LOCAL_SEQUENCE', 'ERROR_LOCKED', 'CERT_FRIENDLY_NAME_PROP_ID', 'STATUS_PIPE_NOT_AVAILABLE', 'IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT', 'STATUS_NO_LDT', 'CLUSAPI_NO_ACCESS', 'STATUS_TRANSACTION_RESPONDED', 'CMSG_HASH_ALGORITHM_PARAM', 'STATUS_GRAPHICS_DDCCI_INVALID_DATA', 'RPC_NT_ALREADY_REGISTERED', 'STATUS_NDIS_DOT11_POWER_STATE_INVALID', 'STARTF_USESIZE', 'STATUS_REPARSE_POINT_NOT_RESOLVED', 'FILE_FLAG_OPEN_REPARSE_POINT', 'STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED', 'STATUS_REMOTE_RESOURCES', 'IMAGE_REL_BASED_RESERVED', 'OBJ_OPENIF', 'STATUS_CHILD_MUST_BE_VOLATILE', 'STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS', 'ERROR_IO_INCOMPLETE', 'CERT_E_CN_NO_MATCH', 'STATUS_END_OF_MEDIA', 'OS_PROFESSIONAL', 'UNPROTECTED_SACL_SECURITY_INFORMATION', 'STATUS_VDM_HARD_ERROR', 'SERVICE_WIN32_OWN_PROCESS', 'ERROR_UNWIND_CONSOLIDATE', 'RPC_C_AUTHN_LEVEL_PKT_INTEGRITY', 'STATUS_MEMORY_NOT_ALLOCATED', 'ERROR_ILLEGAL_FLOAT_CONTEXT', 'BIND_IF_SYNTAX_NDR32', 'ERROR_CRC', 'SM_MOUSEPRESENT', 'STATUS_PROCESS_CLONED', 'ACCESS_ALLOWED_OBJECT_ACE_TYPE', 'PRODUCT_SMALLBUSINESS_SERVER_PREMIUM_CORE', 'CERT_STORE_PROV_REG', 'ERROR_SERVER_SID_MISMATCH', 'STATUS_NO_IP_ADDRESSES', 'ERROR_DIRECTORY', 'EXCEPTION_SINGLE_STEP', 'CERT_AUTO_ENROLL_PROP_ID', 'STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET', 'ERROR_ABANDONED_WAIT_63', 'STATUS_FILE_NOT_ENCRYPTED', 'ERROR_VOLSNAP_PREPARE_HIBERNATE', 'STATUS_PORT_ALREADY_HAS_COMPLETION_LIST', 'SERVICE_CONTROL_STOP', 'STATUS_RESOURCE_NAME_NOT_FOUND', 'STATUS_DS_NO_MORE_RIDS', 'DELETE', 'MS_STRONG_PROV_A', 'STATUS_TRANSACTION_PROPAGATION_FAILED', 'SE_DEBUG_NAME', 'ERROR_FILE_TOO_LARGE', 'STATUS_SYNCHRONIZATION_REQUIRED', 'IMAGE_FILE_32BIT_MACHINE', 'STATUS_INVALID_HANDLE', 'STATUS_ALREADY_REGISTERED', 'STATUS_NETWORK_UNREACHABLE', 'STATUS_DS_INIT_FAILURE', 'CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG', 'STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE', 'STATUS_ROLLBACK_TIMER_EXPIRED', 'CERT_E_REVOKED', 'SE_SACL_AUTO_INHERIT_REQ', 'ERROR_NOT_OWNER', 'STATUS_REMOTE_NOT_LISTENING', 'PROFILE_KERNEL', 'STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS', 'STATUS_BEGINNING_OF_MEDIA', 'STATUS_BEYOND_VDL', 'IMAGE_FILE_UP_SYSTEM_ONLY', 'EPT_NT_CANT_PERFORM_OP', 'SM_SLOWMACHINE', 'ERROR_DRIVERS_LEAKING_LOCKED_PAGES', 'FILE_VOLUME_IS_COMPRESSED', 'STATUS_CLUSTER_NETINTERFACE_NOT_FOUND', 'STATUS_NO_RECOVERY_POLICY', 'SECTION_MAP_WRITE', 'STATUS_LOGON_SERVER_CONFLICT', 'STATUS_WAIT_2', 'STATUS_ENLISTMENT_NOT_FOUND', 'STATUS_DRIVER_PROCESS_TERMINATED', 'STATUS_INTEGER_DIVIDE_BY_ZERO', 'EVENT_TRACE_TYPE_CONFIG_NETINFO', 'PRODUCT_PROFESSIONAL_E', 'SE_DACL_PRESENT', 'STATUS_DEVICE_DOOR_OPEN', 'AF_UNIX', 'PRODUCT_PROFESSIONAL_N', 'STATUS_USER_APC', 'OS_MEORGREATER', 'STATUS_NET_WRITE_FAULT', 'STATUS_REINITIALIZATION_NEEDED', 'DNS_TYPE_MINFO', 'ERROR_INVALID_ACE_CONDITION', 'ERROR_PWD_TOO_RECENT', 'ERROR_PORT_MESSAGE_TOO_LONG', 'STATUS_GRAPHICS_NO_VIDEO_MEMORY', 'ERROR_UNWIND', 'ERROR_EXCL_SEM_ALREADY_OWNED', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_INVALID', 'CERT_E_WRONG_USAGE', 'STATUS_CALLBACK_RETURNED_PRI_BACK', 'DUPLICATE_SAME_ACCESS', 'TRUST_E_BAD_DIGEST', 'STATUS_NOT_LOGON_PROCESS', 'STATUS_INVALID_SYSTEM_SERVICE', 'STATUS_UNSUPPORTED_PREAUTH', 'EVENT_HEADER_FLAG_64_BIT_HEADER', 'CERT_FIND_ANY', 'szOID_RSA', 'STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER', 'CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID', 'IMAGE_DIRECTORY_ENTRY_EXPORT', 'STATUS_GRAPHICS_TRY_AGAIN_LATER', 'STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET', 'STATUS_IO_DEVICE_ERROR', 'CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED', 'STATUS_ACPI_INVALID_OBJTYPE', 'STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH', 'ERROR_INVALID_UNWIND_TARGET', 'STATUS_DEBUGGER_INACTIVE', 'ERROR_JOIN_TO_SUBST', 'STATUS_MORE_PROCESSING_REQUIRED', 'STATUS_CTL_FILE_NOT_SUPPORTED', 'PIPE_TYPE_BYTE', 'PKCS_7_ASN_ENCODING', 'STATUS_NO_INHERITANCE', 'STATUS_OBJECT_NAME_NOT_FOUND', 'PROV_RSA_SIG', 'SE_SYSTEM_PROFILE_NAME', 'STATUS_FWP_TXN_IN_PROGRESS', 'SPC_PE_IMAGE_PAGE_HASHES_V2_OBJID', 'IMAGE_SCN_TYPE_OVER', 'STATUS_ACCESS_DISABLED_BY_POLICY_OTHER', 'ERROR_VERSION_PARSE_ERROR', 'STATUS_SERVER_HAS_OPEN_HANDLES', 'ERROR_DEBUG_ATTACH_FAILED', 'STATUS_ABANDONED_WAIT_0', 'STATUS_CTX_WINSTATION_BUSY', 'SPC_TIME_STAMP_REQUEST_OBJID', 'IMAGE_SCN_MEM_16BIT', 'ERROR_BIOS_FAILED_TO_CONNECT_INTERRUPT', 'STATUS_TOO_MANY_SIDS', 'ERROR_FT_WRITE_RECOVERY', 'CERT_FIND_ISSUER_ATTR', 'ERROR_WMI_GUID_NOT_FOUND', 'STATUS_SHUTDOWN_IN_PROGRESS', 'RPC_NT_GROUP_MEMBER_NOT_FOUND', 'ERROR_DEVICE_ENUMERATION_ERROR', 'CERT_INFO_SIGNATURE_ALGORITHM_FLAG', 'STATUS_FVE_FS_MOUNTED', 'SERVICE_FILE_SYSTEM_DRIVER', 'TOKEN_DUPLICATE', 'CERT_COMPARE_CTL_USAGE', 'LPC_PORT_CLOSED', 'STATUS_EVENT_DONE', 'STATUS_NDIS_INVALID_LENGTH', 'STATUS_REMOTE_DISCONNECT', 'CERT_SYSTEM_STORE_CURRENT_SERVICE_ID', 'STATUS_BAD_INITIAL_STACK', 'ERROR_INVALID_MINALLOCSIZE', 'STATUS_CTX_WD_NOT_FOUND', 'STATUS_ALERTED', 'CERT_INFO_SUBJECT_UNIQUE_ID_FLAG', 'STATUS_CSS_KEY_NOT_ESTABLISHED', 'ERROR_EVT_VERSION_TOO_NEW', 'STATUS_FWP_EM_NOT_SUPPORTED', 'STANDARD_RIGHTS_EXECUTE', 'MEM_ROTATE', 'ERROR_FILE_CHECKED_OUT', 'STATUS_LOG_INVALID_RANGE', 'SM_CYSIZEFRAME', 'EVENT_TRACE_FLAG_NO_SYSCONFIG', 'FILE_WRITE_THROUGH', 'ERROR_SIGNAL_REFUSED', 'STATUS_LOG_MULTIPLEXED', 'CERT_NAME_ATTR_TYPE', 'EVENT_TRACE_TYPE_CONFIG_VIDEO', 'ERROR_PNP_IRQ_TRANSLATION_FAILED', 'ERROR_ALREADY_WIN32', 'EVENT_TRACE_FLAG_DISK_IO', 'ERROR_NO_MORE_SEARCH_HANDLES', 'STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR', 'ALPC_MESSAGE_HANDLE_ATTRIBUTE', 'VER_NT_WORKSTATION', 'ERROR_SYSTEM_IMAGE_BAD_SIGNATURE', 'STATUS_MUTANT_LIMIT_EXCEEDED', 'szOID_ECDSA_SPECIFIED', 'STATUS_INVALID_IMPORT_OF_NON_DLL', 'PKCS12_ALLOW_OVERWRITE_KEY', 'STATUS_ACCOUNT_LOCKED_OUT', 'STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE', 'ACE_INHERITED_OBJECT_TYPE_PRESENT', 'STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE', 'DNS_TYPE_KX', 'PIPE_TYPE_MESSAGE', 'STATUS_FLOAT_MULTIPLE_TRAPS', 'CRYPT_E_INVALID_INDEX', 'PROCESS_MODE_BACKGROUND_END', 'STATUS_NDIS_GROUP_ADDRESS_IN_USE', 'PRODUCT_CLUSTER_SERVER_V', 'AF_BAN', 'STATUS_NO_SUCH_LOGON_SESSION', 'STATUS_VIRTUAL_CIRCUIT_CLOSED', 'STATUS_CTX_CONSOLE_DISCONNECT', 'OS_SERVERADMINUI', 'szOID_RSA_signedData', 'KEY_NOTIFY', 'STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT', 'SPC_STRUCTURED_STORAGE_DATA_OBJID', 'STATUS_FVE_AUTH_INVALID_APPLICATION', 'ERROR_HIBERNATION_FAILURE', 'CMSG_SIGNER_CERT_INFO_PARAM', 'ERROR_PROCESS_MODE_ALREADY_BACKGROUND', 'ALPC_MSGFLG_WOW64_CALL', 'ERROR_DBG_RIPEXCEPTION', 'TRUST_E_ACTION_UNKNOWN', 'SC_MANAGER_MODIFY_BOOT_CONFIG', 'ERROR_RECEIVE_PARTIAL', 'CERT_E_UNTRUSTEDTESTROOT', 'ERROR_PREDEFINED_HANDLE', 'SM_REMOTECONTROL', 'CERT_STORE_SET_LOCALIZED_NAME_FLAG', 'PRODUCT_ENTERPRISE_N', 'ERROR_REPARSE_OBJECT', 'ERROR_AUDIT_FAILED', 'FILE_FLAG_FIRST_PIPE_INSTANCE', 'ERROR_EVT_FILTER_NOTELTSET', 'STATUS_GUARD_PAGE_VIOLATION', 'EVENT_TRACE_REAL_TIME_MODE', 'DNS_ATMA_FORMAT_E164', 'CREATE_ALWAYS', 'CMSG_CTRL_VERIFY_HASH', 'ERROR_SCOPE_NOT_FOUND', 'PROCESS_SET_QUOTA', 'RPC_NT_UUID_LOCAL_ONLY', 'RPC_NT_INVALID_ENDPOINT_FORMAT', 'SE_GROUP_RESOURCE', 'ERROR_MOUNT_POINT_NOT_RESOLVED', 'ERROR_INVALID_EA_HANDLE', 'STATUS_KDC_INVALID_REQUEST', 'PROCESS_MODE_BACKGROUND_BEGIN', 'READ_CONTROL', 'EXCEPTION_FLT_OVERFLOW', 'ERROR_INVALID_SEGMENT_NUMBER', 'STATUS_PIPE_DISCONNECTED', 'COM_EXECUTE_LOCAL', 'TXFS_MINIVERSION_COMMITTED_VIEW', 'FILE_CREATE_TREE_CONNECTION', 'SERVICE_TRIGGER_TYPE_IP_ADDRESS_AVAILABILITY', 'STATUS_EXTRANEOUS_INFORMATION', 'STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED', 'STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST', 'STATUS_MCA_EXCEPTION', 'STATUS_NDIS_INVALID_PORT_STATE', 'CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT', 'CERT_TRUST_HAS_CRL_VALIDITY_EXTENDED', 'ERROR_INVALID_STACKSEG', 'STATUS_DS_CANT_START', 'OS_WIN2000ADVSERVER', 'PRODUCT_HOME_SERVER', 'STATUS_LOST_WRITEBEHIND_DATA', 'STATUS_DECRYPTION_FAILED', 'SUCCESSFUL_ACCESS_ACE_FLAG', 'STATUS_SEGMENT_NOTIFICATION', 'STATUS_CLUSTER_JOIN_IN_PROGRESS', 'STATUS_ADDRESS_NOT_ASSOCIATED', 'SM_CXSIZE', 'ERROR_INTERRUPT_STILL_CONNECTED', 'CERT_QUERY_FORMAT_BINARY', 'ERROR_BAD_CURRENT_DIRECTORY', 'STATUS_PROFILING_NOT_STARTED', 'MUTANT_ALL_ACCESS', 'STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY', 'STATUS_CS_ENCRYPTION_FILE_NOT_CSE', 'SW_NORMAL', 'CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES', 'SERVICE_ERROR_CRITICAL', 'ERROR_VERIFIER_STOP', 'STATUS_KEY_DELETED', 'NMPWAIT_USE_DEFAULT_WAIT', 'PROV_MS_EXCHANGE', 'STATUS_ACPI_RS_ACCESS', 'ERROR_REPLY_MESSAGE_MISMATCH', 'ERROR_INVALID_PLUGPLAY_DEVICE_PATH', 'SE_SACL_AUTO_INHERITED', 'STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH', 'STATUS_NONE_MAPPED', 'DIGSIG_E_ENCODE', 'STATUS_GRAPHICS_ALLOCATION_INVALID', 'MEM_RESERVE', 'IMAGE_DLLCHARACTERISTICS_WDM_DRIVER', 'STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN', 'ERROR_LOGON_SERVER_CONFLICT', 'CERT_TRUST_INVALID_BASIC_CONSTRAINTS', 'SERVICE_CONTINUE_PENDING', 'IMAGE_FILE_MACHINE_CEE', 'IMAGE_FILE_MACHINE_CEF', 'STATUS_DS_UNAVAILABLE', 'ERROR_BAD_PIPE', 'ERROR_NOT_SUPPORTED', 'PROCESS_SET_SESSIONID', 'RPC_NT_FP_OVERFLOW', 'STATUS_UNSUPPORTED_COMPRESSION', 'ERROR_TOO_MANY_SEM_REQUESTS', 'STATUS_HIBERNATED', 'ERROR_NO_EVENT_PAIR', 'ERROR_ACCESS_DENIED', 'FILE_DELETE_CHILD', 'CMSG_CRL_PARAM', 'CMSG_SIGNER_HASH_ALGORITHM_PARAM', 'STATUS_EA_LIST_INCONSISTENT', 'DNS_TYPE_KEY', 'STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER', 'STANDARD_RIGHTS_ALL', 'CERT_STORE_ADD_ALWAYS', 'ERROR_SERVICE_NOTIFICATION', 'REG_DWORD_LITTLE_ENDIAN', 'STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED', 'STATUS_SAM_NEED_BOOTKEY_PASSWORD', 'TRUST_E_NOSIGNATURE', 'IMAGE_REL_BASED_MACHINE_SPECIFIC_9', 'OPEN_ALWAYS', 'IMAGE_REL_BASED_MACHINE_SPECIFIC_7', 'ERROR_ERRORS_ENCOUNTERED', 'IMAGE_REL_BASED_MACHINE_SPECIFIC_5', 'AF_CLUSTER', 'SERVICE_USER_DEFINED_CONTROL', 'SE_SACL_PRESENT', 'FILE_FLAG_OVERLAPPED', 'STATUS_INVALID_BUFFER_SIZE', 'SYSTEM_PROCESS_TRUST_LABEL_VALID_MASK', 'CRYPT_E_NOT_FOUND', 'STATUS_GUID_SUBSTITUTION_MADE', 'STATUS_INTERRUPT_STILL_CONNECTED', 'PKCS12_NO_PERSIST_KEY', 'DNS_QUERY_DISABLE_IDN_ENCODING', 'RPC_NT_SEND_INCOMPLETE', 'DNS_TYPE_SRV', 'DNS_QUERY_APPEND_MULTILABEL', 'CERT_NAME_SIMPLE_DISPLAY_TYPE', 'STATUS_POLICY_OBJECT_NOT_FOUND', 'CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR', 'ERROR_CANNOT_BREAK_OPLOCK', 'STATUS_NO_MORE_FILES', 'FILE_OPENED', 'STATUS_THREAD_ALREADY_IN_TASK', 'SM_CXFULLSCREEN', 'STATUS_LOG_CONTAINER_WRITE_FAILED', 'STATUS_WAKE_SYSTEM_DEBUGGER', 'STATUS_FILE_FORCED_CLOSED', 'SM_MIDEASTENABLED', 'STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT', 'CONTEXT_INTEGER', 'FILE_SHARE_WRITE', 'STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS', 'ERROR_LOCK_FAILED', 'CMSG_CTRL_DEL_CERT', 'CMSG_SIGNER_AUTH_ATTR_PARAM', 'ERROR_IMAGE_MACHINE_TYPE_MISMATCH', 'E_FAIL', 'STATUS_CRM_PROTOCOL_NOT_FOUND', 'CMSG_CTRL_KEY_TRANS_DECRYPT', 'STATUS_GRAPHICS_COPP_NOT_SUPPORTED', 'RPC_NT_NO_CALL_ACTIVE', 'RPC_NT_NO_PRINC_NAME', 'EXCEPTION_NONCONTINUABLE', 'ERROR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY', 'STATUS_MUI_INVALID_FILE', 'STATUS_FLT_DISALLOW_FAST_IO', 'SE_SECURITY_NAME', 'CERT_FIND_SIGNATURE_HASH', 'STATUS_SMARTCARD_SUBSYSTEM_FAILURE', 'STATUS_INVALID_OWNER', 'STATUS_FLT_ALREADY_ENLISTED', 'CRYPT_E_HASH_VALUE', 'STATUS_CTX_CLIENT_QUERY_TIMEOUT', 'ERROR_TOO_MANY_MODULES', 'IMAGE_FILE_MACHINE_AM33', 'STATUS_FVE_OVERLAPPED_UPDATE', 'MAXLEN_PHYSADDR', 'WRITE_DAC', 'szOID_PKCS', 'STATUS_OBJECT_PATH_NOT_FOUND', 'ERROR_PROCESS_IN_JOB', 'IMAGE_SCN_MEM_EXECUTE', 'DNS_TYPE_NBSTAT', 'szOID_INFOSEC_SuiteAIntegrity', 'STATUS_SECRET_TOO_LONG', 'STATUS_SXS_PROCESS_TERMINATION_REQUESTED', 'STATUS_LOCAL_DISCONNECT', 'STATUS_DEVICE_FEATURE_NOT_SUPPORTED', 'FILE_ATTRIBUTE_COMPRESSED', 'CERT_COMPARE_PUBLIC_KEY', 'AF_NETBIOS', 'FILE_SUPERSEDE', 'IMAGE_NUMBEROF_DIRECTORY_ENTRIES', 'STATUS_TOO_MANY_NODES', 'szOID_RSA_messageDigest', 'ERROR_IS_SUBST_TARGET', 'WRITE_WATCH_FLAG_RESET', 'STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION', 'STATUS_CLUSTER_NODE_DOWN', 'STATUS_POWER_STATE_INVALID', 'SERVICE_ADAPTER', 'TIMER_MODIFY_STATE', 'STATUS_NDIS_INTERFACE_NOT_FOUND', 'STATUS_CSS_SCRAMBLED_SECTOR', 'ERROR_DISCARDED', 'ERROR_OUTOFMEMORY', 'PRODUCT_STANDARD_SERVER_CORE_V', 'szOID_RSA_MD2RSA', 'STATUS_NO_TOKEN', 'szOID_RSA_encryptedData', 'STATUS_FWP_NULL_POINTER', 'STATUS_NO_LINK_TRACKING_IN_TRANSACTION', 'ERROR_SYSTEM_PROCESS_TERMINATED', 'OS_WIN2000ORGREATER', 'WRITE_OWNER', 'FILE_MAXIMUM_DISPOSITION', 'ERROR_INFLOOP_IN_RELOC_CHAIN', 'SE_ASSIGNPRIMARYTOKEN_NAME', 'STATUS_INVALID_PORT_ATTRIBUTES', 'DBG_CONTINUE', 'CMSG_CONTENTS_OCTETS_FLAG', 'X509_UNICODE_NAME_VALUE', 'ERROR_BAD_PATHNAME', 'SM_CYDRAG', 'ERROR_INVALID_IMAGE_HASH', 'ERROR_RESOURCE_LANG_NOT_FOUND', 'ERROR_IO_PRIVILEGE_FAILED', 'PIPE_READMODE_MESSAGE', 'STATUS_PREDEFINED_HANDLE', 'FILE_CREATE', 'STATUS_ILLEGAL_ELEMENT_ADDRESS', 'ALPC_MESSAGE_VIEW_ATTRIBUTE', 'CERT_E_REVOCATION_FAILURE', 'STATUS_GRAPHICS_NO_ACTIVE_VIDPN', 'ERROR_EXE_MARKED_INVALID', 'STATUS_GRAPHICS_OPM_INVALID_POINTER', 'PORT_CONNECT', 'STATUS_STREAM_MINIVERSION_NOT_VALID', 'FILE_SUPPORTS_HARD_LINKS', 'STATUS_NO_MORE_MATCHES', 'ERROR_INVALID_LDT_SIZE', 'STATUS_MUI_INVALID_RC_CONFIG', 'STATUS_FWP_TOO_MANY_CALLOUTS', 'COMPRESSION_FORMAT_XPRESS_HUFF', 'STATUS_PWD_HISTORY_CONFLICT', 'STATUS_COMPRESSION_DISABLED', 'ERROR_PAGEFILE_QUOTA_EXCEEDED', 'ERROR_MCA_OCCURED', 'WTD_CHOICE_CERT', 'IMAGE_FILE_MACHINE_R10000', 'SERVICE_CHANGE_CONFIG', 'OBJECT_TYPE_CREATE', 'ERROR_NOT_SAFE_MODE_DRIVER', 'CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG', 'REG_QWORD_LITTLE_ENDIAN', 'ERROR_RANGE_LIST_CONFLICT', 'IMAGE_SCN_ALIGN_8BYTES', 'EVENT_TRACE_CONTROL_STOP', 'RRF_ZEROONFAILURE', 'ERROR_INVALID_QUOTA_LOWER', 'USAGE_MATCH_TYPE_OR', 'ERROR_SEM_NOT_FOUND', 'STATUS_ACPI_INVALID_TARGETTYPE', 'THREAD_ALL_ACCESS', 'szOID_OIWDIR_CRPT', 'STATUS_SXS_ACTIVATION_CONTEXT_DISABLED', 'JOB_OBJECT_QUERY', 'STATUS_TRANSACTION_ALREADY_ABORTED', 'ERROR_RXACT_COMMIT_NECESSARY', 'PRODUCT_ULTIMATE_N', 'STATUS_FILE_LOCKED_WITH_WRITERS', 'STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY', 'PRODUCT_ULTIMATE_E', 'STATUS_INVALID_PRIMARY_GROUP', 'EVENT_TRACE_FLAG_VIRTUAL_ALLOC', 'STATUS_TIMER_RESOLUTION_NOT_SET', 'STATUS_DISK_CORRUPT_ERROR', 'E_NOINTERFACE', 'STATUS_FILE_TOO_LARGE', 'STATUS_CONNECTION_COUNT_LIMIT', 'STATUS_CALLBACK_BYPASS', 'STATUS_BAD_STACK', 'STATUS_FLOATED_SECTION', 'ERROR_WMI_ALREADY_DISABLED', 'STATUS_CTX_GRAPHICS_INVALID', 'STATUS_DELAY_LOAD_FAILED', 'IMAGE_SCN_LNK_OTHER', 'TH32CS_SNAPTHREAD', 'PROV_INTEL_SEC', 'RPC_E_INVALID_OBJREF', 'DNS_TYPE_DS', 'IMAGE_FILE_MACHINE_EBC', 'PRODUCT_STANDARD_SERVER_SOLUTIONS_CORE', 'ERROR_INVALID_PASSWORD', 'STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE', 'DNS_QUERY_MULTICAST_ONLY', 'szOID_OIWSEC_shaRSA', 'STATUS_FWP_INVALID_PARAMETER', 'SM_CXICON', 'DNS_QUERY_STANDARD', 'SM_CMONITORS', 'NTE_PERM', 'STATUS_NO_UNICODE_TRANSLATION', 'LPC_REQUEST', 'CERT_XML_NAME_STR', 'DBG_RIPEXCEPTION', 'IMAGE_SCN_ALIGN_8192BYTES', 'PROCESS_ALL_ACCESS', 'STATUS_CARDBUS_NOT_SUPPORTED', 'DETACHED_PROCESS', 'STGM_FAILIFTHERE', 'STATUS_DRIVER_FAILED_PRIOR_UNLOAD', 'OS_WOW6432', 'RPC_NT_PROTOCOL_ERROR', 'STATUS_PROTOCOL_NOT_SUPPORTED', 'STATUS_LUIDS_EXHAUSTED', 'RPC_NT_INVALID_VERS_OPTION', 'ERROR_TOO_MANY_SEMAPHORES', 'SW_MINIMIZE', 'STGM_READ', 'CRYPT_E_FILE_ERROR', 'SPC_LINK_OBJID', 'CERT_BACKED_UP_PROP_ID', 'STATUS_FWP_ALREADY_EXISTS', 'PRODUCT_CORE', 'CERT_TRUST_HAS_NAME_MATCH_ISSUER', 'FILE_SUPPORTS_OPEN_BY_FILE_ID', 'CERT_SIMPLE_NAME_STR', 'ERROR_EVT_INVALID_PUBLISHER_NAME', 'STATUS_LOG_BLOCK_VERSION', 'STATUS_FT_ORPHANING', 'CMSG_CERT_COUNT_PARAM', 'AF_APPLETALK', 'szOID_NIST_AES256_CBC', 'ERROR_BUSY', 'STATUS_GRAPHICS_INVALID_PIXELFORMAT', 'OWNER_SECURITY_INFORMATION', 'SPC_CERT_EXTENSIONS_OBJID', 'ERROR_IMAGE_SUBSYSTEM_NOT_PRESENT', 'IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT', 'SE_PRIVILEGE_ENABLED_BY_DEFAULT', 'EVENT_HEADER_PROPERTY_FORWARDED_XML', 'SE_GROUP_LOGON_ID', 'PRODUCT_ENTERPRISE_SERVER_IA64', 'STATUS_REGISTRY_IO_FAILED', 'STATUS_FOUND_OUT_OF_SCOPE', 'STATUS_DLL_INIT_FAILED', 'REG_RESOURCE_LIST', 'STATUS_INVALID_ACL', 'STATUS_ACPI_INVALID_DATA', 'ERROR_INVALID_LIST_FORMAT', 'ERROR_PAGE_FAULT_PAGING_FILE', 'szOID_COMMON_NAME', 'STATUS_NDIS_LOW_POWER_STATE', 'ERROR_EVT_MALFORMED_XML_TEXT', 'STATUS_IP_ADDRESS_CONFLICT2', 'IMAGE_SCN_TYPE_REG', 'COM_ACTIVATE_REMOTE', 'STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING', 'CERT_EFS_PROP_ID', 'STATUS_SMI_PRIMITIVE_INSTALLER_FAILED', 'CMSG_SIGNED', 'CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL', 'SEC_FILE', 'IMAGE_FILE_MACHINE_SH3DSP', 'SECURITY_MANDATORY_PROTECTED_PROCESS_RID', 'ERROR_SHARING_PAUSED', 'STATUS_CURRENT_DOMAIN_NOT_ALLOWED', 'ERROR_WMI_TRY_AGAIN', 'RRF_RT_QWORD', 'TOKEN_MANDATORY_POLICY_VALID_MASK', 'FILE_NON_DIRECTORY_FILE', 'COMPRESSION_FORMAT_DEFAULT', 'IMAGE_SCN_ALIGN_256BYTES', 'SEC_LARGE_PAGES', 'PRODUCT_STARTER', 'STATUS_KDC_UNKNOWN_ETYPE', 'NTE_TOKEN_KEYSET_STORAGE_FULL', 'STATUS_APC_RETURNED_WHILE_IMPERSONATING', 'EXCEPTION_FLT_DIVIDE_BY_ZERO', 'FILE_SEQUENTIAL_WRITE_ONCE', 'EXCEPTION_INT_OVERFLOW', 'JOB_OBJECT_SET_SECURITY_ATTRIBUTES', 'STATUS_SMARTCARD_WRONG_PIN', 'szOID_ECDSA_SHA512', 'ERROR_JOIN_TO_JOIN', 'szOID_PKCS_10', 'EVENT_TRACE_FLAG_EXTENSION', 'PROV_SSL', 'SERVICE_TRIGGER_TYPE_DEVICE_INTERFACE_ARRIVAL', 'ERROR_WMI_UNRESOLVED_INSTANCE_REF', 'EXCEPTION_GUARD_PAGE', 'STATUS_CTX_RESPONSE_ERROR', 'IMAGE_FILE_LINE_NUMS_STRIPPED', 'STATUS_INVALID_DEVICE_OBJECT_PARAMETER', 'STATUS_UNEXPECTED_MM_MAP_ERROR', 'ERROR_ROWSNOTRELEASED', 'ERROR_FILE_EXISTS', 'PRODUCT_ENTERPRISE_E', 'STATUS_LOG_SECTOR_PARITY_INVALID', 'IMAGE_FILE_MACHINE_SH3E', 'ERROR_ADAP_HDW_ERR', 'STATUS_COMMITMENT_MINIMUM', 'CERT_QUERY_CONTENT_CRL', 'IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE', 'IMAGE_SCN_ALIGN_2BYTES', 'DRIVE_CDROM', 'EVENTLOG_FORWARDS_READ', 'DRIVE_UNKNOWN', 'STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION', 'STATUS_CLEANER_CARTRIDGE_INSTALLED', 'FILE_PERSISTENT_ACLS', 'STATUS_CANT_DISABLE_MANDATORY', 'CERT_FIND_MD5_HASH', 'CMSG_SIGNER_CERT_ID_PARAM', 'STATUS_ACCESS_VIOLATION', 'STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE', 'STATUS_SERVICE_NOTIFICATION', 'STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS', 'CERT_TRUST_IS_NOT_SIGNATURE_VALID', 'CERT_QUERY_CONTENT_PKCS10', 'STATUS_FWP_INVALID_WEIGHT', 'STATUS_NOTIFY_CLEANUP', 'STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER', 'PAGE_GUARD', 'EVENT_TRACE_TYPE_CONFIG_CPU', 'STATUS_WX86_INTERNAL_ERROR', 'STATUS_UNABLE_TO_LOCK_MEDIA', 'LPC_DATAGRAM', 'DEBUG_ONLY_THIS_PROCESS', 'AF_FIREFOX', 'STATUS_MCA_OCCURED', 'ERROR_PLUGPLAY_QUERY_VETOED', 'ERROR_DATA_NOT_ACCEPTED', 'ERROR_INVALID_BLOCK', 'STATUS_INVALID_PLUGPLAY_DEVICE_PATH', 'STATUS_TRANSACTION_SUPERIOR_EXISTS', 'RPC_NT_NO_PROTSEQS', 'STATUS_NO_SUCH_MEMBER', 'STATUS_INVALID_PIPE_STATE', 'SM_SECURE', 'PERSIST_E_NOTSELFSIZING', 'STATUS_OBJECT_PATH_SYNTAX_BAD', 'ERROR_CONTROL_C_EXIT', 'STATUS_CLUSTER_NODE_UP', 'RPC_NT_INTERNAL_ERROR', 'EXIT_PROCESS_DEBUG_EVENT', 'TRUST_E_PROVIDER_UNKNOWN', 'STATUS_CTX_MODEM_INF_NOT_FOUND', 'CREATE_PRESERVE_CODE_AUTHZ_LEVEL', 'ERROR_WAIT_FOR_OPLOCK', 'KEY_READ', 'CERT_FIND_ISSUER_OF', 'IMAGE_FILE_DLL', 'STATUS_DEVICE_NOT_PARTITIONED', 'CERT_STORE_PROV_FILENAME_A', 'MS_DEF_PROV', 'STATUS_SYMLINK_CLASS_DISABLED', 'SYSTEM_AUDIT_CALLBACK_ACE_TYPE', 'IMAGE_DIRECTORY_ENTRY_ARCHITECTURE', 'SYSTEM_SCOPED_POLICY_ID_ACE_TYPE', 'FILE_ATTRIBUTE_SPARSE_FILE', 'STATUS_CANT_ACCESS_DOMAIN_INFO', 'CERT_STORE_PROV_FILENAME_W', 'STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER', 'ERROR_SUBST_TO_SUBST', 'szOID_RSA_contentType', 'FILE_ATTRIBUTE_OFFLINE', 'STATUS_DS_NO_ATTRIBUTE_OR_VALUE', 'STATUS_INVALID_SIGNATURE', 'STGM_SHARE_DENY_WRITE', 'ERROR_CHECKING_FILE_SYSTEM', 'STATUS_REVOCATION_OFFLINE_C', 'ERROR_FLOAT_MULTIPLE_TRAPS', 'RPC_NT_NAME_SERVICE_UNAVAILABLE', 'STATUS_DS_GROUP_CONVERSION_ERROR', 'ERROR_PATH_NOT_FOUND', 'PRODUCT_HOME_PREMIUM_SERVER', 'SE_PRIVILEGE_USED_FOR_ACCESS', 'ERROR_EVT_UNRESOLVED_PARAMETER_INSERT', 'STD_OUTPUT_HANDLE', 'CERT_EXTENDED_ERROR_INFO_PROP_ID', 'COMPRESSION_ENGINE_HIBER', 'STATUS_FLT_DO_NOT_ATTACH', 'TIMER_ALL_ACCESS', 'STATUS_WRONG_CREDENTIAL_HANDLE', 'ERROR_RANGE_NOT_FOUND', 'STATUS_TRANSACTION_REQUEST_NOT_VALID', 'FILE_SUPPORTS_USN_JOURNAL', 'STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT', 'CRYPT_NO_SALT', 'ERROR_WX86_WARNING', 'STATUS_LOG_FULL', 'STATUS_THREADPOOL_HANDLE_EXCEPTION', 'STATUS_TXF_DIR_NOT_EMPTY', 'STATUS_LOG_INCONSISTENT_SECURITY', 'LPC_EXCEPTION', 'STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME', 'PAGE_READONLY', 'AF_ATM', 'EXCEPTION_IN_PAGE_ERROR', 'STARTF_USEFILLATTRIBUTE', 'SPC_RAW_FILE_DATA_OBJID', 'STATUS_CONNECTION_RESET', 'STATUS_DRIVER_ORDINAL_NOT_FOUND', 'STARTF_USECOUNTCHARS', 'IMAGE_SCN_LNK_INFO', 'STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE', 'STATUS_DOMAIN_CTRLR_CONFIG_ERROR', 'FILE_OVERWRITTEN', 'STATUS_DELETE_PENDING', 'STATUS_INVALID_SECURITY_DESCR', 'FILE_SUPPORTS_REMOTE_STORAGE', 'CMSG_CTRL_MAIL_LIST_DECRYPT', 'SE_SYSTEM_ENVIRONMENT_NAME', 'STATUS_LPC_REPLY_LOST', 'NTE_FAIL', 'STATUS_FLT_CONTEXT_ALREADY_LINKED', 'FAX_JOB_SUBMIT', 'CERT_COMPARE_KEY_IDENTIFIER', 'STATUS_REDIRECTOR_HAS_OPEN_HANDLES', 'STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND', 'STATUS_CALLBACK_RETURNED_TRANSACTION', 'SERVICE_ERROR_NORMAL', 'IMAGE_REL_BASED_HIGHADJ', 'SM_CYMINIMIZED', 'SERVICE_CONTROL_SHUTDOWN', 'PRODUCT_STORAGE_STANDARD_SERVER', 'STATUS_DRIVER_INTERNAL_ERROR', 'STATUS_UNEXPECTED_MM_CREATE_ERR', 'HKEY_LOCAL_MACHINE', 'STATUS_VOLUME_DIRTY', 'STATUS_NO_PAGEFILE', 'RPC_NT_SS_CHAR_TRANS_OPEN_FAIL', 'STATUS_FLT_CONTEXT_ALREADY_DEFINED', 'STATUS_INSTRUCTION_MISALIGNMENT', 'STATUS_INVALID_ACCOUNT_NAME', 'ERROR_NOT_REGISTRY_FILE', 'STATUS_CANT_ENABLE_DENY_ONLY', 'ERROR_ILLEGAL_DLL_RELOCATION', 'ERROR_WMI_ALREADY_ENABLED', 'MEM_PHYSICAL', 'szOID_DS', 'IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY', 'ERROR_NOT_JOINED', 'SM_CYSIZE', 'DNS_TYPE_NIMLOC', 'WTD_CHOICE_BLOB', 'STATUS_PRINT_CANCELLED', 'CRYPT_FORCE_KEY_PROTECTION_HIGH', 'CERT_COMPARE_MD5_HASH', 'OS_WIN2000SERVER', 'STATUS_SXS_SETTING_NOT_REGISTERED', 'STATUS_ACPI_ASSERT_FAILED', 'PRODUCT_DATACENTER_SERVER_CORE', 'STATUS_ALIAS_EXISTS', 'szOID_ECC_CURVE_P256', 'STATUS_FWP_INVALID_RANGE', 'STATUS_FORMS_AUTH_REQUIRED', 'EVENT_TRACE_USE_PAGED_MEMORY', 'MAXLEN_IFDESCR', 'CERT_COMPARE_EXISTING', 'RRF_RT_REG_BINARY', 'VER_NT_SERVER', 'RPC_E_CHANGED_MODE', 'AF_DATAKIT', 'STATUS_SMARTCARD_LOGON_REQUIRED', 'ERROR_DBG_COMMAND_EXCEPTION', 'PRODUCT_ESSENTIALBUSINESS_SERVER_MGMT', 'STATUS_LOG_POLICY_CONFLICT', 'NTE_TEMPORARY_PROFILE', 'ALPC_VIEWFLG_NOT_SECURE', 'STATUS_FWP_CALLOUT_NOT_FOUND', 'RPC_NT_WRONG_STUB_VERSION', 'TOKEN_SECURITY_ATTRIBUTE_TYPE_SID', 'szOID_DH_SINGLE_PASS_STDDH_SHA384_KDF', 'X509_CERT_REQUEST_TO_BE_SIGNED', 'ERROR_MARSHALL_OVERFLOW', 'SERVICE_STOPPED', 'SERVICE_QUERY_STATUS', 'WTD_STATEACTION_VERIFY', 'STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED', 'ERROR_PROFILING_AT_LIMIT', 'STATUS_DRIVER_CANCEL_TIMEOUT', 'OBJ_PERMANENT', 'CERT_INFO_SUBJECT_FLAG', 'PRODUCT_STORAGE_ENTERPRISE_SERVER_CORE', 'STATUS_REPARSE_ATTRIBUTE_CONFLICT', 'STATUS_FWP_NULL_DISPLAY_NAME', 'STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY', 'ERROR_RESOURCE_TYPE_NOT_FOUND', 'STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET', 'ERROR_PROFILING_NOT_STARTED', 'ERROR_WMI_INVALID_REGINFO', 'STATUS_DS_SENSITIVE_GROUP_VIOLATION', 'HKEY_PERFORMANCE_TEXT', 'TRUST_E_SUBJECT_NOT_TRUSTED', 'SM_CXFRAME', 'WTD_UI_NOGOOD', 'STATUS_FLT_FILTER_NOT_FOUND', 'STATUS_NO_MORE_EAS', 'STGM_NOSCRATCH', 'ERROR_ALLOCATE_BUCKET', 'SPC_CAB_DATA_OBJID', 'STATUS_DRIVER_DATABASE_ERROR', 'DNS_TYPE_TKEY', 'STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED', 'ERROR_WMI_DP_NOT_FOUND', 'szOID_RSA_emailAddr', 'CERT_STORE_UNSAFE_PHYSICAL_FLAG', 'ERROR_SHARING_VIOLATION', 'FC_SIMPLE_POINTER', 'RPC_NT_FP_UNDERFLOW', 'DNS_QUERY_BYPASS_CACHE', 'ERROR_EVT_FILTER_OUT_OF_RANGE', 'CONTEXT_DEBUG_REGISTERS', 'STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS', 'STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE', 'CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK', 'ERROR_WMI_SERVER_UNAVAILABLE', 'ERROR_REQUEST_OUT_OF_SEQUENCE', 'ERROR_INVALID_PORT_ATTRIBUTES', 'STATUS_DS_BUSY', 'STATUS_FWP_BUILTIN_OBJECT', 'SE_GROUP_USE_FOR_DENY_ONLY', 'CMSG_ATTR_CERT_COUNT_PARAM', 'STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT', 'STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH', 'STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED', 'RPC_C_IMP_LEVEL_IDENTIFY', 'STATUS_BAD_FUNCTION_TABLE', 'ERROR_PRINTQ_FULL', 'EVENTLOG_WARNING_TYPE', 'CERT_STORE_BACKUP_RESTORE_FLAG', 'FC_ALLOCED_ON_STACK', 'ERROR_PNP_INVALID_ID', 'ERROR_PROC_NOT_FOUND', 'ERROR_OUT_OF_PAPER', 'SM_CXVIRTUALSCREEN', 'ALPC_MSGFLG_REPLY_MESSAGE', 'STATUS_RANGE_NOT_LOCKED', 'ACCESS_DENIED_CALLBACK_ACE_TYPE', 'STATUS_DEVICE_PROTOCOL_ERROR', 'STATUS_MEMBER_NOT_IN_ALIAS', 'STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED', 'ERROR_INVALID_MESSAGE', 'RPC_NT_UNKNOWN_IF', 'STATUS_ACPI_INVALID_INDEX', 'SM_STARTER', 'EVENTLOG_ERROR_TYPE', 'RPC_NT_SS_CONTEXT_MISMATCH', 'STGFMT_ANY', 'CERT_COMPARE_NAME', 'PRODUCT_SERVER_FOR_SMALLBUSINESS_V', 'STATUS_DEVICE_DOES_NOT_EXIST', 'ERROR_LOG_HARD_ERROR', 'STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE', 'SERVICE_RUNNING', 'DNS_TYPE_DNAME', 'STATUS_DS_CANT_ON_RDN', 'IMAGE_SCN_TYPE_GROUP', 'STATUS_DATA_LOST_REPAIR', 'CMSG_AUTHENTICATED_ATTRIBUTES_FLAG', 'ERROR_RING2SEG_MUST_BE_MOVABLE', 'CERT_STORE_SHARE_STORE_FLAG', 'STATUS_SXS_INVALID_ACTCTXDATA_FORMAT', 'STATUS_INVALID_IMAGE_WIN_16', 'STATUS_MUI_FILE_NOT_LOADED', 'STATUS_FILE_NOT_AVAILABLE', 'RRF_RT_REG_EXPAND_SZ', 'STATUS_DATA_ERROR', 'ERROR_PIPE_NOT_CONNECTED', 'NTE_NOT_FOUND', 'SM_CXHSCROLL', 'STATUS_IMAGE_NOT_AT_BASE', 'STATUS_LOGIN_WKSTA_RESTRICTION', 'ATM_NSAP', 'ACCESS_MIN_MS_OBJECT_ACE_TYPE', 'STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE', 'szOID_OIWDIR_md2RSA', 'STATUS_FWP_WRONG_SESSION', 'ERROR_PNP_TRANSLATION_FAILED', 'SEMAPHORE_QUERY_STATE', 'WARMING_NOT_SAME_FLAG_FOR_WINXP', 'szOID_OIWDIR_SIGN', 'CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID', 'FILE_VALID_SET_FLAGS', 'DNS_TYPE_UID', 'STATUS_HOST_DOWN', 'ERROR_PIPE_CONNECTED', 'ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL', 'STATUS_DISK_RECALIBRATE_FAILED', 'szOID_INFOSEC_sdnsKMandSig', 'ERROR_PAGEFILE_CREATE_FAILED', 'STATUS_WORKING_SET_LIMIT_RANGE', 'IMAGE_SCN_TYPE_NO_PAD', 'FILE_RANDOM_ACCESS', 'STATUS_INDOUBT_TRANSACTIONS_EXIST', 'STATUS_OBJECTID_EXISTS', 'STATUS_CTX_BAD_VIDEO_MODE', 'ERROR_NOT_ENOUGH_MEMORY', 'SPC_SP_AGENCY_INFO_OBJID', 'STATUS_FWP_RESERVED', 'SYSTEM_ALARM_OBJECT_ACE_TYPE', 'STATUS_FILE_CHECKED_OUT', 'STATUS_ACPI_INVALID_TABLE', 'IMAGE_SCN_MEM_LOCKED', 'NTE_NOT_SUPPORTED', 'CONTEXT_FLOATING_POINT', 'ERROR_KEY_HAS_CHILDREN', 'STATUS_REVOCATION_OFFLINE_KDC', 'CERT_CTL_USAGE_PROP_ID', 'STATUS_FLT_DELETING_OBJECT', 'ERROR_INSUFFICIENT_BUFFER', 'EVENT_HEADER_FLAG_PRIVATE_SESSION', 'STATUS_COULD_NOT_INTERPRET', 'STATUS_DEVICE_ENUMERATION_ERROR', 'ERROR_UNHANDLED_EXCEPTION', 'ERROR_INVALID_TARGET_HANDLE', 'STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED', 'STATUS_SYSTEM_POWERSTATE_TRANSITION', 'ERROR_REDIR_PAUSED', 'STATUS_NO_SUCH_DEVICE', 'STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE', 'STATUS_BAD_NETWORK_NAME', 'PRODUCT_EMBEDDED', 'PIPE_UNLIMITED_INSTANCES', 'STATUS_BUFFER_TOO_SMALL', 'API_SET_SCHEMA_VERSION_V4', 'STATUS_MISSING_SYSTEMFILE', 'API_SET_SCHEMA_VERSION_V2', 'API_SET_SCHEMA_VERSION_V3', 'SERVICE_PAUSE_CONTINUE', 'STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION', 'PRODUCT_MEDIUMBUSINESS_SERVER_MESSAGING', 'FILE_FLAG_NO_BUFFERING', 'DEBUG_EVENT_EXCEPTION', 'STATUS_PARTIAL_COPY', 'STATUS_GRAPHICS_PARTIAL_DATA_POPULATED', 'STATUS_TRUSTED_DOMAIN_FAILURE', 'PRODUCT_ENTERPRISE_N_EVALUATION', 'STATUS_ACPI_INVALID_MUTEX_LEVEL', 'STATUS_SERIAL_NO_DEVICE_INITED', 'ERROR_COMMITMENT_MINIMUM', 'DBG_TERMINATE_THREAD', 'OS_MEDIACENTER', 'STATUS_XML_PARSE_ERROR', 'FILE_VALID_OPTION_FLAGS', 'ERROR_INVALID_STARTING_CODESEG', 'STATUS_CLUSTER_NODE_NOT_FOUND', 'STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE', 'STATUS_TRANSACTION_INTEGRITY_VIOLATED', 'STATUS_DLL_INIT_FAILED_LOGOFF', 'EVENT_TRACE_RELOG_MODE', 'WAIT_IO_COMPLETION', 'STATUS_FLT_NOT_INITIALIZED', 'STATUS_FLT_NAME_CACHE_MISS', 'ERROR_INSTRUCTION_MISALIGNMENT', 'STATUS_VERIFY_REQUIRED', 'ERROR_INVALID_MODULETYPE', 'CRYPT_UPDATE_KEY', 'ERROR_RESOURCE_DATA_NOT_FOUND', 'STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE', 'STGFMT_DOCFILE', 'CERT_COMPARE_ANY', 'CRYPT_DATA_KEY', 'STATUS_MESSAGE_NOT_FOUND', 'SERVICE_STOP', 'RPC_NT_MAX_CALLS_TOO_SMALL', 'RPC_REQUEST_TYPE_CALL', 'STATUS_DOWNGRADE_DETECTED', 'SPC_JAVA_CLASS_DATA_OBJID', 'ERROR_DLL_MIGHT_BE_INSECURE', 'STATUS_FLOPPY_WRONG_CYLINDER', 'STATUS_NO_MEMORY', 'NTE_FIXEDPARAMETER', 'STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION', 'szOID_OIWSEC_dsaSHA1', 'DEBUG_EVENT_UNLOAD_MODULE', 'STATUS_CSS_REGION_MISMATCH', 'SERVICE_CONTROL_TIMECHANGE', 'STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER', 'CERT_TRUST_CTL_IS_NOT_TIME_VALID', 'SE_CREATE_PERMANENT_NAME', 'CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED', 'STATUS_NO_SUCH_GROUP', 'SERVICE_BOOT_START', 'STATUS_PROPSET_NOT_FOUND', 'STATUS_NDIS_INVALID_ADDRESS', 'STATUS_FAIL_FAST_EXCEPTION', 'PRODUCT_SOLUTION_EMBEDDEDSERVER_CORE', 'STATUS_FLOAT_UNDERFLOW', 'ERROR_NOT_LOCKED', 'WTD_STATEACTION_AUTO_CACHE', 'STATUS_WMI_ALREADY_ENABLED', 'KEY_WOW64_64KEY', 'STATUS_CANNOT_IMPERSONATE', 'STATUS_BIZRULES_NOT_ENABLED', 'EVENT_TRACE_FLAG_IMAGE_LOAD', 'STATUS_LOG_METADATA_FLUSH_FAILED', 'STATUS_CONNECTION_DISCONNECTED', 'IMAGE_SCN_CNT_UNINITIALIZED_DATA', 'STATUS_ACCOUNT_EXPIRED', 'STATUS_DS_INCORRECT_ROLE_OWNER', 'STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE', 'CERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORE', 'STATUS_IPSEC_THROTTLE_DROP', 'STATUS_HANDLE_NOT_CLOSABLE', 'STATUS_FWP_INCOMPATIBLE_LAYER', 'ERROR_PARTIAL_COPY', 'STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED', 'ERROR_PIPE_BUSY', 'PIPE_READMODE_BYTE', 'SM_CMOUSEBUTTONS', 'ALPC_HANDLEFLG_DUPLICATE_SAME_ATTRIBUTES', 'CERT_FIND_SUBJECT_CERT', 'EVENT_TRACE_FILE_MODE_CIRCULAR', 'PAGE_NOACCESS', 'STATUS_NOT_COMMITTED', 'CERT_COMPARE_ENHKEY_USAGE', 'STATUS_SXS_RELEASE_ACTIVATION_CONTEXT', 'KEY_SET_VALUE', 'STATUS_NO_TRUST_SAM_ACCOUNT', 'STATUS_PER_USER_TRUST_QUOTA_EXCEEDED', 'STATUS_FT_MISSING_MEMBER', 'STATUS_INVALID_LOGON_TYPE', 'STATUS_DEVICE_POWERED_OFF', 'STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS', 'RPC_NT_OUT_OF_RESOURCES', 'TIMER_QUERY_STATE', 'TOKEN_SECURITY_ATTRIBUTE_VALID_FLAGS', 'FILE_READ_ATTRIBUTES', 'STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET', 'PKCS_UTC_TIME', 'STATUS_IMAGE_MP_UP_MISMATCH', 'CREATE_SUSPENDED', 'STATUS_FLOAT_OVERFLOW', 'IMAGE_FILE_NET_RUN_FROM_SWAP', 'STATUS_PORT_MESSAGE_TOO_LONG', 'CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID', 'X509_CHOICE_OF_TIME', 'szOID_INFOSEC_mosaicIntegrity', 'STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK', 'API_SET_LOAD_SCHEMA_ORDINAL', 'IMAGE_FILE_MACHINE_I386', 'STATUS_INVALID_MEMBER', 'RPC_NT_UNKNOWN_AUTHN_TYPE', 'CERT_E_INVALID_NAME', 'STATUS_GRAPHICS_TARGET_ALREADY_IN_SET', 'ERROR_FATAL_APP_EXIT', 'STATUS_WAKE_SYSTEM', 'SC_MANAGER_ALL_ACCESS', 'SECURITY_MANDATORY_LOW_RID', 'MEM_LARGE_PAGES', 'RPC_NT_PIPE_EMPTY', 'STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION', 'ERROR_DEV_NOT_EXIST', 'MEM_WRITE_WATCH', 'STATUS_FILE_SYSTEM_LIMITATION', 'RPC_NT_PROCNUM_OUT_OF_RANGE', 'szOID_RSA_DES_EDE3_CBC', 'SE_GROUP_DEFAULTED', 'LOAD_DLL_DEBUG_EVENT', 'PROFILE_SERVER', 'STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST', 'ERROR_INVALID_SIGNAL_NUMBER', 'CERT_INFO_ISSUER_FLAG', 'ERROR_DRIVER_FAILED_SLEEP', 'DRIVE_REMOVABLE', 'CERT_SYSTEM_STORE_LOCATION_MASK', 'STATUS_NO_SPOOL_SPACE', 'STATUS_PNP_RESTART_ENUMERATION', 'ERROR_COULD_NOT_INTERPRET', 'TOKEN_SECURITY_ATTRIBUTE_DISABLED', 'CERT_QUERY_CONTENT_PFX', 'ERROR_PAGE_FAULT_DEMAND_ZERO', 'CERT_TRUST_HAS_EXACT_MATCH_ISSUER', 'STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET', 'ERROR_SWAPERROR', 'EXCEPTION_MAXIMUM_PARAMETERS', 'STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE', 'STATUS_DOMAIN_CONTROLLER_NOT_FOUND', 'WTD_REVOKE_WHOLECHAIN', 'STATUS_LOG_GROWTH_FAILED', 'INFINITE', 'STATUS_LOG_RECORD_NONEXISTENT', 'STATUS_RXACT_INVALID_STATE', 'DBG_CONTROL_BREAK', 'STATUS_WAIT_FOR_OPLOCK', 'ATM_E164', 'CRYPT_INITIATOR', 'STATUS_SYSTEM_IMAGE_BAD_SIGNATURE', 'STATUS_GRAPHICS_NO_VIDPNMGR', 'X509_ALTERNATE_NAME', 'STATUS_XML_ENCODING_MISMATCH', 'SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ANY', 'EVENTLOG_AUDIT_FAILURE', 'STATUS_NDIS_BUFFER_TOO_SHORT', 'STATUS_LOG_SECTOR_REMAPPED', 'REG_DWORD', 'IMAGE_FILE_RELOCS_STRIPPED', 'STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD', 'STATUS_PASSWORD_RESTRICTION', 'STATUS_LINK_FAILED', 'JOB_OBJECT_ASSIGN_PROCESS', 'ERROR_OPLOCK_BREAK_IN_PROGRESS', 'STATUS_TRANSACTION_ALREADY_COMMITTED', 'CERT_COMPARE_CROSS_CERT_DIST_POINTS', 'SM_CYSMCAPTION', 'STATUS_SERVER_SID_MISMATCH', 'RPC_NT_SERVER_TOO_BUSY', 'CERT_TRUST_IS_NOT_VALID_FOR_USAGE', 'STATUS_NDIS_PAUSED', 'STATUS_INVALID_IMAGE_NE_FORMAT', 'ERROR_ITERATED_DATA_EXCEEDS_64k', 'STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE', 'CERT_STORE_PROV_SMART_CARD', 'SPC_PE_IMAGE_PAGE_HASHES_V1_OBJID', 'DNS_TYPE_MAILA', 'DNS_TYPE_MAILB', 'CMSG_INNER_CONTENT_TYPE_PARAM', 'ERROR_SEEK', 'EXCEPTION_ILLEGAL_INSTRUCTION', 'IMAGE_FILE_EXECUTABLE_IMAGE', 'FILE_ATTRIBUTE_VIRTUAL', 'szOID_RSA_SMIMEalg', 'ERROR_ALREADY_EXISTS', 'STATUS_STOPPED_ON_SYMLINK', 'EVENT_TRACE_FLAG_FORWARD_WMI', 'szOID_INFOSEC_SuiteAKMandSig', 'SE_GROUP_VALID_ATTRIBUTES', 'CERT_FIND_CTL_USAGE', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN', 'STATUS_INVALID_SERVER_STATE', 'STATUS_FWP_NEVER_MATCH', 'ERROR_IS_JOINED', 'STATUS_GRAPHICS_MONITOR_NOT_CONNECTED', 'CONTEXT_I386', 'SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ALL', 'STATUS_TRANSACTIONAL_CONFLICT', 'HKEY_PERFORMANCE_NLSTEXT', 'PROCESS_VM_WRITE', 'ERROR_INVALID_HANDLE', 'SM_CXMAXIMIZED', 'ERROR_INVALID_FUNCTION', 'szOID_INFOSEC_mosaicKMandUpdSig', 'STGM_CONVERT', 'STATUS_IPSEC_SA_LIFETIME_EXPIRED', 'STATUS_TRANSACTION_REQUIRED_PROMOTION', 'RPC_NT_CALL_IN_PROGRESS', 'STATUS_USER_EXISTS', 'CMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAM', 'STATUS_LOG_CONTAINER_STATE_INVALID', 'STATUS_FVE_BAD_DATA', 'STATUS_GRAPHICS_INVALID_ACTIVE_REGION', 'CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES', 'SERVICE_ALL_ACCESS', 'IMAGE_DIRECTORY_ENTRY_GLOBALPTR', 'STATUS_SMARTCARD_SILENT_CONTEXT', 'STATUS_OPLOCK_NOT_GRANTED', 'EVENT_TRACE_FILE_MODE_PREALLOCATE', 'STATUS_INVALID_PARAMETER_12', 'ATM_AESA', 'RPC_E_ACCESS_DENIED', 'IMAGE_FILE_MACHINE_POWERPCFP', 'PROCESS_CREATE_THREAD', 'IMAGE_REL_BASED_MACHINE_SPECIFIC_8', 'STARTF_USEPOSITION', 'CERT_TRUST_IS_REVOKED', 'ERROR_MCA_EXCEPTION', 'COMPRESSION_FORMAT_LZNT1', 'CERT_QUERY_CONTENT_PFX_AND_LOAD', 'ERROR_EVT_FILTER_ALREADYSCOPED', 'REG_NONE', 'STATUS_RESOURCE_REQUIREMENTS_CHANGED', 'STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER', 'SM_CARETBLINKINGENABLED', 'SE_INCREASE_QUOTA_NAME', 'ERROR_EVT_CHANNEL_CANNOT_ACTIVATE', 'SECTION_MAP_EXECUTE_EXPLICIT', 'SM_CYCURSOR', 'STATUS_DFS_UNAVAILABLE', 'SERVICE_ACCEPT_SHUTDOWN', 'SYSTEM_ALARM_ACE_TYPE', 'STATUS_SXS_MANIFEST_FORMAT_ERROR', 'CERT_DESCRIPTION_PROP_ID', 'IMAGE_REL_BASED_HIGHLOW', 'STATUS_TRANSACTIONMANAGER_NOT_ONLINE', 'STATUS_FILE_ENCRYPTED', 'STGFMT_NATIVE', 'STATUS_INVALID_DEVICE_REQUEST', 'ERROR_BAD_REM_ADAP', 'STATUS_ACPI_INVALID_REGION', 'SE_RESTORE_NAME', 'STATUS_DS_INVALID_ATTRIBUTE_SYNTAX', 'szOID_INFOSEC_SuiteATokenProtection', 'STATUS_INVALID_TOKEN', 'FILE_FLAG_RANDOM_ACCESS', 'STATUS_CALLBACK_RETURNED_LANG', 'RPC_NT_FP_DIV_ZERO', 'NTE_NO_MEMORY', 'STATUS_REG_NAT_CONSUMPTION', 'ERROR_EVT_MAX_INSERTS_REACHED', 'SM_CXFIXEDFRAME', 'RPC_NT_NO_CONTEXT_AVAILABLE', 'ERROR_SECURITY_STREAM_IS_INCONSISTENT', 'STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS', 'FILE_WRITE_EA', 'SM_CYEDGE', 'STATUS_UNABLE_TO_DELETE_SECTION', 'CERT_HASH_PROP_ID', 'ERROR_UNEXP_NET_ERR', 'EVENTLOG_SUCCESS', 'CERT_STORE_ADD_USE_EXISTING', 'STGM_DIRECT', 'CRYPT_DELETEKEYSET', 'IMAGE_FILE_LARGE_ADDRESS_AWARE', 'STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY', 'ERROR_EVT_NON_VALIDATING_MSXML', 'STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT', 'OS_SMALLBUSINESSSERVER', 'SERVICE_ACCEPT_NETBINDCHANGE', 'STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS', 'STATUS_RDP_PROTOCOL_ERROR', 'OBJ_INHERIT', 'SM_CYFOCUSBORDER', 'IMAGE_FILE_MACHINE_UNKNOWN', 'PKCS_CONTENT_INFO_SEQUENCE_OF_ANY', 'RPC_C_QOS_CAPABILITIES_ANY_AUTHORITY', 'CRYPT_SGCKEY', 'TOKEN_SOURCE_LENGTH', 'RRF_RT_REG_NONE', 'CERT_QUERY_FORMAT_FLAG_ALL', 'PRODUCT_CORE_N', 'CRYPT_E_AUTH_ATTR_MISSING', 'STATUS_FVE_TPM_INVALID_PCR', 'STATUS_LOG_APPENDED_FLUSH_FAILED', 'DNS_TYPE_GID', 'ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL', 'X509_ENUMERATED', 'STATUS_TOO_MANY_OPENED_FILES', 'STATUS_NDIS_INVALID_DEVICE_REQUEST', 'PROCESS_VM_OPERATION', 'STATUS_UNWIND', 'STATUS_SXS_MANIFEST_TOO_BIG', 'DNS_TYPE_NSEC', 'STATUS_SXS_MULTIPLE_DEACTIVATION', 'STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET', 'STATUS_APPHELP_BLOCK', 'STATUS_CANNOT_LOAD_REGISTRY_FILE', 'ERROR_AUTODATASEG_EXCEEDS_64k', 'ERROR_STACK_OVERFLOW_READ', 'CRYPT_RECIPIENT', 'PRODUCT_STANDARD_SERVER', 'EVENT_HEADER_FLAG_NO_CPUTIME', 'szOID_NIST_AES128_CBC', 'ACCESS_SYSTEM_SECURITY', 'MAILSLOT_WAIT_FOREVER', 'STATUS_HIVE_UNLOADED', 'OS_TERMINALREMOTEADMIN', 'STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED', 'STATUS_NO_TXF_METADATA', 'STATUS_NOTIFY_ENUM_DIR', 'CERT_STORE_PROV_COLLECTION', 'CERT_SYSTEM_STORE_CURRENT_USER', 'STATUS_SMARTCARD_CERT_EXPIRED', 'STATUS_NO_SECURITY_ON_OBJECT', 'STATUS_SXS_WRONG_SECTION_TYPE', 'STATUS_ALL_SIDS_FILTERED', 'ACCESS_MAX_MS_OBJECT_ACE_TYPE', 'szOID_OIWDIR_md2', 'STATUS_REMOTE_FILE_VERSION_MISMATCH', 'SYSTEM_PROCESS_TRUST_NOCONSTRAINT_MASK', 'STATUS_GENERIC_NOT_MAPPED', 'RPC_C_AUTHN_LEVEL_CONNECT', 'STGFMT_STORAGE', 'STATUS_FLOPPY_VOLUME', 'STATUS_FVE_CONV_READ_ERROR', 'ERROR_REGISTRY_IO_FAILED', 'CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE', 'PROFILE_USER', 'STATUS_REDIRECTOR_NOT_STARTED', 'AF_LAT', 'ERROR_INVALID_DATA', 'AT_SIGNATURE', 'RPC_NT_CANT_CREATE_ENDPOINT', 'PRODUCT_HOME_PREMIUM_N', 'PAGE_WRITECOMBINE', 'CERT_AUTHORITY_INFO_ACCESS_PROP_ID', 'PRODUCT_HOME_PREMIUM_E', 'STATUS_DS_OID_NOT_FOUND', 'STATUS_FVE_NOT_ENCRYPTED', 'szOID_OIWSEC_rsaSign', 'OS_WIN95ORGREATER', 'STATUS_FVE_FAILED_SECTOR_SIZE', 'STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE', 'ERROR_IS_SUBSTED', 'SYSTEM_AUDIT_OBJECT_ACE_TYPE', 'UNPROTECTED_DACL_SECURITY_INFORMATION', 'FILE_SYNCHRONOUS_IO_ALERT', 'ALPC_MESSAGE_CONTEXT_ATTRIBUTE', 'STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET', 'STATUS_GRAPHICS_ADAPTER_WAS_RESET', 'STATUS_DIRECTORY_SERVICE_REQUIRED', 'STATUS_RETRY', 'CMSG_ATTR_CERT_PARAM', 'ERROR_VC_DISCONNECTED', 'ALPC_MSGFLG_LPC_MODE', 'STATUS_FWP_TOO_MANY_SUBLAYERS', 'REG_DWORD_BIG_ENDIAN', 'DEBUG_EVENT_CHANGE_ENGINE_STATE', 'ERROR_CANT_WAIT', 'SERVICE_ACCEPT_POWEREVENT', 'SE_DACL_AUTO_INHERIT_REQ', 'STATUS_DS_ADMIN_LIMIT_EXCEEDED', 'SW_SHOW', 'STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL', 'STATUS_MEDIA_CHECK', 'STATUS_FWP_LAYER_NOT_FOUND', 'FILE_OPEN_FOR_BACKUP_INTENT', 'NO_PROPAGATE_INHERIT_ACE', 'STATUS_INVALID_ADDRESS_WILDCARD', 'ERROR_MOD_NOT_FOUND', 'STATUS_GRAPHICS_TOO_MANY_REFERENCES', 'STATUS_TOKEN_ALREADY_IN_USE', 'ERROR_NOT_READY', 'STATUS_ACPI_HANDLER_COLLISION', 'STATUS_GRAPHICS_CANNOTCOLORCONVERT', 'STATUS_TRANSACTION_NOT_ROOT', 'STATUS_CANT_CROSS_RM_BOUNDARY', 'SECURITY_MANDATORY_MEDIUM_PLUS_RID', 'STATUS_GENERIC_COMMAND_FAILED', 'STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET', 'ERROR_DBG_TERMINATE_PROCESS', 'STATUS_BAD_MCFG_TABLE', 'STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER', 'STATUS_FILE_LOCK_CONFLICT', 'SM_CYFIXEDFRAME', 'STATUS_PNP_BAD_MPS_TABLE', 'SE_UNSOLICITED_INPUT_NAME', 'CERT_COMPARE_KEY_SPEC', 'DNS_QUERY_NO_MULTICAST', 'STATUS_ACPI_INVALID_ACCESS_SIZE', 'SM_NETWORK', 'EXCEPTION_CONTINUE_EXECUTION', 'ERROR_FLOAT_MULTIPLE_FAULTS', 'STATUS_ACPI_REG_HANDLER_FAILED', 'ERROR_PWD_TOO_SHORT', 'PRODUCT_SERVER_FOR_SMALLBUSINESS', 'CLUSAPI_READ_ACCESS', 'STARTF_FORCEONFEEDBACK', 'ERROR_TOO_MANY_TCBS', 'STATUS_CSS_KEY_NOT_PRESENT', 'DNS_TYPE_IXFR', 'EVENT_TRACE_FILE_MODE_SEQUENTIAL', 'STATUS_CANT_TERMINATE_SELF', 'STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL', 'RPC_NT_ENUM_VALUE_OUT_OF_RANGE', 'ERROR_IOPL_NOT_ENABLED', 'STATUS_RXACT_STATE_CREATED', 'STATUS_FVE_ACTION_NOT_ALLOWED', 'STATUS_INFO_LENGTH_MISMATCH', 'STATUS_FILEMARK_DETECTED', 'IMAGE_SCN_MEM_PURGEABLE', 'STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY', 'RPC_NT_NO_MORE_MEMBERS', 'STATUS_SUCCESS', 'STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK', 'SE_TAKE_OWNERSHIP_NAME', 'CERT_STORE_ADD_NEWER', 'STATUS_CTX_CDM_DISCONNECT', 'PIPE_REJECT_REMOTE_CLIENTS', 'ERROR_BADKEY', 'ALPC_CANCELFLG_TRY_CANCEL', 'STATUS_LOG_RECORDS_RESERVED_INVALID', 'STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE', 'STATUS_STACK_OVERFLOW_READ', 'CRYPT_EXPORTABLE', 'STATUS_CACHE_PAGE_LOCKED', 'PRODUCT_PROFESSIONAL_WMC', 'PRODUCT_UNLICENSED', 'STATUS_REGISTRY_QUOTA_LIMIT', 'STATUS_FVE_VOLUME_TOO_SMALL', 'RIP_EVENT', 'ERROR_CHECKOUT_REQUIRED', 'AF_IMPLINK', 'PRODUCT_STORAGE_STANDARD_SERVER_CORE', 'ERROR_NO_DATA', 'SYSTEM_PROCESS_TRUST_LABEL_ACE_TYPE', 'IMAGE_DIRECTORY_ENTRY_DEBUG', 'CERT_QUERY_FORMAT_FLAG_BINARY', 'ERROR_NO_GUID_TRANSLATION', 'RPC_NT_CALL_FAILED_DNE', 'ERROR_DYNLINK_FROM_INVALID_RING', 'PROV_RNG', 'CREATE_NO_WINDOW', 'STATUS_TOO_MANY_COMMANDS', 'CERT_TRUST_IS_PARTIAL_CHAIN', 'PROV_RSA_SCHANNEL', 'STATUS_TOO_MANY_ADDRESSES', 'CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG', 'SM_SAMEDISPLAYFORMAT', 'CMSG_CTRL_VERIFY_SIGNATURE', 'STATUS_TIMER_NOT_CANCELED', 'AF_CCITT', 'SERVICE_CONTROL_HARDWAREPROFILECHANGE', 'STATUS_INTERNAL_DB_ERROR', 'TOKEN_QUERY_SOURCE', 'CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR', 'FILE_MAP_WRITE', 'STATUS_NONEXISTENT_EA_ENTRY', 'STATUS_MESSAGE_RETRIEVED', 'X509_CERT_POLICIES', 'IMAGE_REL_BASED_ABSOLUTE', 'DNS_TYPE_X25', 'STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED', 'STATUS_DRIVERS_LEAKING_LOCKED_PAGES', 'STATUS_LOG_READ_CONTEXT_INVALID', 'SM_SHUTTINGDOWN', 'szOID_OIWSEC_sha', 'STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS', 'CERT_SYSTEM_STORE_UNPROTECTED_FLAG', 'SYMBOLIC_LINK_QUERY', 'STATUS_OPLOCK_BREAK_IN_PROGRESS', 'STATUS_ACPI_MUTEX_NOT_OWNED', 'STATUS_TRANSACTION_NOT_ACTIVE', 'CERT_NAME_DNS_TYPE', 'ERROR_MORE_DATA', 'STATUS_SMARTCARD_NO_CERTIFICATE', 'STATUS_CTX_CDM_CONNECT', 'DNS_TYPE_NSAPPTR', 'ERROR_FAILED_DRIVER_ENTRY', 'SE_CHANGE_NOTIFY_NAME', 'DNS_QUERY_USE_TCP_ONLY', 'PKCS_TIME_REQUEST', 'ERROR_ABANDONED_WAIT_0', 'STATUS_REGISTRY_RECOVERED', 'ERROR_WAS_UNLOCKED', 'STATUS_NDIS_BAD_CHARACTERISTICS', 'CRYPT_VERIFYCONTEXT', 'AF_ISO', 'STATUS_CSS_AUTHENTICATION_FAILURE', 'FILE_OPEN', 'TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE', 'STANDARD_RIGHTS_READ', 'STATUS_FWP_DUPLICATE_AUTH_METHOD', 'STATUS_FWP_SESSION_ABORTED', 'DNS_TYPE_AXFR', 'ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY', 'STATUS_BAD_DLL_ENTRYPOINT', 'STATUS_NDIS_REQUEST_ABORTED', 'CERT_SIGNATURE_HASH_PROP_ID', 'DNS_TYPE_NSEC3PARAM', 'CONTEXT_XSTATE', 'SECTION_ALL_ACCESS', 'OS_ADVSERVER', 'ERROR_INVALID_EA_NAME', 'CERT_PUBKEY_HASH_RESERVED_PROP_ID', 'SERVICE_TRIGGER_TYPE_DOMAIN_JOIN', 'CERT_INFO_NOT_AFTER_FLAG', 'REG_BINARY', 'SEC_RESERVE', 'CERT_STORE_PROV_FILENAME', 'MEM_DECOMMIT', 'STATUS_SYSTEM_PROCESS_TERMINATED', 'STATUS_PASSWORD_MUST_CHANGE', 'STATUS_USER_SESSION_DELETED', 'DEBUG_EVENT_BREAKPOINT', 'STATUS_CONNECTION_ACTIVE', 'IMAGE_SCN_MEM_NOT_CACHED', 'ERROR_TIMER_RESOLUTION_NOT_SET', 'EVENT_HEADER_FLAG_EXTENDED_INFO', 'STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED', 'szOID_INFOSEC_mosaicTokenProtection', 'STATUS_SHARED_POLICY', 'NTE_BAD_KEYSET_PARAM', 'STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND', 'RPC_NT_CALL_FAILED', 'SM_SWAPBUTTON', 'SM_DEBUG', 'IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG', 'RPC_NT_PIPE_DISCIPLINE_ERROR', 'PRODUCT_SERVER_FOR_SB_SOLUTIONS', 'STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION', 'STATUS_PKINIT_FAILURE', 'DNS_TYPE_A6', 'EVENT_HEADER_PROPERTY_XML', 'CERT_TRUST_IS_CYCLIC', 'FAX_JOB_QUERY', 'STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET', 'CERT_KEY_IDENTIFIER_PROP_ID', 'STATUS_INVALID_ADDRESS', 'ERROR_WMI_ITEMID_NOT_FOUND', 'OBJ_VALID_ATTRIBUTES', 'STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT', 'ERROR_DS_VERSION_CHECK_FAILURE', 'STATUS_NO_QUOTAS_FOR_ACCOUNT', 'SM_CYICONSPACING', 'PROCESS_TRACE_MODE_RAW_TIMESTAMP', 'RPC_NT_CANNOT_SUPPORT', 'STATUS_SPECIAL_GROUP', 'ERROR_INVALID_DEVICE_OBJECT_PARAMETER', 'CERT_FIND_CERT_ID', 'STATUS_LOG_CONTAINER_LIMIT_EXCEEDED', 'SM_CYICON', 'STATUS_ACCESS_DENIED', 'STATUS_ACCOUNT_DISABLED', 'STATUS_CANT_RECOVER_WITH_HANDLE_OPEN', 'STATUS_NO_SECRETS', 'STATUS_CONNECTION_INVALID', 'STATUS_PAGE_FAULT_DEMAND_ZERO', 'RPC_C_IMP_LEVEL_DEFAULT', 'FILE_WRITE_DATA', 'TOKEN_ASSIGN_PRIMARY', 'STATUS_HASH_NOT_SUPPORTED', 'RPC_NT_STRING_TOO_LONG', 'ERROR_EVT_MESSAGE_ID_NOT_FOUND', 'FILE_UNICODE_ON_DISK', 'CMSG_CTRL_ADD_CERT', 'OS_WIN98_GOLD', 'RPC_C_AUTHN_LEVEL_PKT_PRIVACY', 'CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED', 'szOID_OIWSEC_dsaComm', 'STATUS_DFS_EXIT_PATH_FOUND', 'STGM_READWRITE', 'STATUS_CTX_MODEM_RESPONSE_VOICE', 'REALTIME_PRIORITY_CLASS', 'ACCESS_MAX_MS_ACE_TYPE', 'SM_CXSIZEFRAME', 'ERROR_MUTANT_LIMIT_EXCEEDED', 'STATUS_FWP_INVALID_FLAGS', 'STATUS_FLT_POST_OPERATION_CLEANUP', 'STATUS_IMAGE_CERT_REVOKED', 'PROV_EC_ECNRA_FULL', 'STATUS_DEVICE_UNREACHABLE', 'DEBUG_EVENT_CREATE_THREAD', 'ERROR_BAD_NET_RESP', 'CERT_PVK_FILE_PROP_ID', 'STATUS_REDIRECTOR_PAUSED', 'ERROR_EVT_UNRESOLVED_VALUE_INSERT', 'ASYNC_MODE_DEFAULT', 'SERVICE_TRIGGER_TYPE_GROUP_POLICY', 'STATUS_LOG_DEDICATED', 'ERROR_EXE_CANNOT_MODIFY_SIGNED_BINARY', 'STATUS_SXS_FILE_HASH_MISSING', 'ERROR_REGISTRY_QUOTA_LIMIT', 'STATUS_DIRECTORY_IS_A_REPARSE_POINT', 'RPC_NT_NULL_REF_POINTER', 'EVENT_TRACE_FLAG_REGISTRY', 'NTE_BAD_PROV_TYPE', 'OS_WIN98ORGREATER', 'EVENT_TRACE_FLAG_DISPATCHER', 'ERROR_ARBITRATION_UNHANDLED', 'CMSG_CTRL_DECRYPT', 'STATUS_GRAPHICS_DRIVER_MISMATCH', 'DNS_TYPE_ZERO', 'PRODUCT_BUSINESS_N', 'FILE_EXECUTE', 'PRODUCT_SB_SOLUTION_SERVER_EM', 'SE_TIME_ZONE_NAME', 'ERROR_SHORT_NAMES_NOT_ENABLED_ON_VOLUME', 'CERT_QUERY_CONTENT_FLAG_CERT', 'RPC_NT_UNKNOWN_AUTHN_SERVICE', 'TRUNCATE_EXISTING', 'STATUS_INVALID_PARAMETER_5', 'SM_CXHTHUMB', 'STATUS_INVALID_PARAMETER_7', 'STATUS_INVALID_PARAMETER_6', 'STATUS_INVALID_PARAMETER_1', 'RPC_NT_UNSUPPORTED_TRANS_SYN', 'STATUS_INVALID_PARAMETER_3', 'CERT_KEY_PROV_INFO_PROP_ID', 'STATUS_DIRECTORY_NOT_RM', 'STATUS_FWP_ZERO_LENGTH_ARRAY', 'BIND_IF_SYNTAX_UNKNOWN', 'AF_ECMA', 'ERROR_SYSTEM_TRACE', 'STATUS_CONTEXT_MISMATCH', 'DIRECTORY_CREATE_OBJECT', 'STATUS_RESOURCE_LANG_NOT_FOUND', 'PIPE_ACCEPT_REMOTE_CLIENTS', 'CERT_STORE_CREATE_NEW_FLAG', 'IMAGE_FILE_MACHINE_IA64', 'SW_FORCEMINIMIZE', 'ERROR_VDM_HARD_ERROR', 'STATUS_UNFINISHED_CONTEXT_DELETED', 'ERROR_PRIMARY_TRANSPORT_CONNECT_FAILED', 'SC_MANAGER_CONNECT', 'CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG', 'ERROR_NOTHING_TO_TERMINATE', 'STATUS_WMI_GUID_DISCONNECTED', 'szOID_OIWSEC_md5RSASign', 'STATUS_LPC_INVALID_CONNECTION_USAGE', 'INVALID_HANDLE_VALUE', 'STATUS_UNRECOGNIZED_VOLUME', 'CERT_FIND_SHA1_HASH', 'STATUS_CTX_SHADOW_DISABLED', 'WTD_STATEACTION_AUTO_CACHE_FLUSH', 'STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE', 'PRODUCT_WEB_SERVER_CORE', 'STATUS_FILE_CORRUPT_ERROR', 'STATUS_TRANSLATION_COMPLETE', 'STATUS_GROUP_EXISTS', 'IMAGE_SCN_ALIGN_4BYTES', 'STATUS_GUIDS_EXHAUSTED', 'szOID_OIWSEC_desOFB', 'STATUS_FVE_LOCKED_VOLUME', 'CERT_NEXT_UPDATE_LOCATION_PROP_ID', 'X509_BITS', 'CERT_QUERY_CONTENT_CERT', 'STATUS_RESOURCE_NOT_OWNED', 'CERT_STORE_PROV_SERIALIZED', 'szOID_RSA_RSA', 'SEC_WINNT_AUTH_IDENTITY_ANSI', 'NULL', 'STATUS_SHARING_PAUSED', 'STATUS_CTX_INVALID_WD', 'STATUS_INVALID_USER_PRINCIPAL_NAME', 'SE_GROUP_ENABLED_BY_DEFAULT', 'STATUS_ABANDONED_WAIT_63', 'ERROR_INVALID_LDT_OFFSET', 'FILE_ATTRIBUTE_TEMPORARY', 'ERROR_MP_PROCESSOR_MISMATCH', 'ERROR_BAD_DEV_TYPE', 'FILE_GENERIC_WRITE', 'STATUS_CTX_PD_NOT_FOUND', 'FAX_PORT_SET', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING', 'STATUS_WX86_UNSIMULATE', 'CERT_STORE_PROV_LDAP_W', 'STATUS_NO_SECURITY_CONTEXT', 'EXCEPTION_EXECUTE_HANDLER', 'STATUS_INVALID_THREAD', 'OS_EMBEDDED', 'CMSG_ENCODED_SIGNER', 'STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT', 'STATUS_MEDIA_WRITE_PROTECTED', 'STGM_SHARE_DENY_NONE', 'FILE_NOTIFY_CHANGE_ATTRIBUTES', 'ERROR_EA_FILE_CORRUPT', 'CMSG_CTRL_DEL_ATTR_CERT', 'STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED', 'EVENT_TRACE_CONTROL_FLUSH', 'STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING', 'HKEY_CURRENT_USER', 'CERT_FIND_SUBJECT_STR_W', 'THREAD_SET_CONTEXT', 'ERROR_UNEXPECTED_MM_CREATE_ERR', 'ERROR_BUSY_DRIVE', 'SM_CXMINIMIZED', 'PRODUCT_UNDEFINED', 'SERVICE_QUERY_CONFIG', 'CERT_FIND_SUBJECT_STR_A', 'PRODUCT_STARTER_N', 'OBJ_EXCLUSIVE', 'PRODUCT_STARTER_E', 'ERROR_DISK_TOO_FRAGMENTED', 'WOW64_MAXIMUM_SUPPORTED_EXTENSION', 'SERVICE_ACCEPT_PRESHUTDOWN', 'STATUS_RECURSIVE_DISPATCH', 'DNS_TYPE_WINSR', 'STATUS_INVALID_NETWORK_RESPONSE', 'FILE_ATTRIBUTE_NORMAL', 'TH32CS_SNAPMODULE', 'STATUS_DISK_FULL', 'FILE_NOTIFY_CHANGE_SIZE', 'ERROR_RESOURCE_NAME_NOT_FOUND', 'SM_CYHSCROLL', 'SYNCHRONIZE', 'CERT_COMPARE_PROPERTY', 'ERROR_EVT_FILTER_INVARG', 'TOKEN_ADJUST_DEFAULT', 'STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED', 'STATUS_MUTUAL_AUTHENTICATION_FAILED', 'STATUS_SPECIAL_ACCOUNT', 'STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET', 'SC_MANAGER_LOCK', 'SM_CYMENUCHECK', 'CERT_FIND_KEY_SPEC', 'CERT_CHAIN_REVOCATION_CHECK_CHAIN', 'ERROR_CANTSCROLLBACKWARDS', 'STATUS_CTX_WINSTATION_NOT_FOUND', 'SE_PROF_SINGLE_PROCESS_NAME', 'STATUS_REMOTE_STORAGE_NOT_ACTIVE', 'STATUS_PLUGPLAY_NO_DEVICE', 'NTE_BAD_VER', 'ERROR_WMI_GUID_DISCONNECTED', 'DEBUG_EVENT_LOAD_MODULE', 'SERVICE_CONTROL_INTERROGATE', 'STATUS_INVALID_INFO_CLASS', 'NTE_PROV_DLL_NOT_FOUND', 'STATUS_UNMAPPABLE_CHARACTER', 'RPC_NT_BINDING_HAS_NO_AUTH', 'STATUS_ALREADY_DISCONNECTED', 'ERROR_NO_LOG_SPACE', 'CERT_FIND_ISSUER_STR', 'EVENT_TRACE_FLAG_ENABLE_RESERVE', 'STATUS_NETWORK_CREDENTIAL_CONFLICT', 'STATUS_LOG_RESTART_INVALID', 'ALPC_MSGFLG_WAIT_ALERTABLE', 'STATUS_FWP_INVALID_INTERVAL', 'STATUS_CTX_MODEM_RESPONSE_NO_CARRIER', 'STATUS_DEVICE_BUSY', 'ERROR_PAGE_FAULT_GUARD_PAGE', 'ALPC_CANCELFLG_NO_CONTEXT_CHECK', 'SERVICE_INACTIVE', 'STATUS_ND_QUEUE_OVERFLOW', 'STATUS_TOO_MANY_LINKS', 'STATUS_LOG_CLIENT_ALREADY_REGISTERED', 'STATUS_ILLEGAL_FLOAT_CONTEXT', 'ERROR_CANNOT_COPY', 'STATUS_NO_USER_KEYS', 'COMPRESSION_FORMAT_XPRESS', 'STATUS_LOG_FULL_HANDLER_IN_PROGRESS', 'STATUS_TRANSACTION_INVALID_ID', 'SERVICE_WIN32_SHARE_PROCESS', 'STATUS_VOLUME_NOT_UPGRADED', 'BG_NOTIFY_FILE_TRANSFERRED', 'CRYPT_ONLINE', 'CMSG_CTRL_ADD_SIGNER', 'PIPE_ACCESS_DUPLEX', 'ERROR_OPLOCK_HANDLE_CLOSED', 'CERT_E_ISSUERCHAINING', 'STATUS_RESOURCE_TYPE_NOT_FOUND', 'STATUS_WX86_EXCEPTION_CONTINUE', 'STATUS_STRONG_CRYPTO_NOT_SUPPORTED', 'STATUS_BAD_CURRENT_DIRECTORY', 'STATUS_GRAPHICS_OPM_INVALID_SRM', 'BACKUP_SECURITY_INFORMATION', 'STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON', 'STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER', 'STATUS_BACKUP_CONTROLLER', 'STATUS_FREE_VM_NOT_AT_BASE', 'SM_SHOWSOUNDS', 'PRODUCT_HOME_BASIC_E', 'OS_WINDOWS', 'szOID_RSA_PSPECIFIED', 'ERROR_IMAGE_MACHINE_TYPE_MISMATCH_EXE', 'PRODUCT_HOME_BASIC_N', 'STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED', 'STATUS_STACK_BUFFER_OVERRUN', 'STATUS_JOURNAL_NOT_ACTIVE', 'ERROR_MR_MID_NOT_FOUND', 'ERROR_SUCCESS', 'SW_MAX', 'STATUS_SMARTCARD_CERT_REVOKED', 'ERROR_CANNOT_GRANT_REQUESTED_OPLOCK', 'SM_CYMENU', 'FILE_CASE_PRESERVED_NAMES', 'STATUS_BAD_IMPERSONATION_LEVEL', 'STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED', 'STATUS_LOG_SPACE_RESERVED_INVALID', 'STATUS_PORT_CLOSED', 'STATUS_UNKNOWN_REVISION', 'ERROR_EVT_VERSION_TOO_OLD', 'PRODUCT_CLUSTER_SERVER', 'STATUS_SAM_INIT_FAILURE', 'szOID_RSA_hashedData', 'STATUS_INVALID_IDN_NORMALIZATION', 'ERROR_ALERTED', 'RPC_NT_NO_ENDPOINT_FOUND', 'STATUS_HARDWARE_MEMORY_ERROR', 'STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT', 'STATUS_TS_INCOMPATIBLE_SESSIONS', 'STATUS_NO_YIELD_PERFORMED', 'STATUS_DEVICE_REMOVED', 'SYMSEARCH_MASKOBJS', 'ERROR_INVALID_NAME', 'STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED', 'STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA', 'CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64', 'RPC_NT_INVALID_AUTH_IDENTITY', 'szOID_INFOSEC_sdnsKeyManagement', 'STATUS_FWP_INJECT_HANDLE_CLOSING', 'STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER', 'STATUS_FWP_INCOMPATIBLE_DH_GROUP', 'RPC_C_IMP_LEVEL_DELEGATE', 'PERSIST_E_SIZEINDEFINITE', 'szOID_ENHANCED_HASH', 'X509_UNICODE_NAME', 'ERROR_WRONG_DISK', 'STATUS_FVE_RAW_BLOCKED', 'STATUS_ENCOUNTERED_WRITE_IN_PROGRESS', 'STATUS_DS_GC_NOT_AVAILABLE', 'RPC_NT_NOT_LISTENING', 'SM_MEDIACENTER', 'CERT_ACCESS_STATE_PROP_ID', 'STATUS_LOG_BLOCK_INVALID', 'ERROR_WAIT_NO_CHILDREN', 'CERT_NAME_ISSUER_FLAG', 'PRODUCT_DATACENTER_SERVER_V', 'PROCESS_QUERY_INFORMATION', 'szOID_DH_SINGLE_PASS_STDDH_SHA1_KDF', 'STATUS_ADDRESS_CLOSED', 'FILE_ALL_ACCESS', 'STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT', 'IMAGE_FILE_MACHINE_THUMB', 'STATUS_FVE_FAILED_WRONG_FS', 'OS_SERVER', 'ERROR_ARITHMETIC_OVERFLOW', 'STATUS_PROCEDURE_NOT_FOUND', 'PRODUCT_MEDIUMBUSINESS_SERVER_MANAGEMENT', 'SYSTEM_ALARM_CALLBACK_ACE_TYPE', 'STATUS_FULLSCREEN_MODE', 'PRODUCT_STANDARD_SERVER_SOLUTIONS', 'X509_ASN_ENCODING', 'ERROR_UNDEFINED_CHARACTER', 'NTE_BAD_LEN', 'CERT_FIND_ENHKEY_USAGE', 'STATUS_FILE_DELETED', 'OBJECT_TYPE_ALL_ACCESS', 'FILE_TRAVERSE', 'STATUS_NO_USER_SESSION_KEY', 'CERT_QUERY_CONTENT_SERIALIZED_CERT', 'szOID_RSA_SETOAEP_RSA', 'ERROR_NOT_DOS_DISK', 'szOID_NIST_AES128_WRAP', 'CERT_STORE_PROV_SYSTEM_REGISTRY_W', 'ERROR_NEGATIVE_SEEK', 'CRYPT_MACHINE_KEYSET', 'STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA', 'CERT_FIND_SUBJECT_STR', 'STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY', 'WOW64_SIZE_OF_80387_REGISTERS', 'RRF_RT_REG_MULTI_SZ', 'CERT_STORE_PROV_SMART_CARD_W', 'HKEY_PERFORMANCE_DATA', 'IMAGE_FILE_MACHINE_POWERPC', 'DRIVE_REMOTE', 'STATUS_WX86_EXCEPTION_LASTCHANCE', 'SE_RM_CONTROL_VALID', 'STATUS_GRAPHICS_PRESENT_UNOCCLUDED', 'ERROR_NOTIFICATION_GUID_ALREADY_DEFINED', 'szOID_ANSI_X942_DH', 'SERVICE_CONTROL_NETBINDDISABLE', 'FAX_CONFIG_QUERY', 'STATUS_NO_EAS_ON_FILE', 'SEC_WINNT_AUTH_IDENTITY_UNICODE', 'THREAD_SET_INFORMATION', 'PROTECTED_SACL_SECURITY_INFORMATION', 'STATUS_FWP_TRAFFIC_MISMATCH', 'STATUS_TOO_MANY_PRINCIPALS', 'CERT_CROSS_CERT_DIST_POINTS_PROP_ID', 'PROV_EC_ECDSA_SIG', 'STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED', 'STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT', 'STATUS_NOTIFICATION_GUID_ALREADY_DEFINED', 'FILE_COMPLETE_IF_OPLOCKED', 'CERT_SYSTEM_STORE_SERVICES_ID', 'ERROR_DISK_REPAIR_DISABLED', 'CERT_STORE_MANIFOLD_FLAG', 'STATUS_BAD_FILE_TYPE', 'STATUS_CLUSTER_INVALID_NODE', 'API_SET_RELEASE_SCHEMA_ORDINAL', 'STATUS_LOG_CANT_DELETE', 'STATUS_SHARING_VIOLATION', 'IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE', 'CERT_QUERY_CONTENT_FLAG_CTL', 'STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE', 'SYMSEARCH_ALLITEMS', 'SE_LOAD_DRIVER_NAME', 'STD_ERROR_HANDLE', 'PROV_EC_ECNRA_SIG', 'STATUS_PWD_TOO_RECENT', 'PROCESS_SUSPEND_RESUME', 'EVENTLOG_BACKWARDS_READ', 'szOID_RSA_SMIMEalgESDH', 'STATUS_NDIS_ADAPTER_NOT_FOUND', 'STATUS_OBJECT_NO_LONGER_EXISTS', 'STATUS_NETWORK_NAME_DELETED', 'EVENT_HEADER_PROPERTY_LEGACY_EVENTLOG', 'STATUS_GRAPHICS_LEADLINK_START_DEFERRED', 'STATUS_NETWORK_BUSY', 'IMAGE_FILE_MACHINE_ALPHA', 'STATUS_DLL_NOT_FOUND', 'STATUS_INVALID_UNWIND_TARGET', 'STATUS_GRAPHICS_INTERNAL_ERROR', 'STATUS_TXF_ATTRIBUTE_CORRUPT', 'FILE_READ_EA', 'STATUS_REVISION_MISMATCH', 'RPC_NT_INVALID_TIMEOUT', 'STATUS_INVALID_ADDRESS_COMPONENT', 'PRODUCT_SERVER_FOUNDATION', 'STATUS_GRAPHICS_PRESENT_MODE_CHANGED', 'STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE', 'STGTY_REPEAT', 'ERROR_CANNOT_LOAD_REGISTRY_FILE', 'STATUS_NDIS_NOT_SUPPORTED', 'STATUS_ACPI_INVALID_EVENTTYPE', 'FILE_CREATED', 'ERROR_KERNEL_APC', 'SERVICE_SYSTEM_START', 'STATUS_DEVICE_REQUIRES_CLEANING', 'ERROR_VIRUS_INFECTED', 'IMAGE_FILE_MACHINE_AXP64', 'STGM_SHARE_EXCLUSIVE', 'STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY', 'STATUS_PKINIT_CLIENT_FAILURE', 'IMAGE_SCN_ALIGN_2048BYTES', 'ERROR_IS_JOIN_PATH', 'STATUS_CLUSTER_NODE_NOT_PAUSED', 'szOID_X957_DSA', 'ERROR_DLL_MIGHT_BE_INCOMPATIBLE', 'STATUS_VOLMGR_RAID5_NOT_SUPPORTED', 'STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP', 'ERROR_SEEK_ON_DEVICE', 'CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG', 'STATUS_NOT_CLIENT_SESSION', 'STATUS_HUNG_DISPLAY_DRIVER_THREAD', 'STATUS_CLUSTER_NETWORK_ALREADY_ONLINE', 'RRF_NOEXPAND', 'STATUS_NDIS_RESOURCE_CONFLICT', 'ERROR_BAD_DLL_ENTRYPOINT', 'IMAGE_FILE_MACHINE_SH4', 'DNS_TYPE_EID', 'IMAGE_FILE_MACHINE_SH3', 'ERROR_PROCESS_MODE_NOT_BACKGROUND', 'ERROR_INVALID_CATEGORY', 'SECURITY_MANDATORY_MEDIUM_RID', 'CRYPT_ACQUIRE_CACHE_FLAG', 'CRYPT_PREGEN', 'STATUS_NT_CROSS_ENCRYPTION_REQUIRED', 'PKCS12_EXPORT_RESERVED_MASK', 'STATUS_FWP_PROVIDER_CONTEXT_MISMATCH', 'STATUS_DS_CANT_MOD_PRIMARYGROUPID', 'CERT_STORE_ADD_NEW', 'ERROR_RECEIVE_PARTIAL_EXPEDITED', 'SW_SHOWMINNOACTIVE', 'TH32CS_SNAPMODULE32', 'STGM_NOSNAPSHOT', 'STATUS_NULL_LM_PASSWORD', 'STATUS_FVE_RAW_ACCESS', 'RPC_S_PROCNUM_OUT_OF_RANGE', 'IMAGE_DIRECTORY_ENTRY_IMPORT', 'CERT_E_CHAINING', 'ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND', 'CREATE_PROTECTED_PROCESS', 'ERROR_NO_MORE_ITEMS', 'RPC_NT_WRONG_KIND_OF_BINDING', 'CAT_NAMEVALUE_OBJID', 'STATUS_UNABLE_TO_FREE_VM', 'STATUS_FVE_CONV_RECOVERY_FAILED', 'ERROR_FOUND_OUT_OF_SCOPE']) +structs = set(['PFILE_ALIGNMENT_INFORMATION', 'DNS_PTR_DATAW', 'PACCESS_DENIED_CALLBACK_ACE', '_CLAIM_SECURITY_ATTRIBUTE_V1_UNION', 'CERT_INFO', 'MIB_UDPTABLE_OWNER_PID', '_FILE_FS_LABEL_INFORMATION', 'CRYPT_KEY_PROV_PARAM', 'DNS_RECORD_FLAGS', '_FILE_STREAM_INFORMATION', '_DEBUG_STACK_FRAME', 'LPEXCEPTION_DEBUG_INFO', '__tagVARIANT', 'FILE_ATTRIBUTE_TAG_INFORMATION', 'PDNS_LOC_DATA', 'PDNS_SOA_DATAA', '_TOKEN_SOURCE', 'CURDIR', '_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO', 'PDNS_SOA_DATAW', 'IP_ADAPTER_INDEX_MAP', 'PRTL_UNLOAD_EVENT_TRACE64', '_ALPC_PORT_ATTRIBUTES64', 'tagTYPEDESC', 'PRTL_RELATIVE_NAME_U', 'LOAD_DLL_DEBUG_INFO', 'PCERT_RDN_VALUE_BLOB', 'PPSAPI_WORKING_SET_EX_INFORMATION', 'PCRYPT_ENCRYPT_MESSAGE_PARA', 'API_SET_NAMESPACE_ARRAY_V4', 'TOKEN_ORIGIN', 'CMSG_ENVELOPED_ENCODE_INFO', 'PALPC_DIRECT_ATTR64', 'GUID', 'LPIDLDESC', 'PDNS_DNSKEY_DATA', 'PUNICODE_STRING', 'CERT_TRUST_LIST_INFO', 'PFILE_FULL_EA_INFORMATION', 'SERVICE_STATUS_PROCESS', 'CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO', 'PIMAGE_OPTIONAL_HEADER32', 'WINTRUST_CERT_INFO_', '_TOKEN_SECURITY_ATTRIBUTES_INFORMATION', '_CMSG_SIGNER_INFO', 'MIB_TCP6ROW_OWNER_PID', '_DEBUG_SYMBOL_ENTRY', 'LPCONTEXT64', 'ALPC_SERVER_INFORMATION_TMP_OUT', 'PFILE_ALL_INFORMATION', 'PDEBUG_PROCESSOR_IDENTIFICATION_ALL', '_DnsRecordA', 'PFILE_FS_DEVICE_INFORMATION', '_MIB_TCP6ROW_OWNER_PID', 'PPROCESS_MEMORY_COUNTERS', 'SID_AND_ATTRIBUTES_HASH', '_FILE_NAME_INFORMATION', 'PACE_HEADER', '_DnsRecordW', '_DEBUG_OFFSET_REGION', 'PROCESS_BASIC_INFORMATION', 'PDEBUG_SYMBOL_SOURCE_ENTRY', 'OSVERSIONINFOW', 'LPSECURITY_ATTRIBUTES', 'MIDL_XmitDefs_0001', 'OSVERSIONINFOA', 'EXCEPTION_POINTERS64', '_PSAPI_WORKING_SET_BLOCK64', 'ACCESS_ALLOWED_OBJECT_ACE', '_KEY_VALUE_PARTIAL_INFORMATION', 'DEBUG_LAST_EVENT_INFO_EXIT_THREAD', 'PMIB_IFROW', 'LPLOAD_DLL_DEBUG_INFO', '_ALPC_WORK_ON_BEHALF_ATTR', 'PSIP_INDIRECT_DATA', 'PEVENT_HEADER', 'PFILE_FS_SIZE_INFORMATION', 'FILE_BASIC_INFORMATION', 'PROCESS_MITIGATION_DYNAMIC_CODE_POLICY', 'COMVERSION', 'CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', 'PDNS_WINSR_DATAW', '_JIT_DEBUG_INFO', '_DEBUG_EVENT', 'PTOKEN_STATISTICS', 'EVT_VARIANT', 'PMIB_UDPROW_OWNER_PID', 'PTOKEN_PRIMARY_GROUP', 'MULTI_QI', 'LPEXIT_THREAD_DEBUG_INFO', 'WINTRUST_BLOB_INFO', 'PUBLIC_OBJECT_BASIC_INFORMATION', 'RTL_RELATIVE_NAME_U', '_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY', '_DEBUG_SPECIFIC_FILTER_PARAMETERS', '_CRL_ENTRY', 'BITMAPCOREINFO', 'FILE_FULL_EA_INFORMATION', '_TOKEN_PRIMARY_GROUP', '_TMP_signscale', 'FILE_STANDARD_INFORMATION', 'PSYSTEM_RESOURCE_ATTRIBUTE_ACE', '_ALPC_DIRECT_ATTR32', 'PMIB_TCPTABLE_OWNER_PID', 'PCLAIM_SECURITY_ATTRIBUTES_INFORMATION', 'REFIID', 'WNODE_HEADER', 'PFILE_IS_REMOTE_DEVICE_INFORMATION', 'PDNS_MX_DATAW', 'PFILE_FS_ATTRIBUTE_INFORMATION', '_CRYPT_HASH_MESSAGE_PARA', 'PALPC_SECURITY_ATTR64', 'PALPC_HANDLE_ATTR32', 'PDNS_MX_DATAA', 'PIMAGE_EXPORT_DIRECTORY', 'PORT_VIEW', '_TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', 'DISPPARAMS', '_LOCALTHIS', 'LPTYPEATTR', 'FILE_IO_PRIORITY_HINT_INFORMATION', 'CRYPT_DIGEST_BLOB', '_TIME_ZONE_INFORMATION', 'tagBITMAPINFOHEADER', 'tagORPCTHIS', 'PDEBUG_PROCESSOR_IDENTIFICATION_ARM', 'TOKEN_GROUPS_AND_PRIVILEGES', '_IMAGE_BASE_RELOCATION', 'PDNS_OPT_DATA', 'PSYSTEM_HANDLE_INFORMATION64', 'SECURITY_DESCRIPTOR', 'LPBITMAPCOREINFO', 'CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION', 'PIMAGE_SECTION_HEADER', 'DNS_NXT_DATAW', 'SYSTEM_MANDATORY_LABEL_ACE', 'IMAGE_IMPORT_BY_NAME', 'STARTUPINFOEXW', '_CRYPT_KEY_PROV_PARAM', 'PEVENT_DESCRIPTOR', 'TOKEN_STATISTICS', '_IMAGE_NT_HEADERS', 'PFILE_STANDARD_INFORMATION', 'PFILE_ACCESS_INFORMATION', 'DNS_NXT_DATAA', 'PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY', 'TOKEN_PRIVILEGES', '_RPC_IF_ID', 'COAUTHINFO', 'PACCESS_DENIED_OBJECT_ACE', 'PIMAGE_BASE_RELOCATION', 'tagVARDESC', '_WNODE_HEADER', '_CLIENT_ID32', 'PEVENT_TRACE', '_TMPUNION_CERT_ID', 'PPSAPI_WORKING_SET_INFORMATION32', 'PCTL_CONTEXT', 'KEY_VALUE_FULL_INFORMATION', 'PCERT_KEY_CONTEXT', 'REFCLSID', '_SECURITY_ATTRIBUTES', 'LSA_UNICODE_STRING', 'PCRYPT_UINT_BLOB', 'PPORT_MESSAGE64', '_SYMBOL_INFO', 'LPSYSTEMTIME', 'IID', 'TRACE_LOGFILE_HEADER', 'PCRYPT_BIT_BLOB', 'PRTLP_CURDIR_REF', 'PSPC_LINK', '_PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION', '_RIP_INFO', 'PTOKEN_DEFAULT_DACL', 'DNS_DNSKEY_DATA', 'PPRIVILEGE_SET', '_OSVERSIONINFOEXW', '_ALPC_SECURITY_ATTR32', '_CREATE_PROCESS_DEBUG_INFO', 'PDEBUG_MODULE_PARAMETERS', 'IO_STATUS_BLOCK', 'PCURDIR', 'EXIT_THREAD_DEBUG_INFO', 'PSID_AND_ATTRIBUTES', 'ALPC_SECURITY_ATTR32', 'PIMAGEHLP_MODULE64', '_CLAIM_SECURITY_ATTRIBUTE_V1', 'ALPC_DATA_VIEW_ATTR32', 'API_SET_NAMESPACE_ENTRY_V6', '_API_SET_VALUE_ARRAY_V4', 'API_SET_NAMESPACE_ENTRY_V4', '_EVT_VARIANT', 'PKEY_VALUE_FULL_INFORMATION', 'PFILE_FS_LABEL_INFORMATION', 'PCRYPT_KEY_VERIFY_MESSAGE_PARA', '_TMP_UNION_DEBUG_INFO', 'PFILE_IO_PRIORITY_HINT_INFORMATION', 'PCERT_CHAIN_ELEMENT', 'PSYSTEM_MODULE32', 'PMEMORY_BASIC_INFORMATION32', 'PAPI_SET_NAMESPACE_ARRAY_V4', 'PAPI_SET_NAMESPACE_ARRAY_V2', 'PPROCESS_INSTRUMENTATION_CALLBACK_INFORMATION', '_PSAPI_WORKING_SET_INFORMATION64', 'PROCESS_MEMORY_COUNTERS', 'PBITMAPINFOHEADER', 'LPCREATE_THREAD_DEBUG_INFO', 'PCRYPT_DER_BLOB', 'tagTHREADENTRY32', 'DNS_TXT_DATAA', 'PCTL_USAGE', 'PENABLE_TRACE_PARAMETERS', '_SYSTEM_HANDLE64', 'PFILE_FS_SECTOR_SIZE_INFORMATION', '_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO', 'PEVENT_TRACE_PROPERTIES', 'CERT_RDN_VALUE_BLOB', 'DNS_AAAA_DATA', 'DNS_TXT_DATAW', 'PALPC_CONTEXT_ATTR64', 'DNS_SOA_DATAW', '_SYSTEM_MODULE_INFORMATION32', 'CERT_ENHKEY_USAGE', 'SYSTEM_HANDLE_INFORMATION', 'PCRYPT_INTEGER_BLOB', 'PSAPI_WORKING_SET_BLOCK', 'DNS_SOA_DATAA', 'PRGBTRIPLE', '_SYSTEM_ALARM_OBJECT_ACE', 'IMAGE_NT_HEADERS64', 'PFILE_FS_FULL_SIZE_INFORMATION', 'CREATE_THREAD_DEBUG_INFO', 'tagPARAMDESCEX', '_PORT_MESSAGE_TMP_UNION_U2', 'PBITMAPCOREINFO', '_TMP_UNION_IO_STATUS_BLOCK', 'PRTL_OSVERSIONINFOEXW', 'BG_JOB_TIMES', '_SYSTEM_VERIFIER_INFORMATION', 'RPC_IF_ID', '_CONTEXT32', '_PORT_MESSAGE64', '_EXCEPTION_POINTERS32', 'DNS_SRV_DATAA', 'PDNS_SIG_DATAW', '_TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', 'PALPC_DATA_VIEW_ATTR64', 'PMIB_UDPTABLE_OWNER_PID', '_TOKEN_SECURITY_ATTRIBUTE_V1_UNION', 'PDNS_SIG_DATAA', 'SYSTEM_MODULE32', 'DNS_SRV_DATAW', '_ACCESS_DENIED_ACE', '_DEBUG_EXCEPTION_FILTER_PARAMETERS', 'CERT_STRONG_SIGN_PARA', '_TOKEN_ELEVATION', '_GUID', 'PDNS_UNKNOWN_DATA', 'PCERT_REVOCATION_INFO', 'PACL', 'PKEY_VALUE_BASIC_INFORMATION', 'SIP_INDIRECT_DATA_', '_IP_INTERFACE_INFO', '_MIB_TCPROW', '_BG_FILE_RANGE', 'PCRYPTCATMEMBER', '_PORT_MESSAGE_TMP_SUBSTRUCT_S2', 'RTL_OSVERSIONINFOW', '_STARTUPINFOEXW', '_ALPC_DATA_VIEW_ATTR64', 'PFILE_FS_VOLUME_INFORMATION', '_STARTUPINFOEXA', 'OBJECT_DIRECTORY_INFORMATION', 'FUNCDESC', '_TOKEN_MANDATORY_LABEL', 'CLIENT_ID64', '_MIB_UDPTABLE_OWNER_PID', 'CERT_USAGE_MATCH', 'PMODLOAD_DATA', 'SYSTEM_MODULE_INFORMATION32', '__MIDL_IBackgroundCopyJob2_0003', '__MIDL_IBackgroundCopyJob2_0004', '_API_SET_NAMESPACE_V6', 'DEBUG_PROCESSOR_IDENTIFICATION_X86', 'TMPUNION_CMSG_CTRL_DECRYPT_PARA', 'PSYSTEM_ALARM_CALLBACK_OBJECT_ACE', 'PIMAGE_DATA_DIRECTORY', 'PPSAPI_WORKING_SET_EX_BLOCK32', '_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION', '_TOKEN_ORIGIN', '_ALPC_HANDLE_ATTR64', 'REMOTE_PORT_VIEW', '_MIB_TCP6TABLE_OWNER_PID', '_CLIENT_ID', '_API_SET_NAMESPACE_ENTRY', 'tagVS_FIXEDFILEINFO', 'DNS_CACHE_ENTRY', 'POBJECT_DIRECTORY_INFORMATION', '_CERT_KEY_CONTEXT', '_ENUM_SERVICE_STATUS_PROCESSA', 'LPVARIANT', 'DNS_NSEC3_DATA', 'DECIMAL', 'SID_AND_ATTRIBUTES', '_ACL', 'EXCEPTION_RECORD64', 'PTRACE_GUID_INFO', '_ENUM_SERVICE_STATUS_PROCESSW', 'SYMBOL_INFO', '_CERT_INFO', '_CRYPT_KEY_PROV_INFO', 'PSYSTEM_MODULE_INFORMATION64', 'DNS_NAPTR_DATAW', '_LUID_AND_ATTRIBUTES', 'PALPC_SECURITY_ATTR', 'DNS_TKEY_DATAA', 'DNS_NAPTR_DATAA', 'PCRYPT_DIGEST_BLOB', 'PDNS_NSEC3PARAM_DATA', 'WINTRUST_CATALOG_INFO', 'PPROCESS_MITIGATION_ASLR_POLICY', 'DNS_TKEY_DATAW', '_FILE_GET_EA_INFORMATION', 'SECURITY_QUALITY_OF_SERVICE', '_ALPC_HANDLE_ATTR', 'PRLIST_ENTRY', 'POSVERSIONINFOA', '_CERT_SIMPLE_CHAIN', 'LUID', 'CLIENT_ID', 'IMAGE_OPTIONAL_HEADER64', 'tagRGBTRIPLE', '_PSAPI_WORKING_SET_EX_BLOCK64', '_CERT_CHAIN_ENGINE_CONFIG', 'POSVERSIONINFOW', 'TMP_SPC_LINK_UNION', '_IMAGE_FILE_HEADER', 'API_SET_VALUE_ARRAY_V2', 'FILE_MODE_INFORMATION', 'CRYPT_ATTRIBUTE_TYPE_VALUE', 'ALPC_HANDLE_ATTR32', '_CMSG_RECIPIENT_ENCODE_INFO', 'PDNS_CACHE_ENTRY', 'PLSA_UNICODE_STRING', '_CTL_INFO', '_ALPC_DIRECT_ATTR', '_FILE_FS_SIZE_INFORMATION', '_CALLFRAME_MARSHALCONTEXT', 'STRING', 'LPSAFEARRAYBOUND', 'ALPC_WORK_ON_BEHALF_ATTR', 'PCONTEXT32', 'PDNS_NAPTR_DATAW', 'PFILE_GET_EA_INFORMATION', 'PMIB_UDP6ROW_OWNER_PID', 'BITMAPCOREHEADER', 'PALPC_MESSAGE_ATTRIBUTES', 'PDNS_NAPTR_DATAA', '_CRL_INFO', 'EVENT_TRACE_HEADER', 'tagELEMDESC', 'CERT_EXTENSIONS', '_OBJECT_DIRECTORY_INFORMATION', '_WOW64_FLOATING_SAVE_AREA', 'LPBITMAPINFOHEADER', 'PALPC_WORK_ON_BEHALF_ATTR', 'PIO_STATUS_BLOCK', 'SYSTEM_PROCESS_TRUST_LABEL_ACE', 'LPSTARTUPINFOW', 'PTOKEN_ORIGIN', 'PEVENTLOGRECORD', '_FILE_MODE_INFORMATION', 'PM128A', 'TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION', 'PDNS_WKS_DATA', 'LPSTARTUPINFOA', 'LPPARAMDESC', '_CERT_STRONG_SIGN_SERIALIZED_INFO', 'FILE_EA_INFORMATION', '_FILE_FS_ATTRIBUTE_INFORMATION', 'DEBUG_SYMBOL_ENTRY', 'tagTYPEATTR', 'PPROVIDER_ENUMERATION_INFO', 'CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1', 'PFILE_NAME_INFORMATION', '_CRYPT_ATTRIBUTES', '_EXIT_THREAD_DEBUG_INFO', 'PFILE_ATTRIBUTE_TAG_INFORMATION', 'PCERT_PUBLIC_KEY_INFO', '_PROCESS_MITIGATION_IMAGE_LOAD_POLICY', 'PMIB_TCP6TABLE_OWNER_PID', 'PCMSG_RECIPIENT_ENCODE_INFO', 'TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', 'tagMULTI_QI', 'PSECURITY_ATTRIBUTES', 'PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY', 'MEMORY_BASIC_INFORMATION64', '_API_SET_NAMESPACE_ENTRY_V6', 'BITMAPINFO', 'CRYPTCATMEMBER', 'CERT_CONTEXT', 'TMP_DUMMYSTRUCTNAME', 'TOKEN_APPCONTAINER_INFORMATION', 'PDEBUG_LAST_EVENT_INFO_EXIT_THREAD', 'PDNS_PTR_DATAA', 'TOKEN_SECURITY_ATTRIBUTE_V1', 'PSTRING', 'tagSAFEARRAY', 'LPCLSID', '_DEBUG_LAST_EVENT_INFO_LOAD_MODULE', '_CMSG_STREAM_INFO', 'PWOW64_CONTEXT', 'PPROCESS_MITIGATION_DYNAMIC_CODE_POLICY', 'CRYPT_BIT_BLOB', 'ACCESS_ALLOWED_ACE', '_BG_JOB_REPLY_PROGRESS', 'DEBUG_EXCEPTION_FILTER_PARAMETERS', 'PACCESS_ALLOWED_ACE', '_CRYPT_ENCRYPT_MESSAGE_PARA', 'FILE_INTERNAL_INFORMATION', 'FILE_ALL_INFORMATION', 'MIB_TCPROW_OWNER_PID', 'PDNS_KEY_DATA', 'FILE_NETWORK_OPEN_INFORMATION', 'PMIB_TCP6ROW_OWNER_PID', 'PWINTRUST_SGNR_INFO', 'TOKEN_GROUPS', 'PDNS_WINSR_DATAA', 'IMAGE_IMPORT_DESCRIPTOR', 'LPRGBTRIPLE', 'PEXCEPTION_RECORD64', 'CRYPTCATMEMBER_', 'PLUID', 'FILE_STREAM_INFORMATION', '_CERT_EXTENSIONS', 'PIMAGE_IMPORT_BY_NAME', 'SPC_LINK', 'PAPI_SET_VALUE_ENTRY_V2', 'LPSERVICE_STATUS', '_DnsRecordFlags', 'KEY_VALUE_BASIC_INFORMATION', 'ALPC_SECURITY_ATTR', 'CLAIM_SECURITY_ATTRIBUTES_INFORMATION', 'PEXCEPTION_POINTERS32', 'CRYPT_ATTRIBUTE', 'PCRYPT_VERIFY_MESSAGE_PARA', 'CERT_BLOB', 'PEXCEPTION_POINTERS64', 'CERT_SIMPLE_CHAIN', '_RTL_UNLOAD_EVENT_TRACE32', 'PSYSTEMTIME', 'PDEBUG_LAST_EVENT_INFO_EXCEPTION', '_LOAD_DLL_DEBUG_INFO', '_SHITEMID', 'SYSTEM_SCOPED_POLICY_ID_ACE', 'ALPC_CONTEXT_ATTR', 'PCERT_TRUST_STATUS', 'LPVARIANTARG', 'SYSTEM_HANDLE64', 'OUTPUT_DEBUG_STRING_INFO', 'CLSID', 'SYSTEM_AUDIT_ACE', 'IMAGE_BASE_RELOCATION', 'API_SET_NAMESPACE_V6', 'PCLAIM_SECURITY_ATTRIBUTE_V1', '_SERVICE_STATUS', 'FILE_GET_EA_INFORMATION', '_TOKEN_GROUPS_AND_PRIVILEGES', '_FILE_IS_REMOTE_DEVICE_INFORMATION', 'CMSG_SIGNER_INFO', 'PTOKEN_PRIVILEGES', 'PRTL_UNLOAD_EVENT_TRACE32', 'ENUM_SERVICE_STATUS_PROCESSW', '_ALPC_PORT_ATTRIBUTES32', 'PIMAGE_NT_HEADERS64', 'tagPROCESSENTRY32W', 'PBITMAPCOREHEADER', '_PORT_VIEW', 'PCRYPT_ATTRIBUTE', 'IMAGE_EXPORT_DIRECTORY', 'PIP_ADAPTER_INDEX_MAP', '_API_SET_VALUE_ENTRY_V2', 'PIDLIST_ABSOLUTE', '_FILE_INTERNAL_INFORMATION', '_RTL_UNLOAD_EVENT_TRACE64', '_tagVARIANT', 'BG_JOB_PROGRESS', '_SYSTEM_ALARM_ACE', '_PSAPI_WORKING_SET_BLOCK32', 'PDEBUG_STACK_FRAME', 'PCRYPT_OBJID_BLOB', 'CRYPT_ATTR_BLOB', 'M128A', 'CTL_USAGE', 'tagFUNCDESC', '_SYSTEM_AUDIT_CALLBACK_ACE', '_XSAVE_FORMAT_64', 'SYSTEM_ALARM_CALLBACK_OBJECT_ACE', 'PCERT_STRONG_SIGN_PARA', '_RTL_UNLOAD_EVENT_TRACE', 'SIP_INDIRECT_DATA', 'PCCTL_CONTEXT', 'PREMOTE_PORT_VIEW', '_PEB', '_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', 'DNS_RRSIG_DATAW', '_DEBUG_MODULE_AND_ID', '_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY', '_FLOATING_SAVE_AREA', 'DEBUG_SYMBOL_PARAMETERS', 'VARIANT', 'PDNS_RECORDW', 'ENABLE_TRACE_PARAMETERS', 'DNS_RRSIG_DATAA', 'CTL_INFO', 'PDNS_RECORDA', 'PCERT_BLOB', '_ALPC_CONTEXT_ATTR32', '_FILE_STANDARD_INFORMATION', 'PEVENT_HEADER_EXTENDED_DATA_ITEM', 'SYSTEM_AUDIT_OBJECT_ACE', '_PORT_MESSAGE_TMP_UNION_U1', '_PSAPI_WORKING_SET_INFORMATION', 'PEVT_VARIANT', 'CERT_CHAIN_CONTEXT', '_DEBUG_BREAKPOINT_PARAMETERS', 'PTOKEN_MANDATORY_POLICY', 'PSAPI_WORKING_SET_EX_INFORMATION32', '_DEBUG_VALUE', 'PROCESS_MITIGATION_DEP_POLICY', 'PDEBUG_PROCESSOR_IDENTIFICATION_IA64', '_SYSTEM_AUDIT_OBJECT_ACE', 'PORT_MESSAGE32', 'CRYPT_OBJID_BLOB', '_STARTUPINFOA', '_COSERVERINFO', '_EXCEPTION_RECORD64', 'PALPC_SECURITY_ATTR32', '_STARTUPINFOW', 'CLAIM_SECURITY_ATTRIBUTE_V1', 'PPEB_LDR_DATA', 'PDEBUG_SYMBOL_PARAMETERS', 'TRACE_PROVIDER_INFO', 'FILE_FS_SECTOR_SIZE_INFORMATION', 'DEBUG_PROCESSOR_IDENTIFICATION_ARM', 'PALPC_PORT_ATTRIBUTES32', 'IP_INTERFACE_INFO', '_PSAPI_WORKING_SET_EX_INFORMATION32', 'ALPC_CONTEXT_ATTR32', 'RGBQUAD', 'MEMORY_BASIC_INFORMATION', '_ACCESS_ALLOWED_CALLBACK_ACE', 'CRYPT_VERIFY_MESSAGE_PARA', 'EXCEPTION_RECORD', '_DEBUG_PROCESSOR_IDENTIFICATION_AMD64', 'PDEBUG_SYMBOL_ENTRY', 'COAUTHIDENTITY', 'PMIB_IFTABLE', 'PALPC_DATA_VIEW_ATTR', 'PSECURITY_QUALITY_OF_SERVICE', 'PSYSTEM_AUDIT_CALLBACK_ACE', '_CURDIR', 'CERT_REVOCATION_INFO', 'PEB_LDR_DATA', 'LPCGUID', 'ALPC_MESSAGE_ATTRIBUTES', 'RTL_UNLOAD_EVENT_TRACE', 'PSAPI_WORKING_SET_INFORMATION32', '_CLIENT_ID64', 'ACCESS_DENIED_OBJECT_ACE', 'PWINTRUST_BLOB_INFO', '_TOKEN_USER', 'tagIDLDESC', 'tagSAFEARRAYBOUND', 'PTRACE_PROVIDER_INSTANCE_INFO', 'DNS_NSEC3PARAM_DATA', 'PPSAPI_WORKING_SET_EX_INFORMATION64', '_FILE_DISPOSITION_INFORMATION', 'VS_FIXEDFILEINFO', 'EVENT_TRACE_LOGFILEA', 'CALLFRAMEINFO', 'PSAPI_WORKING_SET_EX_BLOCK32', '_TRACE_PROVIDER_INSTANCE_INFO', 'ARRAYDESC', 'PCERT_ISSUER_SERIAL_NUMBER', 'PCTL_ENTRY', 'ALPC_HANDLE_ATTR64', 'MIB_IPADDRTABLE', '_CRYPT_ATTRIBUTE_TYPE_VALUE', 'PMIB_IPADDRROW_XP', 'PACCESS_ALLOWED_CALLBACK_OBJECT_ACE', '_TRACE_GUID_INFO', 'PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY', 'PPROCESS_MITIGATION_DEP_POLICY', 'EXIT_PROCESS_DEBUG_INFO', 'BINDPTR', 'SYSTEM_ALARM_OBJECT_ACE', 'PCERT_EXTENSION', 'WNDCLASSEXW', 'PSYSTEM_MODULE64', 'MIB_UDPROW_OWNER_PID', '_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE', 'PPORT_MESSAGE32', '_CRYPTOAPI_BLOB', '_EVENT_DESCRIPTOR', 'LPBITMAP', 'DNS_WINSR_DATAA', '_TOKEN_GROUPS', 'LPSTARTUPINFOEXW', 'SAFEARRAYBOUND', '__tagBRECORD', 'DNS_WINSR_DATAW', 'ALPC_DIRECT_ATTR32', 'PSID_IDENTIFIER_AUTHORITY', 'tagRGBQUAD', 'EVENTLOG_FULL_INFORMATION', 'POSVERSIONINFOEXA', '_TOKEN_MANDATORY_POLICY', 'LOCALTHIS', 'TOKEN_SECURITY_ATTRIBUTE_V1_UNION', 'SYSTEMTIME', 'tagBITMAPFILEHEADER', 'SPC_SP_OPUS_INFO', '_RTL_DRIVE_LETTER_CURDIR', 'PIMAGE_OPTIONAL_HEADER64', 'IMAGE_SECTION_HEADER', 'ACL', 'WOW64_CONTEXT', '_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY', '_CERT_CHAIN_PARA', 'PACCESS_ALLOWED_CALLBACK_ACE', 'PPROCESS_INFORMATION', 'LPBITMAPINFO', '_CERT_STRONG_SIGN_PARA', '_BG_JOB_TIMES', '_SYSTEM_ALARM_CALLBACK_OBJECT_ACE', 'TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE', 'PCCRL_CONTEXT', 'TMP_lowmid_union', '_SYSTEM_HANDLE', 'CERT_NAME_BLOB', '_ALPC_SECURITY_ATTR64', '_SYSTEM_MODULE_INFORMATION64', '_IMAGE_IMPORT_BY_NAME', 'LPBITMAPCOREHEADER', 'DATA_BLOB', 'PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', 'PCRYPT_KEY_PROV_PARAM', '_TOKEN_SECURITY_ATTRIBUTE_V1', '_BG_FILE_PROGRESS', '_PROCESS_MEMORY_COUNTERS_EX', '_TOKEN_PRIVILEGES', 'PTOKEN_OWNER', '_CERT_EXTENSION', '_IO_STATUS_BLOCK', 'ALPC_TOKEN_ATTR', 'PLUID_AND_ATTRIBUTES', '_TMP_VARDESC_UNION', '_TOKEN_OWNER', 'RIP_INFO', 'FILE_FS_DRIVER_PATH_INFORMATION', '_CONTEXT64', 'DNS_DS_DATA', '_CRYPT_VERIFY_MESSAGE_PARA', 'PTOKEN_LINKED_TOKEN', 'PPORT_VIEW', '_API_SET_VALUE_ENTRY', 'CRYPT_UINT_BLOB', 'TLIBATTR', 'SYSTEM_MODULE64', '_ACE_HEADER', 'tagBITMAPCOREHEADER', 'LPDEBUG_EVENT', 'CRYPT_INTEGER_BLOB', 'PCRL_ENTRY', 'LPENUM_SERVICE_STATUS_PROCESSW', 'PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY', 'PFILETIME', 'PDNS_DS_DATA', '_DEBUG_SYMBOL_SOURCE_ENTRY', 'PRTL_OSVERSIONINFOW', 'tagBITMAPINFO', 'LPENUM_SERVICE_STATUS_PROCESSA', '_KEY_VALUE_BASIC_INFORMATION', 'DNS_LOC_DATA', '_EVENT_TRACE_HEADER', 'TMP_VARDESC_UNION', 'PDNS_SRV_DATAW', 'DEBUG_STACK_FRAME', '_EVENT_RECORD', 'PDNS_SRV_DATAA', 'TMP_UNION_IO_STATUS_BLOCK', 'LPCONTEXT32', 'FILE_POSITION_INFORMATION', '_IMAGE_OPTIONAL_HEADER64', '_COAUTHINFO', '_SID_AND_ATTRIBUTES', 'PCMSG_STREAM_INFO', 'WINTRUST_SGNR_INFO_', 'MIB_IFROW', 'ACE_HEADER', 'PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY', 'PDNS_TLSA_DATA', 'PIMAGE_FILE_HEADER', 'RTL_USER_PROCESS_PARAMETERS', 'FILE_FS_SIZE_INFORMATION', 'tagBITMAP', 'WNDCLASSEXA', '_PROCESS_MITIGATION_DEP_POLICY', 'PDNS_NXT_DATAA', 'PDATA_BLOB', '_IMAGEHLP_MODULE64', 'CERT_ID', 'PDNS_NXT_DATAW', 'PCRYPT_ATTRIBUTE_TYPE_VALUE', 'PCRYPT_ATTRIBUTES', 'PORT_MESSAGE_TMP_UNION', 'FILE_DISPOSITION_INFORMATION', 'DEBUG_PROCESSOR_IDENTIFICATION_IA64', 'CERT_STRONG_SIGN_SERIALIZED_INFO', '_FILE_FS_VOLUME_INFORMATION', 'IDLDESC', 'PSYSTEM_AUDIT_OBJECT_ACE', '_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY', 'PFILE_FS_OBJECTID_INFORMATION', '_CERT_TRUST_LIST_INFO', 'SHITEMID', 'THREAD_BASIC_INFORMATION', '_ALPC_MESSAGE_ATTRIBUTES', 'CMSG_STREAM_INFO', '_MIB_IFTABLE', 'NPRGBTRIPLE', 'LPRIP_INFO', '__PUBLIC_OBJECT_TYPE_INFORMATION', 'FILE_FS_VOLUME_INFORMATION', 'PANSI_STRING', '_PSAPI_WORKING_SET_EX_BLOCK32', 'BG_FILE_RANGE', 'PSYSTEM_PROCESS_TRUST_LABEL_ACE', '_OSVERSIONINFOEXA', '_SYSTEMTIME', '_FILE_IO_PRIORITY_HINT_INFORMATION', 'SERVICE_STATUS', 'PDEBUG_MODULE_AND_ID', '_CERT_REVOCATION_CRL_INFO', 'VARIANTARG', 'PDNS_NSEC_DATAA', 'CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION', '_TRACE_PROVIDER_INFO', '_PROCESS_MITIGATION_ASLR_POLICY', 'WINTRUST_FILE_INFO_', 'API_SET_VALUE_ARRAY_V4', '_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', 'tagBINDPTR', 'PDNS_NSEC_DATAW', 'PSPC_SP_OPUS_INFO', '_IMAGE_OPTIONAL_HEADER', 'XSAVE_FORMAT_32', 'ACCESS_DENIED_ACE', '_SID_AND_ATTRIBUTES_HASH', 'ALPC_PORT_ATTRIBUTES32', 'LPJIT_DEBUG_INFO', 'PXSAVE_FORMAT_32', 'PDEBUG_VALUE', 'PWNODE_HEADER', 'PCCERT_CONTEXT', 'PEVENT_RECORD', '_ALPC_CONTEXT_ATTR', 'WINTRUST_CATALOG_INFO_', '_CERT_CHAIN_ELEMENT', 'BG_FILE_INFO', '_TOKEN_ACCESS_INFORMATION', 'FILE_FS_DEVICE_INFORMATION', 'PFILE_MODE_INFORMATION', '_SYSTEM_HANDLE_INFORMATION64', 'PBITMAPFILEHEADER', '_DEBUG_LAST_EVENT_INFO_EXCEPTION', 'PDEBUG_OFFSET_REGION', 'PFILE_BASIC_INFORMATION', 'CERT_CHAIN_ENGINE_CONFIG', 'PISECURITY_DESCRIPTOR', 'TOKEN_ACCESS_INFORMATION', 'PPROCESS_BASIC_INFORMATION', '_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE', 'PEVENT_FILTER_DESCRIPTOR', 'DNS_UNKNOWN_DATA', '_ALPC_DATA_VIEW_ATTR32', 'DNS_ATMA_DATA', 'STARTUPINFOEXA', 'LPBITMAPFILEHEADER', '_FILETIME', 'FILE_FS_CONTROL_INFORMATION', '_ETW_BUFFER_CONTEXT', 'ACCESS_DENIED_CALLBACK_ACE', 'TOKEN_SECURITY_ATTRIBUTES_INFORMATION', 'PTOKEN_APPCONTAINER_INFORMATION', '_SYSTEM_MODULE64', '_TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', 'DEBUG_VALUE_TMP_UNION', '_TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION', 'WINTRUST_FILE_INFO', 'REFGUID', '_SERVICE_STATUS_PROCESS', 'MIB_IPADDRROW', 'CMSG_CTRL_DECRYPT_PARA', 'PFILE_FS_DRIVER_PATH_INFORMATION', 'LPTIME_ZONE_INFORMATION', '_PSAPI_WORKING_SET_BLOCK', '_CREATE_THREAD_DEBUG_INFO', 'MIB_IPADDRROW_XP', 'DNS_NSEC_DATAW', 'MEMORY_BASIC_INFORMATION32', 'SECURITY_ATTRIBUTES', 'IMAGE_NT_HEADERS32', 'POSVERSIONINFOEXW', 'DNS_NSEC_DATAA', 'PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO', 'MIB_TCPTABLE_OWNER_PID', 'EVENT_TRACE', '_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', 'PTRACE_ENABLE_INFO', 'LPCREATE_PROCESS_DEBUG_INFO', 'TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION', 'ALPC_HANDLE_ATTR', 'PDNS_MINFO_DATAA', 'TOKEN_ELEVATION', '_FILE_FULL_EA_INFORMATION', '_ACCESS_DENIED_OBJECT_ACE', '_ACL_SIZE_INFORMATION', '_ACCESS_ALLOWED_ACE', 'PDNS_DHCID_DATA', 'COSERVERINFO', 'CTL_ENTRY', 'LPFUNCDESC', 'FILE_FS_FULL_SIZE_INFORMATION', 'PCRL_INFO', '_ALPC_TOKEN_ATTR', 'CRYPT_ENCRYPT_MESSAGE_PARA', 'CERT_CHAIN_PARA', 'PALPC_CONTEXT_ATTR', '_DEBUG_PROCESSOR_IDENTIFICATION_X86', 'PALPC_DATA_VIEW_ATTR32', '_DEBUG_PROCESSOR_IDENTIFICATION_ALL', 'LPFILETIME', '_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY', 'PWINTRUST_CERT_INFO', 'PMIB_UDP6TABLE_OWNER_PID', 'CRYPT_DER_BLOB', '_API_SET_NAMESPACE_ARRAY', 'PSPC_SERIALIZED_OBJECT', 'ACCESS_ALLOWED_CALLBACK_OBJECT_ACE', 'PROCESS_MITIGATION_IMAGE_LOAD_POLICY', 'PSYMBOL_INFO', 'BG_FILE_PROGRESS', 'PALPC_DIRECT_ATTR32', 'PCRYPT_ATTR_BLOB', '_TOKEN_STATISTICS', 'PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', 'PDNS_MINFO_DATAW', '_SYSTEM_PROCESS_TRUST_LABEL_ACE', 'PPUBLIC_OBJECT_BASIC_INFORMATION', 'CRYPT_KEY_VERIFY_MESSAGE_PARA', 'PCRL_CONTEXT', 'tagTLIBATTR', 'DNS_TLSA_DATA', 'CLIENT_ID32', 'PALPC_TOKEN_ATTR', 'CRYPTCATATTRIBUTE_', 'ALPC_DIRECT_ATTR', '_API_SET_NAMESPACE_ENTRY_V4', '__MIDL_XmitDefs_0001', 'LPTHREADENTRY32', 'CATALOG_INFO_', 'SAFEARRAY', '_ALPC_SECURITY_ATTR', 'PAPI_SET_NAMESPACE_ENTRY_V2', 'PCANSI_STRING', '_MIB_TCPROW_OWNER_PID', 'PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE', 'PTIME_ZONE_INFORMATION', 'PTOKEN_MANDATORY_LABEL', '_API_SET_NAMESPACE_ENTRY_V2', 'LPELEMDESC', 'EVENT_RECORD', '_IMAGE_NT_HEADERS64', 'PCRYPT_KEY_PROV_INFO', 'TOKEN_DEFAULT_DACL', 'DNS_NULL_DATA', 'DEBUG_LAST_EVENT_INFO_EXCEPTION', 'PDNS_ATMA_DATA', 'PTOKEN_SECURITY_ATTRIBUTE_V1', 'PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY', 'SYSTEM_HANDLE_INFORMATION64', 'RTL_OSVERSIONINFOEXW', 'PMEMORY_BASIC_INFORMATION', 'DNS_WKS_DATA', 'PTRACE_LOGFILE_HEADER', '_IMAGE_DATA_DIRECTORY', 'TMP_UNION_DEBUG_INFO', '_ANON_PEB_SYSTEM_DEPENDENT_03', 'BG_BASIC_CREDENTIALS', 'OBJECT_ATTRIBUTES', 'PCRYPT_DATA_BLOB', '_ANON_PEB_SYSTEM_DEPENDENT_07', 'PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY', '_THREAD_BASIC_INFORMATION', 'EVENT_HEADER_EXTENDED_DATA_ITEM', 'PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE', 'tagWNDCLASSEXA', '_PORT_MESSAGE32_TMP_UNION', '_REMOTE_PORT_VIEW', '_LUID', 'PFILE_INTERNAL_INFORMATION', 'PCRYPT_HASH_MESSAGE_PARA', 'PSYSTEM_HANDLE_INFORMATION', 'DEBUG_OFFSET_REGION', '_EVENTLOGRECORD', 'EXCEPTION_DEBUG_INFO', '_CMSG_ENVELOPED_ENCODE_INFO', 'DNS_KEY_DATA', 'CRYPT_KEY_PROV_INFO', 'PCERT_ENHKEY_USAGE', '_OSVERSIONINFOW', 'PCERT_ID', 'PRTL_USER_PROCESS_PARAMETERS', 'PCRYPTCATATTRIBUTE', 'PAPI_SET_NAMESPACE_ENTRY', 'PSYSTEM_SCOPED_POLICY_ID_ACE', '_CALLFRAMEPARAMINFO', '_OSVERSIONINFOA', 'CERT_REVOCATION_CRL_INFO', 'PBITMAPINFO', '_PROCESS_BASIC_INFORMATION', 'LPSTARTUPINFOEXA', 'PROCESSENTRY32', 'LUID_AND_ATTRIBUTES', '_CERT_USAGE_MATCH', 'ACL_REVISION_INFORMATION', 'tagEXCEPINFO', 'PWINTRUST_FILE_INFO', '_CRYPT_DECRYPT_MESSAGE_PARA', '_MIB_IFROW', 'PCERT_SIMPLE_CHAIN', '_MIB_TCPTABLE_OWNER_PID', '_ACCESS_ALLOWED_OBJECT_ACE', 'PACL_SIZE_INFORMATION', '_MEMORY_BASIC_INFORMATION', 'FILETIME', 'PMIB_TCPROW_OWNER_PID', 'PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY', '_TMPUNION_CMSG_CTRL_DECRYPT_PARA', '_TMP_WINTRUST_UNION_TYPE', 'PTOKEN_SOURCE', 'DNS_WINS_DATA', 'CERT_EXTENSION', '_BG_FILE_INFO', 'DNS_MINFO_DATAA', '_PEB_LDR_DATA', 'PDEBUG_PROCESSOR_IDENTIFICATION_AMD64', '_EVENT_HEADER', 'DNS_MINFO_DATAW', 'CRYPT_ATTRIBUTES', 'CRYPTCATATTRIBUTE', '_RTL_RELATIVE_NAME_U', 'PPSAPI_WORKING_SET_BLOCK64', '_FILE_FS_OBJECTID_INFORMATION', 'DNS_OPT_DATA', '_ANON_TMP_variant_sub_union', 'DNS_RECORDA', 'PCRYPT_DECRYPT_MESSAGE_PARA', '_MODLOAD_DATA', 'PPSAPI_WORKING_SET_INFORMATION64', 'PPROCESS_MITIGATION_IMAGE_LOAD_POLICY', 'DNS_RECORDW', 'ALPC_DATA_VIEW_ATTR64', 'API_SET_VALUE_ENTRY_V2', '_FILE_FS_FULL_SIZE_INFORMATION', 'ALPC_PORT_ATTRIBUTES64', 'CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE', '_OVERLAPPED', 'OVERLAPPED', 'PDEBUG_LAST_EVENT_INFO_EXIT_PROCESS', 'RGBTRIPLE', '_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE', 'FILE_ALIGNMENT_INFORMATION', '_IMAGE_IMPORT_DESCRIPTOR', 'ENUM_SERVICE_STATUS_PROCESSA', 'PSOLE_AUTHENTICATION_SERVICE', '_DEBUG_VALUE_TMP_SUBSTRUCT3', '_DEBUG_VALUE_TMP_SUBSTRUCT2', '_DEBUG_VALUE_TMP_SUBSTRUCT1', 'TMPUNION_CERT_ID', 'TIME_ZONE_INFORMATION', 'tagPROCESSENTRY32', 'LPEVENTLOG_FULL_INFORMATION', '_FILE_ACCESS_INFORMATION', '_PROVIDER_ENUMERATION_INFO', 'PRIVILEGE_SET', 'ETW_BUFFER_CONTEXT', '_EXCEPTION_DEBUG_INFO', '_PROCESS_MEMORY_COUNTERS', 'PCERT_CHAIN_CONTEXT', 'SID_IDENTIFIER_AUTHORITY', 'THREADENTRY32', '_PUBLIC_OBJECT_BASIC_INFORMATION', 'PPSAPI_WORKING_SET_BLOCK32', 'MIB_IFTABLE', '_CERT_ISSUER_SERIAL_NUMBER', 'tagSOLE_AUTHENTICATION_SERVICE', 'ELEMDESC', 'MODLOAD_DATA', 'LPBINDPTR', '_API_SET_VALUE_ARRAY_V2', 'CERT_ISSUER_SERIAL_NUMBER', 'SYSTEM_VERIFIER_INFORMATION', 'PEXCEPTION_RECORD32', 'PAPI_SET_VALUE_ENTRY', 'API_SET_NAMESPACE_ENTRY_V2', 'EVENT_TRACE_PROPERTIES', 'PPROCESSENTRY32W', 'PCRYPT_SIGN_MESSAGE_PARA', '_CERT_CONTEXT', '_ENABLE_TRACE_PARAMETERS', '_MIB_UDPROW_OWNER_PID', '_CRYPT_ENCODE_PARA', 'PSAPI_WORKING_SET_BLOCK32', '_PORT_MESSAGE_TMP_SUBSTRUCT_S1', 'PALPC_DIRECT_ATTR', 'PDEBUG_LAST_EVENT_INFO_SYSTEM_ERROR', 'DEBUG_MODULE_AND_ID', 'DEBUG_LAST_EVENT_INFO_LOAD_MODULE', '_API_SET_NAMESPACE_ARRAY_V4', 'PFILE_STREAM_INFORMATION', 'PDNS_PTR_DATAW', 'PPSAPI_WORKING_SET_INFORMATION', 'LPGUID', 'LPPROCESSENTRY32W', 'PFILE_FS_CONTROL_INFORMATION', 'PLIST_ENTRY', '_ALPC_SERVER_INFORMATION_TMP_OUT', 'TRACE_PROVIDER_INSTANCE_INFO', 'PDNS_AAAA_DATA', 'TOKEN_USER', 'CRL_INFO', '_API_SET_NAMESPACE_ARRAY_V2', 'CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', 'PMIB_IPADDRTABLE', 'PCRL_BLOB', 'PCERT_EXTENSIONS', 'MIB_TCPROW', 'PROCESS_MEMORY_COUNTERS_EX', 'CRYPT_SIGN_MESSAGE_PARA', 'LPOVERLAPPED', 'PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE', '_FILE_BASIC_INFORMATION', 'PACCESS_ALLOWED_OBJECT_ACE', '_CRL_CONTEXT', 'PDEBUG_LAST_EVENT_INFO_LOAD_MODULE', 'PALPC_CONTEXT_ATTR32', 'MIB_UDP6TABLE_OWNER_PID', 'PIMAGE_NT_HEADERS32', 'PCERT_CHAIN_PARA', 'TMP_CERT_STRONG_SIGN_PARA_UNION_TYPE', '_TOKEN_LINKED_TOKEN', 'EXCEPTION_POINTERS32', 'ACCESS_ALLOWED_CALLBACK_ACE', 'WINTRUST_CERT_INFO', 'CRL_BLOB', 'PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1', 'POBJECT_ATTRIBUTES', '_EVENT_TRACE_PROPERTIES', 'PCERT_CHAIN_ENGINE_CONFIG', '_DEBUG_LAST_EVENT_INFO_BREAKPOINT', 'SYSTEM_RESOURCE_ATTRIBUTE_ACE', 'PTOKEN_ELEVATION', 'PFILE_EA_INFORMATION', 'KEY_VALUE_PARTIAL_INFORMATION', 'WOW64_FLOATING_SAVE_AREA', '_LIST_ENTRY', '_PORT_MESSAGE32', 'PCERT_REVOCATION_CRL_INFO', 'PPSAPI_WORKING_SET_EX_BLOCK64', 'PDEBUG_BREAKPOINT_PARAMETERS', '_CTL_ENTRY', 'PEVENT_TRACE_HEADER', '_PROCESS_INFORMATION', '_CERT_CHAIN_CONTEXT', '_SYSTEM_HANDLE_INFORMATION', '_MIB_UDP6ROW_OWNER_PID', 'LPUNLOAD_DLL_DEBUG_INFO', 'EVENTLOGRECORD', '_LSA_UNICODE_STRING', '_MIB_IPADDRTABLE', 'PARAMDESC', 'PDEBUG_REGISTER_DESCRIPTION', 'CRL_CONTEXT', 'PPSAPI_WORKING_SET_EX_BLOCK', 'PAPI_SET_VALUE_ARRAY_V2', 'tagWNDCLASSEXW', '_WOW64_CONTEXT', 'PCCERT_STRONG_SIGN_PARA', '_UNLOAD_DLL_DEBUG_INFO', 'PWINTRUST_CATALOG_INFO', 'CREATE_PROCESS_DEBUG_INFO', '_COAUTHIDENTITY', 'tagDISPPARAMS', 'PIP_INTERFACE_INFO', '_ANON_PEB_SYSTEM_DEPENDENT_02', '_ANON_PEB_UNION_1', '_ANON_PEB_UNION_2', '_SYSTEM_RESOURCE_ATTRIBUTE_ACE', 'WINTRUST_SGNR_INFO', 'PCMSG_SIGNER_INFO', 'PALPC_HANDLE_ATTR64', '_TOKEN_APPCONTAINER_INFORMATION', 'PRTL_UNLOAD_EVENT_TRACE', 'PARAMDESCEX', '_SYSTEM_ALARM_CALLBACK_ACE', '_ANON_PEB_SYSTEM_DEPENDENT_06', '_XSAVE_FORMAT_32', '_ITEMIDLIST', '_KEY_VALUE_FULL_INFORMATION', 'PDNS_NSEC3_DATA', 'EVENT_FILTER_DESCRIPTOR', '_CALLFRAMEINFO', '_OUTPUT_DEBUG_STRING_INFO', 'TOKEN_MANDATORY_POLICY', '_EVENT_TRACE', 'PPEB', 'PRTL_DRIVE_LETTER_CURDIR', 'PCERT_CONTEXT', 'PSYSTEM_ALARM_OBJECT_ACE', 'PCERT_NAME_BLOB', '_CRYPT_ATTRIBUTE', '_EVENT_FILTER_DESCRIPTOR', 'SYSTEM_MODULE_INFORMATION64', '_CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION', 'WINTRUST_BLOB_INFO_', 'PCMSG_CTRL_DECRYPT_PARA', '_ALPC_SERVER_INFORMATION_TMP_IN', '_FILE_ATTRIBUTE_TAG_INFORMATION', 'PIMAGE_IMPORT_DESCRIPTOR', 'PDNS_WINS_DATA', 'FILE_FS_LABEL_INFORMATION', '_WINTRUST_DATA', 'TYPEATTR', 'PCRYPT_ENCODE_PARA', '_FILE_FS_SECTOR_SIZE_INFORMATION', 'TRACE_GUID_INFO', '_IP_ADAPTER_INDEX_MAP', 'FILE_ACCESS_INFORMATION', '_TMP_DUMMYSTRUCTNAME', 'PROCESS_INFORMATION', 'BITMAPFILEHEADER', 'CONTEXT64', '_CERT_ID', 'RTL_DRIVE_LETTER_CURDIR', 'JIT_DEBUG_INFO', 'TRACE_ENABLE_INFO', 'DNS_SIG_DATAW', '_SYSTEM_AUDIT_ACE', 'CRYPT_DECRYPT_MESSAGE_PARA', 'PCCERT_SIMPLE_CHAIN', '_SECURITY_QUALITY_OF_SERVICE', 'IMAGE_OPTIONAL_HEADER32', 'PALPC_PORT_ATTRIBUTES64', 'CRYPT_HASH_BLOB', 'PCIDLIST_ABSOLUTE', 'ALPC_CONTEXT_ATTR64', 'PAPI_SET_NAMESPACE_ENTRY_V4', '_CERT_REVOCATION_INFO', '_DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE', '_PSAPI_WORKING_SET_EX_INFORMATION', 'PPSAPI_WORKING_SET_BLOCK', '_DEBUG_PROCESSOR_IDENTIFICATION_IA64', 'CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE', 'CMSG_RECIPIENT_ENCODE_INFO', 'PTOKEN_GROUPS', 'ORPCTHIS', 'PCCERT_CHAIN_CONTEXT', '_PSAPI_WORKING_SET_EX_INFORMATION64', '_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1', '_MIB_IPADDRROW_XP', 'UNICODE_STRING', 'IMAGEHLP_MODULE64', 'BG_AUTH_CREDENTIALS_UNION', 'DNS_A_DATA', 'PROCESS_MITIGATION_ASLR_POLICY', 'PCMSG_ENVELOPED_ENCODE_INFO', '_CTL_CONTEXT', '_DEBUG_REGISTER_DESCRIPTION', 'TOKEN_MANDATORY_LABEL', 'PSYSTEM_ALARM_CALLBACK_ACE', 'PSAPI_WORKING_SET_EX_BLOCK64', '_EVENT_TRACE_LOGFILEA', 'SYSTEM_ALARM_ACE', '_IMAGE_EXPORT_DIRECTORY', '_DEBUG_LAST_EVENT_INFO_EXIT_PROCESS', 'DEBUG_LAST_EVENT_INFO_BREAKPOINT', 'DEBUG_LAST_EVENT_INFO_EXIT_PROCESS', 'RTL_UNLOAD_EVENT_TRACE32', 'PSYSTEM_MANDATORY_LABEL_ACE', 'PEB', 'TOKEN_PRIMARY_GROUP', 'TOKEN_OWNER', 'PCRYPT_ALGORITHM_IDENTIFIER', '_DNS_CACHE_ENTRY', 'TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', 'PPSAPI_WORKING_SET_EX_INFORMATION32', 'DEBUG_SYMBOL_SOURCE_ENTRY', '_ACL_REVISION_INFORMATION', 'CERT_KEY_CONTEXT', '_SYSTEM_MANDATORY_LABEL_ACE', 'PSYSTEM_VERIFIER_INFORMATION', '_CERT_PUBLIC_KEY_INFO', 'tagCOMVERSION', 'EVENT_HEADER', '_CERT_TRUST_STATUS', '_DEBUG_SYMBOL_PARAMETERS', 'PFILE_POSITION_INFORMATION', 'PXSAVE_FORMAT_64', '_DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR', '_RTLP_CURDIR_REF', 'DEBUG_EVENT', 'PCERT_TRUST_LIST_INFO', 'PSAPI_WORKING_SET_BLOCK64', 'PMEMORY_BASIC_INFORMATION64', 'CALLFRAME_MARSHALCONTEXT', '_FILE_EA_INFORMATION', 'PCERT_INFO', '_OBJECT_ATTRIBUTES', 'PSYSTEM_MODULE_INFORMATION32', '_SPC_SERIALIZED_OBJECT', 'ALPC_SECURITY_ATTR64', 'PDNS_TXT_DATAW', 'FILE_FS_OBJECTID_INFORMATION', 'PTOKEN_GROUPS_AND_PRIVILEGES', '_PSAPI_WORKING_SET_INFORMATION32', 'DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR', 'PDNS_TXT_DATAA', 'LIST_ENTRY', 'PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION', '_FILE_ALIGNMENT_INFORMATION', '_DEBUG_PROCESSOR_IDENTIFICATION_ALPHA', '_SYSTEM_SCOPED_POLICY_ID_ACE', 'PCERT_STRONG_SIGN_SERIALIZED_INFO', '_CLAIM_SECURITY_ATTRIBUTES_INFORMATION', '_DEBUG_LAST_EVENT_INFO_EXIT_THREAD', 'tagPARAMDESC', 'ALPC_SERVER_INFORMATION_TMP_IN', 'LPTLIBATTR', 'PCTL_INFO', 'PCRYPT_HASH_BLOB', 'PTOKEN_ACCESS_INFORMATION', 'PDNS_TSIG_DATAW', 'CALLFRAMEPARAMINFO', 'DNS_TSIG_DATAA', '_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE', 'CATALOG_INFO', '_SYSTEM_MODULE32', 'LPPARAMDESCEX', 'DNS_TSIG_DATAW', 'PDNS_TSIG_DATAA', '_TMP_lowmid', 'PALPC_HANDLE_ATTR', 'PPUBLIC_OBJECT_TYPE_INFORMATION', '_tagBRECORD', 'GENERIC_MAPPING', '_LDR_DATA_TABLE_ENTRY', 'PSID_AND_ATTRIBUTES_HASH', 'DEBUG_PROCESSOR_IDENTIFICATION_ALPHA', 'PACCESS_DENIED_CALLBACK_OBJECT_ACE', 'PTHREADENTRY32', 'DEBUG_VALUE', 'ALPC_SERVER_INFORMATION', 'DEBUG_PROCESSOR_IDENTIFICATION_ALL', '_MEMORY_BASIC_INFORMATION64', 'PROCESSENTRY32W', 'TOKEN_SOURCE', 'CRYPT_DATA_BLOB', '_CRYPT_BIT_BLOB', 'CERT_TRUST_STATUS', '_EXCEPTION_POINTERS64', 'FILE_IS_REMOTE_DEVICE_INFORMATION', 'SYSTEM_ALARM_CALLBACK_ACE', 'IP6_ADDRESS', 'SYSTEM_AUDIT_CALLBACK_ACE', 'CRL_ENTRY', 'PSAPI_WORKING_SET_EX_INFORMATION', 'PTOKEN_USER', 'PDEBUG_LAST_EVENT_INFO_UNLOAD_MODULE', 'LPPROCESSENTRY32', 'DEBUG_BREAKPOINT_PARAMETERS', 'BITMAPINFOHEADER', 'SOLE_AUTHENTICATION_SERVICE', 'FILE_FS_ATTRIBUTE_INFORMATION', 'PCERT_USAGE_MATCH', 'PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO', 'ACL_SIZE_INFORMATION', 'TMP_signscale_union', '_MEMORY_BASIC_INFORMATION32', 'PSAPI_WORKING_SET_EX_BLOCK', 'LPOUTPUT_DEBUG_STRING_INFO', 'IMAGE_FILE_HEADER', 'DEBUG_PROCESSOR_IDENTIFICATION_AMD64', '_SECURITY_DESCRIPTOR', 'PUBLIC_OBJECT_TYPE_INFORMATION', 'PROVIDER_ENUMERATION_INFO', 'API_SET_NAMESPACE_ENTRY', 'FLOATING_SAVE_AREA', '_PSAPI_WORKING_SET_EX_BLOCK', 'TMP_TYPEDESC_UNION', 'PFILE_DISPOSITION_INFORMATION', 'PTOKEN_SECURITY_ATTRIBUTES_INFORMATION', 'PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE', 'EXCEPINFO', 'PLDR_DATA_TABLE_ENTRY', 'RTL_UNLOAD_EVENT_TRACE64', '_FILE_FS_DEVICE_INFORMATION', '_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY', '_CRYPT_ALGORITHM_IDENTIFIER', 'PACCESS_DENIED_ACE', '_FILE_ALL_INFORMATION', 'LPEXIT_PROCESS_DEBUG_INFO', '_CRYPT_KEY_VERIFY_MESSAGE_PARA', 'API_SET_NAMESPACE_ARRAY_V2', '_PRIVILEGE_SET', '_TMP_TYPEDESC_UNION', 'PETW_BUFFER_CONTEXT', 'LPOSVERSIONINFOA', 'LPWNDCLASSEXA', 'BG_JOB_REPLY_PROGRESS', '_FILE_NETWORK_OPEN_INFORMATION', '_ALPC_HANDLE_ATTR32', '_EXIT_PROCESS_DEBUG_INFO', 'LPWNDCLASSEXW', '_IMAGE_SECTION_HEADER', 'LPOSVERSIONINFOW', 'EVENT_TRACE_LOGFILEW', '_ACCESS_DENIED_CALLBACK_ACE', 'PEXCEPTION_RECORD', 'PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO', 'IMAGE_DATA_DIRECTORY', 'BITMAP', 'PKEY_VALUE_PARTIAL_INFORMATION', '_FILE_FS_DRIVER_PATH_INFORMATION', 'PFILE_NETWORK_OPEN_INFORMATION', '_MIB_UDP6TABLE_OWNER_PID', 'LPPROCESS_INFORMATION', '_TMP_SPC_LINK_UNION', 'CRYPT_ENCODE_PARA', 'PDNS_TKEY_DATAW', 'BG_AUTH_CREDENTIALS', 'LPVARDESC', '_EVENTLOG_FULL_INFORMATION', 'PBITMAP', 'PDNS_TKEY_DATAA', 'PDEBUG_SPECIFIC_FILTER_PARAMETERS', 'PWNDCLASSEXW', '_TMP_CONTEXT64_SUBUNION', 'PDNS_RRSIG_DATAW', '_FILE_POSITION_INFORMATION', 'PWNDCLASSEXA', 'PPROCESSENTRY32', 'API_SET_NAMESPACE_ARRAY', 'PMIB_TCPROW', '_FILE_FS_CONTROL_INFORMATION', 'FILE_NAME_INFORMATION', 'DNS_PTR_DATAA', '_ALPC_DATA_VIEW_ATTR', '_TRACE_LOGFILE_HEADER', 'UNLOAD_DLL_DEBUG_INFO', '_STRING', '_ALPC_DIRECT_ATTR64', 'PIP6_ADDRESS', '_TOKEN_DEFAULT_DACL', '_ALPC_CONTEXT_ATTR64', 'TMP_WINTRUST_UNION_TYPE', '_GENERIC_MAPPING', 'EVENT_DESCRIPTOR', 'PCONTEXT64', 'PACL_REVISION_INFORMATION', 'CERT_CHAIN_ELEMENT', 'CERT_PUBLIC_KEY_INFO', 'DEBUG_SPECIFIC_FILTER_PARAMETERS', 'PEVENT_TRACE_LOGFILEW', 'API_SET_VALUE_ENTRY', 'PCCERT_CHAIN_ELEMENT', '_DEBUG_VALUE_TMP_UNION', 'DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE', 'PSAPI_WORKING_SET_EX_INFORMATION64', '_RTL_USER_PROCESS_PARAMETERS', 'PEVENT_TRACE_LOGFILEA', 'TMP_CONTEXT64_SUBUNION', '_TRACE_ENABLE_INFO', '_EXCEPTION_RECORD32', 'MIB_TCP6TABLE_OWNER_PID', 'LDR_DATA_TABLE_ENTRY', 'ALPC_DATA_VIEW_ATTR', '_CTL_USAGE', 'CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO', 'LPOSVERSIONINFOEXW', 'DEBUG_MODULE_PARAMETERS', 'PWINTRUST_DATA', 'SPC_SERIALIZED_OBJECT', 'TYPEDESC', 'LPOSVERSIONINFOEXA', 'DEBUG_REGISTER_DESCRIPTION', '_TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE', 'STARTUPINFOA', 'DNS_DHCID_DATA', 'PAPI_SET_NAMESPACE_ARRAY', 'tagDEC', 'STARTUPINFOW', 'EXCEPTION_RECORD32', 'MIB_UDP6ROW_OWNER_PID', 'PDEBUG_PROCESSOR_IDENTIFICATION_ALPHA', 'DNS_SIG_DATAA', '_PORT_MESSAGE64_TMP_UNION', '_SID_IDENTIFIER_AUTHORITY', 'PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY', 'TOKEN_LINKED_TOKEN', 'CRYPT_ALGORITHM_IDENTIFIER', 'VARDESC', 'PORT_MESSAGE64', 'PDEBUG_EXCEPTION_FILTER_PARAMETERS', 'WINTRUST_DATA', 'SYSTEM_HANDLE', '_DEBUG_MODULE_PARAMETERS', 'OSVERSIONINFOEXW', 'ACCESS_DENIED_CALLBACK_OBJECT_ACE', '_M128A', 'CTL_CONTEXT', 'PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE', 'OSVERSIONINFOEXA', '_EVENT_TRACE_LOGFILEW', '_CMSG_CTRL_DECRYPT_PARA', 'PSAPI_WORKING_SET_INFORMATION64', 'CRYPT_HASH_MESSAGE_PARA', 'ITEMIDLIST', 'PDNS_RRSIG_DATAA', 'PGENERIC_MAPPING', '_SPC_SP_OPUS_INFO', 'PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY', '_ACCESS_DENIED_CALLBACK_OBJECT_ACE', 'SPC_LINK_', 'PDEBUG_PROCESSOR_IDENTIFICATION_X86', 'tagBITMAPCOREINFO', 'PSAPI_WORKING_SET_INFORMATION', '_EXCEPTION_RECORD', 'tagARRAYDESC', 'PDNS_NULL_DATA', 'CLAIM_SECURITY_ATTRIBUTE_V1_UNION', '_BG_JOB_PROGRESS', 'XSAVE_FORMAT_64', 'LPSERVICE_STATUS_PROCESS', 'DNS_MX_DATAA', 'CONTEXT32', '_TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION', 'PDNS_A_DATA', '_DEBUG_PROCESSOR_IDENTIFICATION_ARM', 'PTHREAD_BASIC_INFORMATION', 'DNS_MX_DATAW', '_EVENT_HEADER_EXTENDED_DATA_ITEM', 'RTLP_CURDIR_REF', 'SYSTEM_AUDIT_CALLBACK_OBJECT_ACE', 'PDEBUG_LAST_EVENT_INFO_BREAKPOINT', 'ALPC_DIRECT_ATTR64', 'CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', 'NPBITMAP', 'TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO', 'DEBUG_VALUE_TMP_SUBSTRUCT1', 'DEBUG_VALUE_TMP_SUBSTRUCT3', 'DEBUG_VALUE_TMP_SUBSTRUCT2', '_CRYPT_SIGN_MESSAGE_PARA']) +enums = set(['VARENUM', 'INVOKEKIND', 'BG_JOB_PROXY_USAGE', '_BG_JOB_PROXY_USAGE', '_IMAGEHLP_SYMBOL_TYPE_INFO', 'CLSCTX', '_THREAD_INFORMATION_CLASS', 'TASK_COMPATIBILITY', 'tagCLSCTX', '_TASK_ACTION_TYPE', 'FS_INFORMATION_CLASS', 'SYSKIND', 'BG_JOB_TYPE', 'tag_WBEM_GENERIC_FLAG_TYPE', 'IO_PRIORITY_HINT', 'WBEM_GENUS_TYPE', 'EVT_SYSTEM_PROPERTY_ID', 'ALPC_PORT_INFORMATION_CLASS', 'BG_AUTH_SCHEME', 'EVT_EVENT_METADATA_PROPERTY_ID', 'tag_WBEM_CHANGE_FLAG_TYPE', '_SC_ENUM_TYPE', '_CALLFRAME_COPY', '_IO_PRIORITY_HINT', 'SE_OBJECT_TYPE', '_EVT_SYSTEM_PROPERTY_ID', '_ALPC_PORT_INFORMATION_CLASS', 'TASK_CREATION', 'IMAGEHLP_SYMBOL_TYPE_INFO', '_MIB_TCP_STATE', '_TASK_TRIGGER_TYPE2', 'TASK_TRIGGER_TYPE2', 'tag_WBEM_CONNECT_OPTIONS', '_TASK_RUNLEVEL_TYPE', 'SC_STATUS_TYPE', 'EVT_LOG_PROPERTY_ID', '_EVT_RENDER_FLAGS', 'DESCKIND', 'FUNCKIND', '_INTERNAL_IF_OPER_STATUS', 'NET_FW_PROFILE_TYPE2', 'PTHREAD_INFORMATION_CLASS', '_TASK_INSTANCES_POLICY', 'TASK_INSTANCES_POLICY', 'TASK_ACTION_TYPE', '_SE_OBJECT_TYPE', 'BG_ERROR_CONTEXT', 'TASK_STATE', 'PROCESS_INFORMATION_CLASS', 'tagMSHLFLAGS', 'EVT_RENDER_CONTEXT_FLAGS', '_TASK_LOGON_TYPE', 'UdtKind', '_BG_JOB_TYPE', 'PPROCESS_MITIGATION_POLICY', 'MEMORY_INFORMATION_CLASS', 'INTERNAL_IF_OPER_STATUS', 'TYPEKIND', 'tagCALLCONV', 'NET_FW_ACTION', '_VARENUM', 'SC_ENUM_TYPE', '_WELL_KNOWN_SID_TYPE', 'TASK_ENUM_FLAGS', '_MEMORY_INFORMATION_CLASS', 'DNS_FREE_TYPE', 'DataKind', 'tag_WBEM_QUERY_FLAG_TYPE', 'UDP_TABLE_CLASS', '_KEY_VALUE_INFORMATION_CLASS', 'NET_FW_IP_PROTOCOL_', 'tag_WBEM_GENUS_TYPE', 'PROCESS_MITIGATION_POLICY', '_SECURITY_IMPERSONATION_LEVEL', '_EVT_QUERY_FLAGS', '_PROCESS_MITIGATION_POLICY', '_SC_STATUS_TYPE', 'PFILE_INFORMATION_CLASS', '_UDP_TABLE_CLASS', '_BG_JOB_PRIORITY', 'EVT_CHANNEL_TYPE', '_PROCESSINFOCLASS', '_EVT_CHANNEL_CONFIG_PROPERTY_ID', '_EVT_LOG_PROPERTY_ID', 'VARKIND', '_BG_ERROR_CONTEXT', 'PTOKEN_INFORMATION_CLASS', 'WBEM_CONNECT_OPTIONS', 'NET_FW_PROFILE_TYPE2_', 'ACL_INFORMATION_CLASS', 'PALPC_MESSAGE_INFORMATION_CLASS', 'PTOKEN_TYPE', 'TASK_RUNLEVEL_TYPE', 'SECURITY_IMPERSONATION_LEVEL', '_EVT_OPEN_LOG_FLAGS', 'BG_JOB_PRIORITY', 'CALLFRAME_COPY', 'SYM_TYPE', 'TOKEN_INFORMATION_CLASS', 'tagTOKEN_TYPE', 'TASK_LOGON_TYPE', 'COINIT', 'KEY_INFORMATION_CLASS', 'tag_WBEM_TIMEOUT_TYPE', 'THREAD_INFORMATION_CLASS', '_TASK_ENUM_FLAGS', 'COMSD', 'NET_FW_RULE_DIRECTION', 'TRACE_QUERY_INFO_CLASS', 'EVT_OPEN_LOG_FLAGS', '_EVT_CHANNEL_TYPE', 'CALLFRAME_WALK', '_TOKEN_INFORMATION_CLASS', 'NDR_FORMAT_CHARACTER', 'tagTYPEKIND', '__MIDL_IBackgroundCopyJob2_0002', 'tagCOINIT', '__MIDL_IBackgroundCopyJob2_0001', 'TASK_RUN_FLAGS', 'CALLCONV', '_FS_INFORMATION_CLASS', 'EVT_QUERY_FLAGS', '_EVT_VARIANT_TYPE', 'WBEM_QUERY_FLAG_TYPE', 'OBJECT_INFORMATION_CLASS', 'BasicType', 'ALPC_MESSAGE_INFORMATION_CLASS', '_ALPC_MESSAGE_INFORMATION_CLASS', 'MIB_TCP_STATE', '_TCP_TABLE_CLASS', 'tagCOMSD', 'PROCESSINFOCLASS', 'SECTION_INHERIT', 'tagFUNCKIND', '_SYSTEM_INFORMATION_CLASS', 'SYSTEM_INFORMATION_CLASS', 'EVT_CHANNEL_CONFIG_PROPERTY_ID', 'tag_WBEMSTATUS', 'tagDESCKIND', 'tagVARKIND', 'BG_AUTH_TARGET', 'EVT_FORMAT_MESSAGE_FLAGS', '_TOKEN_ELEVATION_TYPE', 'PSECURITY_IMPERSONATION_LEVEL', 'SID_NAME_USE', 'TRACE_INFO_CLASS', '_TASK_CREATION', 'SymTagEnum', 'EVT_CHANNEL_ISOLATION_TYPE', '_EVT_PUBLISHER_METADATA_PROPERTY_ID', 'KEY_VALUE_INFORMATION_CLASS', 'tagSYSKIND', '_TASK_COMPATIBILITY', '_SID_NAME_USE', 'WBEM_GENERIC_FLAG_TYPE', 'NET_FW_MODIFY_STATE', 'NET_FW_RULE_DIRECTION_', '_EVT_RENDER_CONTEXT_FLAGS', 'BG_JOB_STATE', 'MSHLFLAGS', 'EVT_VARIANT_TYPE', 'WBEM_TIMEOUT_TYPE', 'FILE_INFORMATION_CLASS', '_EVT_EVENT_METADATA_PROPERTY_ID', 'tagINVOKEKIND', '_FILE_INFORMATION_CLASS', 'NET_FW_ACTION_', 'TOKEN_TYPE', 'tagCALLFRAME_WALK', '_EVT_FORMAT_MESSAGE_FLAGS', 'PSID_NAME_USE', 'PTOKEN_ELEVATION_TYPE', '_BG_JOB_STATE', '_RTL_PATH_TYPE', 'WBEM_CHANGE_FLAG_TYPE', 'TCP_TABLE_CLASS', 'TOKEN_ELEVATION_TYPE', '_EVT_CHANNEL_ISOLATION_TYPE', 'NET_FW_MODIFY_STATE_', '_TASK_STATE', 'WBEMSTATUS', 'RTL_PATH_TYPE', '_KEY_INFORMATION_CLASS', 'EVT_RENDER_FLAGS', '_OBJECT_INFORMATION_CLASS', 'WELL_KNOWN_SID_TYPE', '_ACL_INFORMATION_CLASS', '_SymTagEnum', 'NET_FW_IP_PROTOCOL', '_SECTION_INHERIT', 'EVT_PUBLISHER_METADATA_PROPERTY_ID']) +functions = set(['EvtGetChannelConfigProperty', 'NtQuerySymbolicLinkObject', 'GetStdHandle', 'GetDriveTypeW', 'GetFileVersionInfoSizeA', 'CertFreeCertificateContext', 'GetModuleBaseNameA', 'ConvertSidToStringSidW', 'ShellExecuteW', 'CryptAcquireCertificatePrivateKey', 'AddVectoredContinueHandler', 'GetDriveTypeA', 'SymEnumTypesByName', 'CryptEncrypt', 'DebugBreak', 'EvtOpenLog', 'GetProcessDEPPolicy', 'GetProcessMitigationPolicy', 'ConvertSidToStringSidA', 'GetExtendedTcpTable', 'CreatePipe', 'CreateWellKnownSid', 'GetSecurityDescriptorGroup', 'NtWow64ReadVirtualMemory64', 'DebugActiveProcessStop', 'SymInitialize', 'RegOpenKeyExW', 'SymLoadModuleEx', 'InitializeProcThreadAttributeList', 'CryptMsgGetParam', 'NtOpenSymbolicLinkObject', 'RegOpenKeyExA', 'QueryWorkingSetEx', 'CertEnumCTLsInStore', 'GetFirmwareEnvironmentVariableExW', 'CryptCATAdminCalcHashFromFileHandle2', 'CertCreateCertificateContext', 'EvtOpenEventMetadataEnum', 'CloseEventLog', 'CryptMsgUpdate', 'StartTraceA', 'NtSetInformationProcess', 'NtAlpcDisconnectPort', 'WriteFile', 'WaitForSingleObject', 'GetLogicalDriveStringsW', 'EvtOpenPublisherMetadata', 'CoGetInterceptor', 'EvtRender', 'NtAlpcConnectPortEx', 'ConnectNamedPipe', 'GetProcessImageFileNameW', 'CoInitializeSecurity', 'EnumClipboardFormats', 'AllocConsole', 'SymSearch', 'GetVolumeInformationA', 'GetProcessImageFileNameA', 'NtQueryInformationFile', 'CryptDestroyKey', 'PeekNamedPipe', 'LookupPrivilegeValueA', 'EvtFormatMessage', 'NtQueryKey', 'OpenServiceA', 'WriteProcessMemory', 'NtSetContextThread', 'FindNextVolumeA', 'RegQueryValueExA', 'CryptCATCatalogInfoFromContext', 'RtlDecompressBufferEx', 'NtQueryDirectoryObject', 'NtEnumerateValueKey', 'LookupPrivilegeValueW', 'CreateTransaction', 'GetSecurityInfo', 'CryptEncodeObjectEx', 'NtAlpcDeletePortSection', 'RegQueryValueExW', 'NtQueryVirtualMemory', 'VerQueryValueA', 'FindWindowA', 'StartTraceW', 'CryptCATGetAttrInfo', 'GetSidSubAuthority', 'ConvertStringSecurityDescriptorToSecurityDescriptorW', 'LoadLibraryExA', 'SetConsoleCtrlHandler', 'NtAlpcCreateSectionView', 'ConvertStringSecurityDescriptorToSecurityDescriptorA', 'LoadLibraryExW', 'ZwDuplicateObject', 'NtAlpcDeleteSecurityContext', 'SymEnumerateModules64', 'GetModuleBaseNameW', 'EnableTraceEx', 'NtQuerySystemInformation', 'NtSetValueKey', 'QueryAllTracesW', 'GetSidSubAuthorityCount', 'CreateThread', 'CreateProcessAsUserA', 'GetExitCodeThread', 'SetNamedPipeHandleState', 'SetTcpEntry', 'CreateFileA', 'QueryAllTracesA', 'LocalFree', 'CoCreateInstanceEx', 'NtConnectPort', 'CreateProcessAsUserW', 'NtProtectVirtualMemory', 'SetPriorityClass', 'CoInitializeEx', 'EvtOpenPublisherEnum', 'TraceQueryInformation', 'EnableTraceEx2', 'CryptCATGetMemberInfo', 'CryptExportKey', 'VirtualQuery', 'DebugActiveProcess', 'EvtGetPublisherMetadataProperty', 'CloseWindow', 'EqualSid', 'IsValidSecurityDescriptor', 'LdrLoadDll', 'SetThreadToken', 'GetCurrentThreadId', 'GetExtendedUdpTable', 'SleepEx', 'CryptUIDlgViewContext', 'GetSecurityDescriptorRMControl', 'CreateToolhelp32Snapshot', 'SymEnumTypes', 'RtlInitUnicodeString', 'GetFirmwareEnvironmentVariableExA', 'RegCloseKey', 'NtAlpcImpersonateClientOfPort', 'NtSetInformationFile', 'ControlTraceA', 'GetVersionExW', 'OpenEventLogA', 'GetNumberOfEventLogRecords', 'CommitTransaction', 'GetVersionExA', 'GetSecurityDescriptorLength', 'CreateRemoteThread', 'NtAlpcSendWaitReceivePort', 'SystemTimeToFileTime', 'OpenProcessToken', 'SymLoadModuleExW', 'OpenProcess', 'EnumChildWindows', 'EvtGetLogInfo', 'GetProcAddress', 'CryptSignMessage', 'GetComputerNameW', 'RtlAnsiStringToUnicodeString', 'SetWindowTextA', 'SetThreadContext', 'CertCompareCertificate', 'Wow64GetThreadContext', 'DebugBreakProcess', 'SymSetOptions', 'OpenEventLogW', 'SetWindowTextW', 'NtCreateNamedPipeFile', 'GetComputerNameA', 'BringWindowToTop', 'lstrcmpW', 'GetAce', 'MapGenericMask', 'NtQueryLicenseValue', 'StartServiceW', 'OpenTraceA', 'GetDesktopWindow', 'Process32Next', 'CryptCATAdminEnumCatalogFromHash', 'FreeLibrary', 'CertFindCertificateInStore', 'CoTaskMemFree', 'OpenTraceW', 'RemoveVectoredExceptionHandler', 'NtOpenEvent', 'EvtOpenChannelEnum', 'EvtNextChannelPath', 'VirtualAllocEx', 'NtCreateProcessEx', 'NtAlpcCreateSecurityContext', 'FindWindowW', 'EvtClose', 'GetInterfaceInfo', 'GlobalUnlock', 'GlobalAlloc', 'NtOpenDirectoryObject', 'GetWindowThreadProcessId', 'CryptCATAdminReleaseCatalogContext', 'SizeofResource', 'TdhEnumerateProviders', 'VirtualFreeEx', 'MoveWindow', 'ContinueDebugEvent', 'GetSecurityDescriptorOwner', 'CertDuplicateCTLContext', 'SetThreadAffinityMask', 'NtQueryObject', 'SymEnumSymbols', 'ApiSetResolveToHost', 'CryptVerifyMessageSignatureWithKey', 'CryptCATEnumerateCatAttr', 'DuplicateTokenEx', 'GetWindowModuleFileNameA', 'CryptVerifyMessageHash', 'GetNamedSecurityInfoW', 'EnumServicesStatusExW', 'GetSecurityDescriptorDacl', 'GetModuleHandleA', 'StopTraceW', 'EmptyClipboard', 'GetWindowModuleFileNameW', 'Process32NextW', 'Wow64RevertWow64FsRedirection', 'MessageBoxW', 'StopTraceA', 'GlobalLock', 'GetModuleHandleW', 'EnumServicesStatusExA', 'TpCallbackSendAlpcMessageOnCompletion', 'TraceSetInformation', 'GetFileVersionInfoA', 'NtAlpcQueryInformation', 'NtOpenKey', 'Wow64DisableWow64FsRedirection', 'OpenSCManagerW', 'ObjectFromLresult', 'VirtualFree', 'GetFileVersionInfoW', 'NtGetContextThread', 'OpenSCManagerA', 'NtQueryInformationProcess', 'NtQueryValueKey', 'EvtGetEventMetadataProperty', 'NtOpenSection', 'GetForegroundWindow', 'FileTimeToSystemTime', 'CertAddCertificateContextToStore', 'GetFileVersionInfoSizeW', 'SetWindowPos', 'GetProcessId', 'EvtQuery', 'GetCurrentProcess', 'NtReadVirtualMemory', 'SymLoadModuleExA', 'ConvertStringSidToSidA', 'OpenEventA', 'WindowFromPoint', 'GetThreadContext', 'GetCursorPos', 'SetStdHandle', 'PFXImportCertStore', 'CoGetClassObject', 'LoadLibraryW', 'WaitForDebugEvent', 'GetNamedSecurityInfoA', 'CryptQueryObject', 'OpenThreadToken', 'GetSecurityDescriptorSacl', 'GetProcessMemoryInfo', 'CryptCATEnumerateMember', 'NtCreateFile', 'GetSystemTimeAsFileTime', 'Thread32First', 'CryptMsgOpenToEncode', 'OpenTransaction', 'CertDuplicateCertificateContext', 'QueryDosDeviceA', 'CryptMsgVerifyCountersignatureEncodedEx', 'AddVectoredExceptionHandler', 'GetMappedFileNameW', 'GetLogicalDriveStringsA', 'LoadResource', 'GetWindowTextW', 'GetMappedFileNameA', 'QueryDosDeviceW', 'NtAlpcQueryInformationMessage', 'CryptCATAdminAcquireContext2', 'GetWindowTextA', 'GetCurrentThread', 'GetEventLogInformation', 'CryptVerifyMessageSignature', 'CertEnumCertificatesInStore', 'CryptMsgVerifyCountersignatureEncoded', 'OpenThread', 'GetParent', 'CertStrToNameW', 'SuspendThread', 'DuplicateToken', 'NtCreateSymbolicLinkObject', 'GetModuleFileNameW', 'EnumWindows', 'RtlGetCompressionWorkSpaceSize', 'CertStrToNameA', 'GetClassInfoExA', 'ExitProcess', 'CryptCATEnumerateAttr', 'CertOpenStore', 'GetModuleFileNameA', 'GetAclInformation', 'LoadLibraryA', 'SetProcessMitigationPolicy', 'DnsGetCacheDataTable', 'CloseServiceHandle', 'GetPriorityClass', 'SymEnumSymbolsEx', 'NtQueryEaFile', 'NtAlpcConnectPort', 'NtAlpcDeleteResourceReserve', 'GetVolumeInformationW', 'GetClipboardData', 'MapViewOfFile', 'CryptGenKey', 'RtlDecompressBuffer', 'NtWriteVirtualMemory', 'GetVolumeNameForVolumeMountPointA', 'GetFirmwareEnvironmentVariableW', 'NtUnmapViewOfSection', 'SetClipboardData', 'DebugSetProcessKillOnExit', 'NtSetEaFile', 'GetFirmwareEnvironmentVariableA', 'CryptCATAdminAcquireContext', 'GetIpAddrTable', 'GetVolumeNameForVolumeMountPointW', 'ExitThread', 'CryptDecrypt', 'CryptDecodeObject', 'EvtGetObjectArraySize', 'SymGetModuleInfo64', 'ReadEventLogA', 'RtlGetUnloadEventTraceEx', 'TerminateProcess', 'EvtOpenChannelConfig', 'NtAlpcCreatePortSection', 'ConvertSecurityDescriptorToStringSecurityDescriptorW', 'SymSearchW', 'GetWindowRect', 'NtAlpcCreateResourceReserve', 'WinVerifyTrust', 'VirtualQueryEx', 'ReadEventLogW', 'SymGetTypeInfo', 'CryptCATAdminReleaseContext', 'GetClipboardFormatNameW', 'GetVersion', 'NtEnumerateSystemEnvironmentValuesEx', 'CryptHashCertificate', 'ConvertSecurityDescriptorToStringSecurityDescriptorA', 'CloseHandle', 'StartServiceA', 'CopySid', 'LookupAccountSidW', 'GetSystemTime', 'CertCreateSelfSignCertificate', 'TerminateThread', 'LookupPrivilegeNameA', 'OpenBackupEventLogW', 'AccessCheck', 'AlpcInitializeMessageAttribute', 'GetExitCodeProcess', 'LookupAccountSidA', 'Wow64SetThreadContext', 'VirtualProtect', 'CertEnumCertificateContextProperties', 'OpenBackupEventLogA', 'NtAlpcAcceptConnectPort', 'GetClassInfoExW', 'GetSystemMetrics', 'NtCreateThreadEx', 'NtCreateKey', 'GetWindowsDirectoryW', 'QueryWorkingSet', 'EvtCreateRenderContext', 'PfnCryptGetSignerCertificate', 'SHGetPathFromIDListW', 'OpenEventW', 'CryptDecryptMessage', 'GetWindowsDirectoryA', 'ProcessTrace', 'NtAllocateVirtualMemory', 'VerQueryValueW', 'SHGetPathFromIDListA', 'VirtualProtectEx', 'EnableTrace', 'CreateFileMappingW', 'StrStrIA', 'DnsQuery_A', 'CryptAcquireContextA', 'GetSidIdentifierAuthority', 'ReadProcessMemory', 'DeleteProcThreadAttributeList', 'NtQueryInformationThread', 'StrStrIW', 'DnsQuery_W', 'CryptMsgClose', 'CreateFileMappingA', 'Thread32Next', 'DuplicateHandle', 'CreateFileTransactedW', 'RtlDosPathNameToNtPathName_U', 'GetClassNameW', 'OpenServiceW', 'GetProductInfo', 'NtCreateSection', 'CreateProcessA', 'CryptMsgOpenToDecode', 'FindFirstVolumeA', 'FreeSid', 'GetSidLengthRequired', 'CryptMsgControl', 'CreateFileW', 'CryptSignAndEncryptMessage', 'NtWow64WriteVirtualMemory64', 'EvtNextPublisherId', 'GetTokenInformation', 'EvtNextEventMetadata', 'ShellExecuteA', 'FindFirstVolumeW', 'OpenClipboard', 'GetLastError', 'NtAlpcCreatePort', 'FreeConsole', 'GetShortPathNameW', 'CreateNamedPipeW', 'GetSecurityDescriptorControl', 'GlobalFree', 'ResumeThread', 'AlpcGetMessageAttribute', 'AdjustTokenPrivileges', 'CryptReleaseContext', 'GetProcessTimes', 'GetIfTable', 'CryptEncryptMessage', 'SymFromName', 'CreateNamedPipeA', 'GetShortPathNameA', 'NtMapViewOfSection', 'CreateProcessW', 'ConvertStringSidToSidW', 'FindNextVolumeW', 'GetCurrentProcessorNumber', 'RegGetValueW', 'LockResource', 'UpdateProcThreadAttribute', 'MessageBoxA', 'GetClassNameA', 'SetTokenInformation', 'Wow64EnableWow64FsRedirection', 'NtAlpcDeleteSectionView', 'CertGetCertificateChain', 'RegGetValueA', 'EvtGetObjectArrayProperty', 'Process32FirstW', 'EnumerateTraceGuidsEx', 'LookupPrivilegeNameW', 'CoCreateInstance', 'RtlEqualUnicodeString', 'NtOpenFile', 'RealGetWindowClassW', 'lstrcmpA', 'RollbackTransaction', 'NtQueryVolumeInformationFile', 'NtQueryDirectoryFile', 'ReadFile', 'CreateFileTransactedA', 'CryptCATAdminCalcHashFromFileHandle', 'CertGetCertificateContextProperty', 'NtFreeVirtualMemory', 'ControlTraceW', 'Process32First', 'GetLengthSid', 'GetClipboardFormatNameA', 'PFXExportCertStoreEx', 'RealGetWindowClassA', 'CryptAcquireContextW', 'CertFreeCTLContext', 'CertGetNameStringA', 'GetLongPathNameW', 'DeviceIoControl', 'SymFromAddr', 'GetThreadId', 'CLSIDFromProgID', 'SymGetTypeFromName', 'FindResourceW', 'NtAlpcRevokeSecurityContext', 'DnsFree', 'IsOS', 'GetLongPathNameA', 'Sleep', 'CertGetNameStringW', 'EvtNext', 'CloseClipboard', 'RtlInitString', 'FindResourceA', 'VirtualAlloc']) +interfaces = set(['IUnknown', 'ITypeInfo', 'ITaskService', 'INetFwPolicy2', 'IRunningTaskCollection', 'IActionCollection', 'IShellLinkW', 'IPersistFile', 'INetFwRules', 'IAction', 'IWbemContext', 'INetFwServiceRestriction', 'ITypeComp', 'ITrigger', 'IShellLinkA', 'ICallFrame', 'IEnumVARIANT', 'ICallInterceptor', 'IWbemObjectSink', 'IBackgroundCopyManager', 'IEnumBackgroundCopyJobs', 'ITypeLib', 'IWebBrowser2', 'IPrincipal', 'ITaskSettings', 'IWbemLocator', 'INetFwRule', 'ITaskNamedValueCollection', 'IExecAction', 'IBackgroundCopyFile', 'IWbemCallResult', 'INetworkSettings', 'ITaskFolder', 'ICallFrameWalker', 'IRunningTask', 'IRegistrationInfo', 'IWbemServices', 'IBackgroundCopyFile2', 'IBackgroundCopyFile3', 'IIdleSettings', 'IEnumBackgroundCopyFiles', 'IDispatch', 'IComHandlerAction', 'IPersist', 'IBackgroundCopyError', 'IRepetitionPattern', 'ITaskFolderCollection', 'ICallFrameEvents', 'IWbemQualifierSet', 'IWbemClassObject', 'IShowMessageAction', 'ITaskNamedValuePair', 'ITaskDefinition', 'IBackgroundCopyJob', 'IBackgroundCopyJob2', 'IRegisteredTask', 'IRegisteredTaskCollection', 'IEnumWbemClassObject', 'IEmailAction', 'IBackgroundCopyCallback', 'ITriggerCollection']) def generate_walker(namelist, target_module): def my_walker(): diff --git a/windows/generated_def/windef.py b/windows/generated_def/windef.py index 1c11a79..fce3892 100644 --- a/windows/generated_def/windef.py +++ b/windows/generated_def/windef.py @@ -6,172 +6,12 @@ bitness = int(bits[:2]) NATIVE_WORD_MAX_VALUE = 0xffffffff if bitness == 32 else 0xffffffffffffffff from ntstatus import * -CWCSTORAGENAME = make_flag("CWCSTORAGENAME", 32) -STGM_DIRECT = make_flag("STGM_DIRECT", 0x00000000) -STGM_TRANSACTED = make_flag("STGM_TRANSACTED", 0x00010000) -STGM_SIMPLE = make_flag("STGM_SIMPLE", 0x08000000) -STGM_READ = make_flag("STGM_READ", 0x00000000) -STGM_WRITE = make_flag("STGM_WRITE", 0x00000001) -STGM_READWRITE = make_flag("STGM_READWRITE", 0x00000002) -STGM_SHARE_DENY_NONE = make_flag("STGM_SHARE_DENY_NONE", 0x00000040) -STGM_SHARE_DENY_READ = make_flag("STGM_SHARE_DENY_READ", 0x00000030) -STGM_SHARE_DENY_WRITE = make_flag("STGM_SHARE_DENY_WRITE", 0x00000020) -STGM_SHARE_EXCLUSIVE = make_flag("STGM_SHARE_EXCLUSIVE", 0x00000010) -STGM_PRIORITY = make_flag("STGM_PRIORITY", 0x00040000) -STGM_DELETEONRELEASE = make_flag("STGM_DELETEONRELEASE", 0x04000000) -STGM_NOSCRATCH = make_flag("STGM_NOSCRATCH", 0x00100000) -STGM_CREATE = make_flag("STGM_CREATE", 0x00001000) -STGM_CONVERT = make_flag("STGM_CONVERT", 0x00020000) -STGM_FAILIFTHERE = make_flag("STGM_FAILIFTHERE", 0x00000000) -STGM_NOSNAPSHOT = make_flag("STGM_NOSNAPSHOT", 0x00200000) -STGM_DIRECT_SWMR = make_flag("STGM_DIRECT_SWMR", 0x00400000) -ASYNC_MODE_COMPATIBILITY = make_flag("ASYNC_MODE_COMPATIBILITY", 0x00000001) -ASYNC_MODE_DEFAULT = make_flag("ASYNC_MODE_DEFAULT", 0x00000000) -STGTY_REPEAT = make_flag("STGTY_REPEAT", 0x00000100) -STG_TOEND = make_flag("STG_TOEND", 0xFFFFFFFF) -STG_LAYOUT_SEQUENTIAL = make_flag("STG_LAYOUT_SEQUENTIAL", 0x00000000) -STG_LAYOUT_INTERLEAVED = make_flag("STG_LAYOUT_INTERLEAVED", 0x00000001) -STGFMT_STORAGE = make_flag("STGFMT_STORAGE", 0) -STGFMT_NATIVE = make_flag("STGFMT_NATIVE", 1) -STGFMT_FILE = make_flag("STGFMT_FILE", 3) -STGFMT_ANY = make_flag("STGFMT_ANY", 4) -STGFMT_DOCFILE = make_flag("STGFMT_DOCFILE", 5) -STGFMT_DOCUMENT = make_flag("STGFMT_DOCUMENT", 0) -ACCESS_MIN_MS_ACE_TYPE = make_flag("ACCESS_MIN_MS_ACE_TYPE", ( 0x0 )) -ACCESS_ALLOWED_ACE_TYPE = make_flag("ACCESS_ALLOWED_ACE_TYPE", ( 0x0 )) -ACCESS_DENIED_ACE_TYPE = make_flag("ACCESS_DENIED_ACE_TYPE", ( 0x1 )) -SYSTEM_AUDIT_ACE_TYPE = make_flag("SYSTEM_AUDIT_ACE_TYPE", ( 0x2 )) -SYSTEM_ALARM_ACE_TYPE = make_flag("SYSTEM_ALARM_ACE_TYPE", ( 0x3 )) -ACCESS_MAX_MS_V2_ACE_TYPE = make_flag("ACCESS_MAX_MS_V2_ACE_TYPE", ( 0x3 )) -ACCESS_ALLOWED_COMPOUND_ACE_TYPE = make_flag("ACCESS_ALLOWED_COMPOUND_ACE_TYPE", ( 0x4 )) -ACCESS_MAX_MS_V3_ACE_TYPE = make_flag("ACCESS_MAX_MS_V3_ACE_TYPE", ( 0x4 )) -ACCESS_MIN_MS_OBJECT_ACE_TYPE = make_flag("ACCESS_MIN_MS_OBJECT_ACE_TYPE", ( 0x5 )) -ACCESS_ALLOWED_OBJECT_ACE_TYPE = make_flag("ACCESS_ALLOWED_OBJECT_ACE_TYPE", ( 0x5 )) -ACCESS_DENIED_OBJECT_ACE_TYPE = make_flag("ACCESS_DENIED_OBJECT_ACE_TYPE", ( 0x6 )) -SYSTEM_AUDIT_OBJECT_ACE_TYPE = make_flag("SYSTEM_AUDIT_OBJECT_ACE_TYPE", ( 0x7 )) -SYSTEM_ALARM_OBJECT_ACE_TYPE = make_flag("SYSTEM_ALARM_OBJECT_ACE_TYPE", ( 0x8 )) -ACCESS_MAX_MS_OBJECT_ACE_TYPE = make_flag("ACCESS_MAX_MS_OBJECT_ACE_TYPE", ( 0x8 )) -ACCESS_MAX_MS_V4_ACE_TYPE = make_flag("ACCESS_MAX_MS_V4_ACE_TYPE", ( 0x8 )) -ACCESS_MAX_MS_ACE_TYPE = make_flag("ACCESS_MAX_MS_ACE_TYPE", ( 0x8 )) -ACCESS_ALLOWED_CALLBACK_ACE_TYPE = make_flag("ACCESS_ALLOWED_CALLBACK_ACE_TYPE", ( 0x9 )) -ACCESS_DENIED_CALLBACK_ACE_TYPE = make_flag("ACCESS_DENIED_CALLBACK_ACE_TYPE", ( 0xA )) -ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE = make_flag("ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE", ( 0xB )) -ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE = make_flag("ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE", ( 0xC )) -SYSTEM_AUDIT_CALLBACK_ACE_TYPE = make_flag("SYSTEM_AUDIT_CALLBACK_ACE_TYPE", ( 0xD )) -SYSTEM_ALARM_CALLBACK_ACE_TYPE = make_flag("SYSTEM_ALARM_CALLBACK_ACE_TYPE", ( 0xE )) -SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE = make_flag("SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE", ( 0xF )) -SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE = make_flag("SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE", ( 0x10 )) -SYSTEM_MANDATORY_LABEL_ACE_TYPE = make_flag("SYSTEM_MANDATORY_LABEL_ACE_TYPE", ( 0x11 )) -ACCESS_MAX_MS_V5_ACE_TYPE = make_flag("ACCESS_MAX_MS_V5_ACE_TYPE", ( 0x11 )) -SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE = make_flag("SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE", ( 0x12 )) -SYSTEM_SCOPED_POLICY_ID_ACE_TYPE = make_flag("SYSTEM_SCOPED_POLICY_ID_ACE_TYPE", ( 0x13 )) -SYSTEM_PROCESS_TRUST_LABEL_ACE_TYPE = make_flag("SYSTEM_PROCESS_TRUST_LABEL_ACE_TYPE", ( 0x14 )) -ACCESS_MAX_MS_V5_ACE_TYPE = make_flag("ACCESS_MAX_MS_V5_ACE_TYPE", ( 0x14 )) -SEC_WINNT_AUTH_IDENTITY_ANSI = make_flag("SEC_WINNT_AUTH_IDENTITY_ANSI", 0x1) -SEC_WINNT_AUTH_IDENTITY_UNICODE = make_flag("SEC_WINNT_AUTH_IDENTITY_UNICODE", 0x2) -SE_OWNER_DEFAULTED = make_flag("SE_OWNER_DEFAULTED", 0x00000001) -SE_GROUP_DEFAULTED = make_flag("SE_GROUP_DEFAULTED", 0x00000002) -SE_DACL_PRESENT = make_flag("SE_DACL_PRESENT", 0x00000004) -SE_DACL_DEFAULTED = make_flag("SE_DACL_DEFAULTED", 0x00000008) -SE_SACL_PRESENT = make_flag("SE_SACL_PRESENT", 0x00000010) -SE_SACL_DEFAULTED = make_flag("SE_SACL_DEFAULTED", 0x00000020) -SE_DACL_AUTO_INHERIT_REQ = make_flag("SE_DACL_AUTO_INHERIT_REQ", 0x00000100) -SE_SACL_AUTO_INHERIT_REQ = make_flag("SE_SACL_AUTO_INHERIT_REQ", 0x00000200) -SE_DACL_AUTO_INHERITED = make_flag("SE_DACL_AUTO_INHERITED", 0x00000400) -SE_SACL_AUTO_INHERITED = make_flag("SE_SACL_AUTO_INHERITED", 0x00000800) -SE_DACL_PROTECTED = make_flag("SE_DACL_PROTECTED", 0x00001000) -SE_SACL_PROTECTED = make_flag("SE_SACL_PROTECTED", 0x00002000) -SE_RM_CONTROL_VALID = make_flag("SE_RM_CONTROL_VALID", 0x00004000) -SE_SELF_RELATIVE = make_flag("SE_SELF_RELATIVE", 0x00008000) -SDDL_REVISION_1 = make_flag("SDDL_REVISION_1", 0x1) -ACE_OBJECT_TYPE_PRESENT = make_flag("ACE_OBJECT_TYPE_PRESENT", 0x1) -ACE_INHERITED_OBJECT_TYPE_PRESENT = make_flag("ACE_INHERITED_OBJECT_TYPE_PRESENT", 0x2) -OBJECT_INHERIT_ACE = make_flag("OBJECT_INHERIT_ACE", ( 0x1 )) -CONTAINER_INHERIT_ACE = make_flag("CONTAINER_INHERIT_ACE", ( 0x2 )) -NO_PROPAGATE_INHERIT_ACE = make_flag("NO_PROPAGATE_INHERIT_ACE", ( 0x4 )) -INHERIT_ONLY_ACE = make_flag("INHERIT_ONLY_ACE", ( 0x8 )) -INHERITED_ACE = make_flag("INHERITED_ACE", ( 0x10 )) -VALID_INHERIT_FLAGS = make_flag("VALID_INHERIT_FLAGS", ( 0x1F )) -SUCCESSFUL_ACCESS_ACE_FLAG = make_flag("SUCCESSFUL_ACCESS_ACE_FLAG", ( 0x40 )) -FAILED_ACCESS_ACE_FLAG = make_flag("FAILED_ACCESS_ACE_FLAG", ( 0x80 )) -SYSTEM_MANDATORY_LABEL_NO_WRITE_UP = make_flag("SYSTEM_MANDATORY_LABEL_NO_WRITE_UP", 0x1) -SYSTEM_MANDATORY_LABEL_NO_READ_UP = make_flag("SYSTEM_MANDATORY_LABEL_NO_READ_UP", 0x2) -SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP = make_flag("SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP", 0x4) -SYSTEM_PROCESS_TRUST_LABEL_VALID_MASK = make_flag("SYSTEM_PROCESS_TRUST_LABEL_VALID_MASK", 0x00ffffff) -SYSTEM_PROCESS_TRUST_NOCONSTRAINT_MASK = make_flag("SYSTEM_PROCESS_TRUST_NOCONSTRAINT_MASK", 0xffffffff) -CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID", 0x00) -CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64 = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64", 0x01) -CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64 = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64", 0x02) -CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING", 0x03) -CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN", 0x04) -CLAIM_SECURITY_ATTRIBUTE_TYPE_SID = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_SID", 0x05) -CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN", 0x06) -CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING", 0x10) -SE_GROUP_MANDATORY = make_flag("SE_GROUP_MANDATORY", ( 0x00000001 )) -SE_GROUP_ENABLED_BY_DEFAULT = make_flag("SE_GROUP_ENABLED_BY_DEFAULT", ( 0x00000002 )) -SE_GROUP_ENABLED = make_flag("SE_GROUP_ENABLED", ( 0x00000004 )) -SE_GROUP_OWNER = make_flag("SE_GROUP_OWNER", ( 0x00000008 )) -SE_GROUP_USE_FOR_DENY_ONLY = make_flag("SE_GROUP_USE_FOR_DENY_ONLY", ( 0x00000010 )) -SE_GROUP_INTEGRITY = make_flag("SE_GROUP_INTEGRITY", ( 0x00000020 )) -SE_GROUP_INTEGRITY_ENABLED = make_flag("SE_GROUP_INTEGRITY_ENABLED", ( 0x00000040 )) -SE_GROUP_LOGON_ID = make_flag("SE_GROUP_LOGON_ID", ( 0xC0000000 )) -SE_GROUP_RESOURCE = make_flag("SE_GROUP_RESOURCE", ( 0x20000000 )) -SE_GROUP_VALID_ATTRIBUTES = make_flag("SE_GROUP_VALID_ATTRIBUTES", ( SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED | SE_GROUP_OWNER | SE_GROUP_USE_FOR_DENY_ONLY | SE_GROUP_LOGON_ID | SE_GROUP_RESOURCE | SE_GROUP_INTEGRITY | SE_GROUP_INTEGRITY_ENABLED )) -OWNER_SECURITY_INFORMATION = make_flag("OWNER_SECURITY_INFORMATION", ( 0x00000001 )) -GROUP_SECURITY_INFORMATION = make_flag("GROUP_SECURITY_INFORMATION", ( 0x00000002 )) -DACL_SECURITY_INFORMATION = make_flag("DACL_SECURITY_INFORMATION", ( 0x00000004 )) -SACL_SECURITY_INFORMATION = make_flag("SACL_SECURITY_INFORMATION", ( 0x00000008 )) -LABEL_SECURITY_INFORMATION = make_flag("LABEL_SECURITY_INFORMATION", ( 0x00000010 )) -ATTRIBUTE_SECURITY_INFORMATION = make_flag("ATTRIBUTE_SECURITY_INFORMATION", ( 0x00000020 )) -SCOPE_SECURITY_INFORMATION = make_flag("SCOPE_SECURITY_INFORMATION", ( 0x00000040 )) -PROCESS_TRUST_LABEL_SECURITY_INFORMATION = make_flag("PROCESS_TRUST_LABEL_SECURITY_INFORMATION", ( 0x00000080 )) -BACKUP_SECURITY_INFORMATION = make_flag("BACKUP_SECURITY_INFORMATION", ( 0x00010000 )) -PROTECTED_DACL_SECURITY_INFORMATION = make_flag("PROTECTED_DACL_SECURITY_INFORMATION", ( 0x80000000 )) -PROTECTED_SACL_SECURITY_INFORMATION = make_flag("PROTECTED_SACL_SECURITY_INFORMATION", ( 0x40000000 )) -UNPROTECTED_DACL_SECURITY_INFORMATION = make_flag("UNPROTECTED_DACL_SECURITY_INFORMATION", ( 0x20000000 )) -UNPROTECTED_SACL_SECURITY_INFORMATION = make_flag("UNPROTECTED_SACL_SECURITY_INFORMATION", ( 0x10000000 )) -IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA = make_flag("IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA", 0x0020) -IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE = make_flag("IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE", 0x0040) -IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY = make_flag("IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY", 0x0080) -IMAGE_DLLCHARACTERISTICS_NX_COMPAT = make_flag("IMAGE_DLLCHARACTERISTICS_NX_COMPAT", 0x0100) -IMAGE_DLLCHARACTERISTICS_NO_ISOLATION = make_flag("IMAGE_DLLCHARACTERISTICS_NO_ISOLATION", 0x0200) -IMAGE_DLLCHARACTERISTICS_NO_SEH = make_flag("IMAGE_DLLCHARACTERISTICS_NO_SEH", 0x0400) -IMAGE_DLLCHARACTERISTICS_NO_BIND = make_flag("IMAGE_DLLCHARACTERISTICS_NO_BIND", 0x0800) -IMAGE_DLLCHARACTERISTICS_APPCONTAINER = make_flag("IMAGE_DLLCHARACTERISTICS_APPCONTAINER", 0x1000) -IMAGE_DLLCHARACTERISTICS_WDM_DRIVER = make_flag("IMAGE_DLLCHARACTERISTICS_WDM_DRIVER", 0x2000) -IMAGE_DLLCHARACTERISTICS_GUARD_CF = make_flag("IMAGE_DLLCHARACTERISTICS_GUARD_CF", 0x4000) -IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE = make_flag("IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE", 0x8000) -IMAGE_DIRECTORY_ENTRY_EXPORT = make_flag("IMAGE_DIRECTORY_ENTRY_EXPORT", 0) -IMAGE_DIRECTORY_ENTRY_IMPORT = make_flag("IMAGE_DIRECTORY_ENTRY_IMPORT", 1) -IMAGE_DIRECTORY_ENTRY_RESOURCE = make_flag("IMAGE_DIRECTORY_ENTRY_RESOURCE", 2) -IMAGE_DIRECTORY_ENTRY_EXCEPTION = make_flag("IMAGE_DIRECTORY_ENTRY_EXCEPTION", 3) -IMAGE_DIRECTORY_ENTRY_SECURITY = make_flag("IMAGE_DIRECTORY_ENTRY_SECURITY", 4) -IMAGE_DIRECTORY_ENTRY_BASERELOC = make_flag("IMAGE_DIRECTORY_ENTRY_BASERELOC", 5) -IMAGE_DIRECTORY_ENTRY_DEBUG = make_flag("IMAGE_DIRECTORY_ENTRY_DEBUG", 6) -IMAGE_DIRECTORY_ENTRY_ARCHITECTURE = make_flag("IMAGE_DIRECTORY_ENTRY_ARCHITECTURE", 7) -IMAGE_DIRECTORY_ENTRY_GLOBALPTR = make_flag("IMAGE_DIRECTORY_ENTRY_GLOBALPTR", 8) -IMAGE_DIRECTORY_ENTRY_TLS = make_flag("IMAGE_DIRECTORY_ENTRY_TLS", 9) -IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG = make_flag("IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG", 10) -IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT = make_flag("IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT", 11) -IMAGE_DIRECTORY_ENTRY_IAT = make_flag("IMAGE_DIRECTORY_ENTRY_IAT", 12) -IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT = make_flag("IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT", 13) -IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR = make_flag("IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR", 14) -IMAGE_REL_BASED_ABSOLUTE = make_flag("IMAGE_REL_BASED_ABSOLUTE", 0) -IMAGE_REL_BASED_HIGH = make_flag("IMAGE_REL_BASED_HIGH", 1) -IMAGE_REL_BASED_LOW = make_flag("IMAGE_REL_BASED_LOW", 2) -IMAGE_REL_BASED_HIGHLOW = make_flag("IMAGE_REL_BASED_HIGHLOW", 3) -IMAGE_REL_BASED_HIGHADJ = make_flag("IMAGE_REL_BASED_HIGHADJ", 4) -IMAGE_REL_BASED_MACHINE_SPECIFIC_5 = make_flag("IMAGE_REL_BASED_MACHINE_SPECIFIC_5", 5) -IMAGE_REL_BASED_RESERVED = make_flag("IMAGE_REL_BASED_RESERVED", 6) -IMAGE_REL_BASED_MACHINE_SPECIFIC_7 = make_flag("IMAGE_REL_BASED_MACHINE_SPECIFIC_7", 7) -IMAGE_REL_BASED_MACHINE_SPECIFIC_8 = make_flag("IMAGE_REL_BASED_MACHINE_SPECIFIC_8", 8) -IMAGE_REL_BASED_MACHINE_SPECIFIC_9 = make_flag("IMAGE_REL_BASED_MACHINE_SPECIFIC_9", 9) -IMAGE_REL_BASED_DIR64 = make_flag("IMAGE_REL_BASED_DIR64", 10) -FC_ALLOCATE_ALL_NODES = make_flag("FC_ALLOCATE_ALL_NODES", 0x01) -FC_DONT_FREE = make_flag("FC_DONT_FREE", 0x02) -FC_ALLOCED_ON_STACK = make_flag("FC_ALLOCED_ON_STACK", 0x04) -FC_SIMPLE_POINTER = make_flag("FC_SIMPLE_POINTER", 0x08) -FC_POINTER_DEREF = make_flag("FC_POINTER_DEREF", 0x10) +BG_JOB_ENUM_ALL_USERS = make_flag("BG_JOB_ENUM_ALL_USERS", 0x0001) +BG_NOTIFY_JOB_TRANSFERRED = make_flag("BG_NOTIFY_JOB_TRANSFERRED", 0x0001) +BG_NOTIFY_JOB_ERROR = make_flag("BG_NOTIFY_JOB_ERROR", 0x0002) +BG_NOTIFY_DISABLE = make_flag("BG_NOTIFY_DISABLE", 0x0004) +BG_NOTIFY_JOB_MODIFICATION = make_flag("BG_NOTIFY_JOB_MODIFICATION", 0x0008) +BG_NOTIFY_FILE_TRANSFERRED = make_flag("BG_NOTIFY_FILE_TRANSFERRED", 0x0010) SERVICE_TRIGGER_TYPE_DEVICE_INTERFACE_ARRIVAL = make_flag("SERVICE_TRIGGER_TYPE_DEVICE_INTERFACE_ARRIVAL", 1) SERVICE_TRIGGER_TYPE_IP_ADDRESS_AVAILABILITY = make_flag("SERVICE_TRIGGER_TYPE_IP_ADDRESS_AVAILABILITY", 2) SERVICE_TRIGGER_TYPE_DOMAIN_JOIN = make_flag("SERVICE_TRIGGER_TYPE_DOMAIN_JOIN", 3) @@ -185,6 +25,1404 @@ SERVICE_TRIGGER_DATA_TYPE_STRING = make_flag("SERVICE_TRIGGER_DATA_TYPE_STRING", SERVICE_TRIGGER_DATA_TYPE_LEVEL = make_flag("SERVICE_TRIGGER_DATA_TYPE_LEVEL", 3) SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ANY = make_flag("SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ANY", 4) SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ALL = make_flag("SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ALL", 5) +INVALID_HANDLE_VALUE = make_flag("INVALID_HANDLE_VALUE", ( ( -1 ) & NATIVE_WORD_MAX_VALUE )) +NULL = make_flag("NULL", 0) +MAX_PATH = make_flag("MAX_PATH", 260) +ANYSIZE_ARRAY = make_flag("ANYSIZE_ARRAY", 1) +ANY_SIZE = make_flag("ANY_SIZE", 1) +IMAGE_SIZEOF_SHORT_NAME = make_flag("IMAGE_SIZEOF_SHORT_NAME", 8) +IMAGE_NUMBEROF_DIRECTORY_ENTRIES = make_flag("IMAGE_NUMBEROF_DIRECTORY_ENTRIES", 16) +INFINITE = make_flag("INFINITE", 0xFFFFFFFF) +STD_INPUT_HANDLE = make_flag("STD_INPUT_HANDLE", -10) +STD_OUTPUT_HANDLE = make_flag("STD_OUTPUT_HANDLE", -11) +STD_ERROR_HANDLE = make_flag("STD_ERROR_HANDLE", -12) +WARMING_NOT_SAME_FLAG_FOR_WINXP = make_flag("WARMING_NOT_SAME_FLAG_FOR_WINXP", 0) +STARTF_USESHOWWINDOW = make_flag("STARTF_USESHOWWINDOW", 0x00000001) +STARTF_USESIZE = make_flag("STARTF_USESIZE", 0x00000002) +STARTF_USEPOSITION = make_flag("STARTF_USEPOSITION", 0x00000004) +STARTF_USECOUNTCHARS = make_flag("STARTF_USECOUNTCHARS", 0x00000008) +STARTF_USEFILLATTRIBUTE = make_flag("STARTF_USEFILLATTRIBUTE", 0x00000010) +STARTF_RUNFULLSCREEN = make_flag("STARTF_RUNFULLSCREEN", 0x00000020) +STARTF_FORCEONFEEDBACK = make_flag("STARTF_FORCEONFEEDBACK", 0x00000040) +STARTF_FORCEOFFFEEDBACK = make_flag("STARTF_FORCEOFFFEEDBACK", 0x00000080) +STARTF_USESTDHANDLES = make_flag("STARTF_USESTDHANDLES", 0x00000100) +SW_HIDE = make_flag("SW_HIDE", 0) +SW_SHOWNORMAL = make_flag("SW_SHOWNORMAL", 1) +SW_NORMAL = make_flag("SW_NORMAL", 1) +SW_SHOWMINIMIZED = make_flag("SW_SHOWMINIMIZED", 2) +SW_SHOWMAXIMIZED = make_flag("SW_SHOWMAXIMIZED", 3) +SW_MAXIMIZE = make_flag("SW_MAXIMIZE", 3) +SW_SHOWNOACTIVATE = make_flag("SW_SHOWNOACTIVATE", 4) +SW_SHOW = make_flag("SW_SHOW", 5) +SW_MINIMIZE = make_flag("SW_MINIMIZE", 6) +SW_SHOWMINNOACTIVE = make_flag("SW_SHOWMINNOACTIVE", 7) +SW_SHOWNA = make_flag("SW_SHOWNA", 8) +SW_RESTORE = make_flag("SW_RESTORE", 9) +SW_SHOWDEFAULT = make_flag("SW_SHOWDEFAULT", 10) +SW_FORCEMINIMIZE = make_flag("SW_FORCEMINIMIZE", 11) +SW_MAX = make_flag("SW_MAX", 11) +DEBUG_PROCESS = make_flag("DEBUG_PROCESS", 0x00000001) +DEBUG_ONLY_THIS_PROCESS = make_flag("DEBUG_ONLY_THIS_PROCESS", 0x00000002) +CREATE_SUSPENDED = make_flag("CREATE_SUSPENDED", 0x00000004) +DETACHED_PROCESS = make_flag("DETACHED_PROCESS", 0x00000008) +CREATE_NEW_CONSOLE = make_flag("CREATE_NEW_CONSOLE", 0x00000010) +NORMAL_PRIORITY_CLASS = make_flag("NORMAL_PRIORITY_CLASS", 0x00000020) +IDLE_PRIORITY_CLASS = make_flag("IDLE_PRIORITY_CLASS", 0x00000040) +HIGH_PRIORITY_CLASS = make_flag("HIGH_PRIORITY_CLASS", 0x00000080) +REALTIME_PRIORITY_CLASS = make_flag("REALTIME_PRIORITY_CLASS", 0x00000100) +CREATE_NEW_PROCESS_GROUP = make_flag("CREATE_NEW_PROCESS_GROUP", 0x00000200) +CREATE_UNICODE_ENVIRONMENT = make_flag("CREATE_UNICODE_ENVIRONMENT", 0x00000400) +CREATE_SEPARATE_WOW_VDM = make_flag("CREATE_SEPARATE_WOW_VDM", 0x00000800) +CREATE_SHARED_WOW_VDM = make_flag("CREATE_SHARED_WOW_VDM", 0x00001000) +CREATE_FORCEDOS = make_flag("CREATE_FORCEDOS", 0x00002000) +BELOW_NORMAL_PRIORITY_CLASS = make_flag("BELOW_NORMAL_PRIORITY_CLASS", 0x00004000) +ABOVE_NORMAL_PRIORITY_CLASS = make_flag("ABOVE_NORMAL_PRIORITY_CLASS", 0x00008000) +INHERIT_PARENT_AFFINITY = make_flag("INHERIT_PARENT_AFFINITY", 0x00010000) +INHERIT_CALLER_PRIORITY = make_flag("INHERIT_CALLER_PRIORITY", 0x00020000) +CREATE_PROTECTED_PROCESS = make_flag("CREATE_PROTECTED_PROCESS", 0x00040000) +EXTENDED_STARTUPINFO_PRESENT = make_flag("EXTENDED_STARTUPINFO_PRESENT", 0x00080000) +PROCESS_MODE_BACKGROUND_BEGIN = make_flag("PROCESS_MODE_BACKGROUND_BEGIN", 0x00100000) +PROCESS_MODE_BACKGROUND_END = make_flag("PROCESS_MODE_BACKGROUND_END", 0x00200000) +CREATE_BREAKAWAY_FROM_JOB = make_flag("CREATE_BREAKAWAY_FROM_JOB", 0x01000000) +CREATE_PRESERVE_CODE_AUTHZ_LEVEL = make_flag("CREATE_PRESERVE_CODE_AUTHZ_LEVEL", 0x02000000) +CREATE_DEFAULT_ERROR_MODE = make_flag("CREATE_DEFAULT_ERROR_MODE", 0x04000000) +CREATE_NO_WINDOW = make_flag("CREATE_NO_WINDOW", 0x08000000) +PROFILE_USER = make_flag("PROFILE_USER", 0x10000000) +PROFILE_KERNEL = make_flag("PROFILE_KERNEL", 0x20000000) +PROFILE_SERVER = make_flag("PROFILE_SERVER", 0x40000000) +CREATE_IGNORE_SYSTEM_DEFAULT = make_flag("CREATE_IGNORE_SYSTEM_DEFAULT", 0x80000000) +WAIT_IO_COMPLETION = make_flag("WAIT_IO_COMPLETION", STATUS_USER_APC) +STILL_ACTIVE = make_flag("STILL_ACTIVE", STATUS_PENDING) +EXCEPTION_ACCESS_VIOLATION = make_flag("EXCEPTION_ACCESS_VIOLATION", STATUS_ACCESS_VIOLATION) +EXCEPTION_DATATYPE_MISALIGNMENT = make_flag("EXCEPTION_DATATYPE_MISALIGNMENT", STATUS_DATATYPE_MISALIGNMENT) +EXCEPTION_BREAKPOINT = make_flag("EXCEPTION_BREAKPOINT", STATUS_BREAKPOINT) +EXCEPTION_SINGLE_STEP = make_flag("EXCEPTION_SINGLE_STEP", STATUS_SINGLE_STEP) +EXCEPTION_ARRAY_BOUNDS_EXCEEDED = make_flag("EXCEPTION_ARRAY_BOUNDS_EXCEEDED", STATUS_ARRAY_BOUNDS_EXCEEDED) +EXCEPTION_FLT_DENORMAL_OPERAND = make_flag("EXCEPTION_FLT_DENORMAL_OPERAND", STATUS_FLOAT_DENORMAL_OPERAND) +EXCEPTION_FLT_DIVIDE_BY_ZERO = make_flag("EXCEPTION_FLT_DIVIDE_BY_ZERO", STATUS_FLOAT_DIVIDE_BY_ZERO) +EXCEPTION_FLT_INEXACT_RESULT = make_flag("EXCEPTION_FLT_INEXACT_RESULT", STATUS_FLOAT_INEXACT_RESULT) +EXCEPTION_FLT_INVALID_OPERATION = make_flag("EXCEPTION_FLT_INVALID_OPERATION", STATUS_FLOAT_INVALID_OPERATION) +EXCEPTION_FLT_OVERFLOW = make_flag("EXCEPTION_FLT_OVERFLOW", STATUS_FLOAT_OVERFLOW) +EXCEPTION_FLT_STACK_CHECK = make_flag("EXCEPTION_FLT_STACK_CHECK", STATUS_FLOAT_STACK_CHECK) +EXCEPTION_FLT_UNDERFLOW = make_flag("EXCEPTION_FLT_UNDERFLOW", STATUS_FLOAT_UNDERFLOW) +EXCEPTION_INT_DIVIDE_BY_ZERO = make_flag("EXCEPTION_INT_DIVIDE_BY_ZERO", STATUS_INTEGER_DIVIDE_BY_ZERO) +EXCEPTION_INT_OVERFLOW = make_flag("EXCEPTION_INT_OVERFLOW", STATUS_INTEGER_OVERFLOW) +EXCEPTION_PRIV_INSTRUCTION = make_flag("EXCEPTION_PRIV_INSTRUCTION", STATUS_PRIVILEGED_INSTRUCTION) +EXCEPTION_IN_PAGE_ERROR = make_flag("EXCEPTION_IN_PAGE_ERROR", STATUS_IN_PAGE_ERROR) +EXCEPTION_ILLEGAL_INSTRUCTION = make_flag("EXCEPTION_ILLEGAL_INSTRUCTION", STATUS_ILLEGAL_INSTRUCTION) +EXCEPTION_NONCONTINUABLE_EXCEPTION = make_flag("EXCEPTION_NONCONTINUABLE_EXCEPTION", STATUS_NONCONTINUABLE_EXCEPTION) +EXCEPTION_STACK_OVERFLOW = make_flag("EXCEPTION_STACK_OVERFLOW", STATUS_STACK_OVERFLOW) +EXCEPTION_INVALID_DISPOSITION = make_flag("EXCEPTION_INVALID_DISPOSITION", STATUS_INVALID_DISPOSITION) +EXCEPTION_GUARD_PAGE = make_flag("EXCEPTION_GUARD_PAGE", STATUS_GUARD_PAGE_VIOLATION) +EXCEPTION_INVALID_HANDLE = make_flag("EXCEPTION_INVALID_HANDLE", STATUS_INVALID_HANDLE) +EXCEPTION_POSSIBLE_DEADLOCK = make_flag("EXCEPTION_POSSIBLE_DEADLOCK", STATUS_POSSIBLE_DEADLOCK) +CONTROL_C_EXIT = make_flag("CONTROL_C_EXIT", STATUS_CONTROL_C_EXIT) +EXCEPTION_DEBUG_EVENT = make_flag("EXCEPTION_DEBUG_EVENT", 1) +CREATE_THREAD_DEBUG_EVENT = make_flag("CREATE_THREAD_DEBUG_EVENT", 2) +CREATE_PROCESS_DEBUG_EVENT = make_flag("CREATE_PROCESS_DEBUG_EVENT", 3) +EXIT_THREAD_DEBUG_EVENT = make_flag("EXIT_THREAD_DEBUG_EVENT", 4) +EXIT_PROCESS_DEBUG_EVENT = make_flag("EXIT_PROCESS_DEBUG_EVENT", 5) +LOAD_DLL_DEBUG_EVENT = make_flag("LOAD_DLL_DEBUG_EVENT", 6) +UNLOAD_DLL_DEBUG_EVENT = make_flag("UNLOAD_DLL_DEBUG_EVENT", 7) +OUTPUT_DEBUG_STRING_EVENT = make_flag("OUTPUT_DEBUG_STRING_EVENT", 8) +RIP_EVENT = make_flag("RIP_EVENT", 9) +TH32CS_SNAPHEAPLIST = make_flag("TH32CS_SNAPHEAPLIST", 0x00000001) +TH32CS_SNAPPROCESS = make_flag("TH32CS_SNAPPROCESS", 0x00000002) +TH32CS_SNAPTHREAD = make_flag("TH32CS_SNAPTHREAD", 0x00000004) +TH32CS_SNAPMODULE = make_flag("TH32CS_SNAPMODULE", 0x00000008) +TH32CS_SNAPMODULE32 = make_flag("TH32CS_SNAPMODULE32", 0x00000010) +TH32CS_SNAPALL = make_flag("TH32CS_SNAPALL", ( TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE )) +TH32CS_INHERIT = make_flag("TH32CS_INHERIT", 0x80000000) +CONTEXT_I386 = make_flag("CONTEXT_I386", 0x00010000) +CONTEXT_CONTROL = make_flag("CONTEXT_CONTROL", 0x00000001) +CONTEXT_INTEGER = make_flag("CONTEXT_INTEGER", 0x00000002) +CONTEXT_SEGMENTS = make_flag("CONTEXT_SEGMENTS", 0x00000004) +CONTEXT_FLOATING_POINT = make_flag("CONTEXT_FLOATING_POINT", 0x00000008) +CONTEXT_DEBUG_REGISTERS = make_flag("CONTEXT_DEBUG_REGISTERS", 0x00000010) +CONTEXT_EXTENDED_REGISTERS = make_flag("CONTEXT_EXTENDED_REGISTERS", 0x00000020) +CONTEXT_FULL = make_flag("CONTEXT_FULL", ( CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS )) +CONTEXT_ALL = make_flag("CONTEXT_ALL", ( CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS | CONTEXT_EXTENDED_REGISTERS )) +CONTEXT_FULL = make_flag("CONTEXT_FULL", CONTEXT_I386 | CONTEXT_FULL) +CONTEXT_ALL = make_flag("CONTEXT_ALL", CONTEXT_I386 | CONTEXT_ALL) +CONTEXT_XSTATE = make_flag("CONTEXT_XSTATE", ( CONTEXT_I386 | 0x00000040 )) +PAGE_NOACCESS = make_flag("PAGE_NOACCESS", 0x01) +PAGE_READONLY = make_flag("PAGE_READONLY", 0x02) +PAGE_READWRITE = make_flag("PAGE_READWRITE", 0x04) +PAGE_WRITECOPY = make_flag("PAGE_WRITECOPY", 0x08) +PAGE_EXECUTE = make_flag("PAGE_EXECUTE", 0x10) +PAGE_EXECUTE_READ = make_flag("PAGE_EXECUTE_READ", 0x20) +PAGE_EXECUTE_READWRITE = make_flag("PAGE_EXECUTE_READWRITE", 0x40) +PAGE_EXECUTE_WRITECOPY = make_flag("PAGE_EXECUTE_WRITECOPY", 0x80) +PAGE_GUARD = make_flag("PAGE_GUARD", 0x100) +PAGE_NOCACHE = make_flag("PAGE_NOCACHE", 0x200) +PAGE_WRITECOMBINE = make_flag("PAGE_WRITECOMBINE", 0x400) +MEM_COMMIT = make_flag("MEM_COMMIT", 0x1000) +MEM_RESERVE = make_flag("MEM_RESERVE", 0x2000) +MEM_DECOMMIT = make_flag("MEM_DECOMMIT", 0x4000) +MEM_RELEASE = make_flag("MEM_RELEASE", 0x8000) +MEM_FREE = make_flag("MEM_FREE", 0x10000) +MEM_PRIVATE = make_flag("MEM_PRIVATE", 0x20000) +MEM_MAPPED = make_flag("MEM_MAPPED", 0x40000) +MEM_RESET = make_flag("MEM_RESET", 0x80000) +MEM_TOP_DOWN = make_flag("MEM_TOP_DOWN", 0x100000) +MEM_WRITE_WATCH = make_flag("MEM_WRITE_WATCH", 0x200000) +MEM_PHYSICAL = make_flag("MEM_PHYSICAL", 0x400000) +MEM_ROTATE = make_flag("MEM_ROTATE", 0x800000) +MEM_LARGE_PAGES = make_flag("MEM_LARGE_PAGES", 0x20000000) +MEM_4MB_PAGES = make_flag("MEM_4MB_PAGES", 0x80000000) +SEC_FILE = make_flag("SEC_FILE", 0x800000) +SEC_IMAGE = make_flag("SEC_IMAGE", 0x1000000) +SEC_PROTECTED_IMAGE = make_flag("SEC_PROTECTED_IMAGE", 0x2000000) +SEC_RESERVE = make_flag("SEC_RESERVE", 0x4000000) +SEC_COMMIT = make_flag("SEC_COMMIT", 0x8000000) +SEC_NOCACHE = make_flag("SEC_NOCACHE", 0x10000000) +SEC_WRITECOMBINE = make_flag("SEC_WRITECOMBINE", 0x40000000) +SEC_LARGE_PAGES = make_flag("SEC_LARGE_PAGES", 0x80000000) +MEM_IMAGE = make_flag("MEM_IMAGE", SEC_IMAGE) +WRITE_WATCH_FLAG_RESET = make_flag("WRITE_WATCH_FLAG_RESET", 0x01) +DELETE = make_flag("DELETE", ( 0x00010000 )) +READ_CONTROL = make_flag("READ_CONTROL", ( 0x00020000 )) +WRITE_DAC = make_flag("WRITE_DAC", ( 0x00040000 )) +WRITE_OWNER = make_flag("WRITE_OWNER", ( 0x00080000 )) +SYNCHRONIZE = make_flag("SYNCHRONIZE", ( 0x00100000 )) +STANDARD_RIGHTS_REQUIRED = make_flag("STANDARD_RIGHTS_REQUIRED", ( 0x000F0000 )) +STANDARD_RIGHTS_READ = make_flag("STANDARD_RIGHTS_READ", ( READ_CONTROL )) +STANDARD_RIGHTS_WRITE = make_flag("STANDARD_RIGHTS_WRITE", ( READ_CONTROL )) +STANDARD_RIGHTS_EXECUTE = make_flag("STANDARD_RIGHTS_EXECUTE", ( READ_CONTROL )) +STANDARD_RIGHTS_ALL = make_flag("STANDARD_RIGHTS_ALL", ( 0x001F0000 )) +SPECIFIC_RIGHTS_ALL = make_flag("SPECIFIC_RIGHTS_ALL", ( 0x0000FFFF )) +AF_UNSPEC = make_flag("AF_UNSPEC", 0) +AF_UNIX = make_flag("AF_UNIX", 1) +AF_INET = make_flag("AF_INET", 2) +AF_IMPLINK = make_flag("AF_IMPLINK", 3) +AF_PUP = make_flag("AF_PUP", 4) +AF_CHAOS = make_flag("AF_CHAOS", 5) +AF_NS = make_flag("AF_NS", 6) +AF_IPX = make_flag("AF_IPX", AF_NS) +AF_ISO = make_flag("AF_ISO", 7) +AF_OSI = make_flag("AF_OSI", AF_ISO) +AF_ECMA = make_flag("AF_ECMA", 8) +AF_DATAKIT = make_flag("AF_DATAKIT", 9) +AF_CCITT = make_flag("AF_CCITT", 10) +AF_SNA = make_flag("AF_SNA", 11) +AF_DECnet = make_flag("AF_DECnet", 12) +AF_DLI = make_flag("AF_DLI", 13) +AF_LAT = make_flag("AF_LAT", 14) +AF_HYLINK = make_flag("AF_HYLINK", 15) +AF_APPLETALK = make_flag("AF_APPLETALK", 16) +AF_NETBIOS = make_flag("AF_NETBIOS", 17) +AF_VOICEVIEW = make_flag("AF_VOICEVIEW", 18) +AF_FIREFOX = make_flag("AF_FIREFOX", 19) +AF_UNKNOWN1 = make_flag("AF_UNKNOWN1", 20) +AF_BAN = make_flag("AF_BAN", 21) +AF_ATM = make_flag("AF_ATM", 22) +AF_INET6 = make_flag("AF_INET6", 23) +AF_CLUSTER = make_flag("AF_CLUSTER", 24) +AF_12844 = make_flag("AF_12844", 25) +AF_IRDA = make_flag("AF_IRDA", 26) +AF_NETDES = make_flag("AF_NETDES", 28) +EXCEPTION_NONCONTINUABLE = make_flag("EXCEPTION_NONCONTINUABLE", 0x1) +EXCEPTION_MAXIMUM_PARAMETERS = make_flag("EXCEPTION_MAXIMUM_PARAMETERS", 15) +EXCEPTION_EXECUTE_HANDLER = make_flag("EXCEPTION_EXECUTE_HANDLER", 1) +EXCEPTION_CONTINUE_SEARCH = make_flag("EXCEPTION_CONTINUE_SEARCH", 0) +EXCEPTION_CONTINUE_EXECUTION = make_flag("EXCEPTION_CONTINUE_EXECUTION", -1) +GENERIC_READ = make_flag("GENERIC_READ", ( 0x80000000 )) +GENERIC_WRITE = make_flag("GENERIC_WRITE", ( 0x40000000 )) +GENERIC_EXECUTE = make_flag("GENERIC_EXECUTE", ( 0x20000000 )) +GENERIC_ALL = make_flag("GENERIC_ALL", ( 0x10000000 )) +FILE_FLAG_WRITE_THROUGH = make_flag("FILE_FLAG_WRITE_THROUGH", 0x80000000) +FILE_FLAG_OVERLAPPED = make_flag("FILE_FLAG_OVERLAPPED", 0x40000000) +FILE_FLAG_NO_BUFFERING = make_flag("FILE_FLAG_NO_BUFFERING", 0x20000000) +FILE_FLAG_RANDOM_ACCESS = make_flag("FILE_FLAG_RANDOM_ACCESS", 0x10000000) +FILE_FLAG_SEQUENTIAL_SCAN = make_flag("FILE_FLAG_SEQUENTIAL_SCAN", 0x08000000) +FILE_FLAG_DELETE_ON_CLOSE = make_flag("FILE_FLAG_DELETE_ON_CLOSE", 0x04000000) +FILE_FLAG_BACKUP_SEMANTICS = make_flag("FILE_FLAG_BACKUP_SEMANTICS", 0x02000000) +FILE_FLAG_POSIX_SEMANTICS = make_flag("FILE_FLAG_POSIX_SEMANTICS", 0x01000000) +FILE_FLAG_OPEN_REPARSE_POINT = make_flag("FILE_FLAG_OPEN_REPARSE_POINT", 0x00200000) +FILE_FLAG_OPEN_NO_RECALL = make_flag("FILE_FLAG_OPEN_NO_RECALL", 0x00100000) +FILE_FLAG_FIRST_PIPE_INSTANCE = make_flag("FILE_FLAG_FIRST_PIPE_INSTANCE", 0x00080000) +CREATE_NEW = make_flag("CREATE_NEW", 1) +CREATE_ALWAYS = make_flag("CREATE_ALWAYS", 2) +OPEN_EXISTING = make_flag("OPEN_EXISTING", 3) +OPEN_ALWAYS = make_flag("OPEN_ALWAYS", 4) +TRUNCATE_EXISTING = make_flag("TRUNCATE_EXISTING", 5) +FILE_SHARE_READ = make_flag("FILE_SHARE_READ", 0x00000001) +FILE_SHARE_WRITE = make_flag("FILE_SHARE_WRITE", 0x00000002) +FILE_SHARE_DELETE = make_flag("FILE_SHARE_DELETE", 0x00000004) +FILE_ATTRIBUTE_READONLY = make_flag("FILE_ATTRIBUTE_READONLY", 0x00000001) +FILE_ATTRIBUTE_HIDDEN = make_flag("FILE_ATTRIBUTE_HIDDEN", 0x00000002) +FILE_ATTRIBUTE_SYSTEM = make_flag("FILE_ATTRIBUTE_SYSTEM", 0x00000004) +FILE_ATTRIBUTE_DIRECTORY = make_flag("FILE_ATTRIBUTE_DIRECTORY", 0x00000010) +FILE_ATTRIBUTE_ARCHIVE = make_flag("FILE_ATTRIBUTE_ARCHIVE", 0x00000020) +FILE_ATTRIBUTE_DEVICE = make_flag("FILE_ATTRIBUTE_DEVICE", 0x00000040) +FILE_ATTRIBUTE_NORMAL = make_flag("FILE_ATTRIBUTE_NORMAL", 0x00000080) +FILE_ATTRIBUTE_TEMPORARY = make_flag("FILE_ATTRIBUTE_TEMPORARY", 0x00000100) +FILE_ATTRIBUTE_SPARSE_FILE = make_flag("FILE_ATTRIBUTE_SPARSE_FILE", 0x00000200) +FILE_ATTRIBUTE_REPARSE_POINT = make_flag("FILE_ATTRIBUTE_REPARSE_POINT", 0x00000400) +FILE_ATTRIBUTE_COMPRESSED = make_flag("FILE_ATTRIBUTE_COMPRESSED", 0x00000800) +FILE_ATTRIBUTE_OFFLINE = make_flag("FILE_ATTRIBUTE_OFFLINE", 0x00001000) +FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = make_flag("FILE_ATTRIBUTE_NOT_CONTENT_INDEXED", 0x00002000) +FILE_ATTRIBUTE_ENCRYPTED = make_flag("FILE_ATTRIBUTE_ENCRYPTED", 0x00004000) +FILE_ATTRIBUTE_VIRTUAL = make_flag("FILE_ATTRIBUTE_VIRTUAL", 0x00010000) +FILE_NOTIFY_CHANGE_FILE_NAME = make_flag("FILE_NOTIFY_CHANGE_FILE_NAME", 0x00000001) +FILE_NOTIFY_CHANGE_DIR_NAME = make_flag("FILE_NOTIFY_CHANGE_DIR_NAME", 0x00000002) +FILE_NOTIFY_CHANGE_ATTRIBUTES = make_flag("FILE_NOTIFY_CHANGE_ATTRIBUTES", 0x00000004) +FILE_NOTIFY_CHANGE_SIZE = make_flag("FILE_NOTIFY_CHANGE_SIZE", 0x00000008) +FILE_NOTIFY_CHANGE_LAST_WRITE = make_flag("FILE_NOTIFY_CHANGE_LAST_WRITE", 0x00000010) +FILE_NOTIFY_CHANGE_LAST_ACCESS = make_flag("FILE_NOTIFY_CHANGE_LAST_ACCESS", 0x00000020) +FILE_NOTIFY_CHANGE_CREATION = make_flag("FILE_NOTIFY_CHANGE_CREATION", 0x00000040) +FILE_NOTIFY_CHANGE_SECURITY = make_flag("FILE_NOTIFY_CHANGE_SECURITY", 0x00000100) +FILE_ACTION_ADDED = make_flag("FILE_ACTION_ADDED", 0x00000001) +FILE_ACTION_REMOVED = make_flag("FILE_ACTION_REMOVED", 0x00000002) +FILE_ACTION_MODIFIED = make_flag("FILE_ACTION_MODIFIED", 0x00000003) +FILE_ACTION_RENAMED_OLD_NAME = make_flag("FILE_ACTION_RENAMED_OLD_NAME", 0x00000004) +FILE_ACTION_RENAMED_NEW_NAME = make_flag("FILE_ACTION_RENAMED_NEW_NAME", 0x00000005) +MAILSLOT_NO_MESSAGE = make_flag("MAILSLOT_NO_MESSAGE", ( -1 )) +MAILSLOT_WAIT_FOREVER = make_flag("MAILSLOT_WAIT_FOREVER", ( -1 )) +FILE_CASE_SENSITIVE_SEARCH = make_flag("FILE_CASE_SENSITIVE_SEARCH", 0x00000001) +FILE_CASE_PRESERVED_NAMES = make_flag("FILE_CASE_PRESERVED_NAMES", 0x00000002) +FILE_UNICODE_ON_DISK = make_flag("FILE_UNICODE_ON_DISK", 0x00000004) +FILE_PERSISTENT_ACLS = make_flag("FILE_PERSISTENT_ACLS", 0x00000008) +FILE_FILE_COMPRESSION = make_flag("FILE_FILE_COMPRESSION", 0x00000010) +FILE_VOLUME_QUOTAS = make_flag("FILE_VOLUME_QUOTAS", 0x00000020) +FILE_SUPPORTS_SPARSE_FILES = make_flag("FILE_SUPPORTS_SPARSE_FILES", 0x00000040) +FILE_SUPPORTS_REPARSE_POINTS = make_flag("FILE_SUPPORTS_REPARSE_POINTS", 0x00000080) +FILE_SUPPORTS_REMOTE_STORAGE = make_flag("FILE_SUPPORTS_REMOTE_STORAGE", 0x00000100) +FILE_VOLUME_IS_COMPRESSED = make_flag("FILE_VOLUME_IS_COMPRESSED", 0x00008000) +FILE_SUPPORTS_OBJECT_IDS = make_flag("FILE_SUPPORTS_OBJECT_IDS", 0x00010000) +FILE_SUPPORTS_ENCRYPTION = make_flag("FILE_SUPPORTS_ENCRYPTION", 0x00020000) +FILE_NAMED_STREAMS = make_flag("FILE_NAMED_STREAMS", 0x00040000) +FILE_READ_ONLY_VOLUME = make_flag("FILE_READ_ONLY_VOLUME", 0x00080000) +FILE_SEQUENTIAL_WRITE_ONCE = make_flag("FILE_SEQUENTIAL_WRITE_ONCE", 0x00100000) +FILE_SUPPORTS_TRANSACTIONS = make_flag("FILE_SUPPORTS_TRANSACTIONS", 0x00200000) +FILE_SUPPORTS_HARD_LINKS = make_flag("FILE_SUPPORTS_HARD_LINKS", 0x00400000) +FILE_SUPPORTS_EXTENDED_ATTRIBUTES = make_flag("FILE_SUPPORTS_EXTENDED_ATTRIBUTES", 0x00800000) +FILE_SUPPORTS_OPEN_BY_FILE_ID = make_flag("FILE_SUPPORTS_OPEN_BY_FILE_ID", 0x01000000) +FILE_SUPPORTS_USN_JOURNAL = make_flag("FILE_SUPPORTS_USN_JOURNAL", 0x02000000) +HKEY_CLASSES_ROOT = make_flag("HKEY_CLASSES_ROOT", ( 0x80000000 )) +HKEY_CURRENT_USER = make_flag("HKEY_CURRENT_USER", ( 0x80000001 )) +HKEY_LOCAL_MACHINE = make_flag("HKEY_LOCAL_MACHINE", ( 0x80000002 )) +HKEY_USERS = make_flag("HKEY_USERS", ( 0x80000003 )) +HKEY_PERFORMANCE_DATA = make_flag("HKEY_PERFORMANCE_DATA", ( 0x80000004 )) +HKEY_PERFORMANCE_TEXT = make_flag("HKEY_PERFORMANCE_TEXT", ( 0x80000050 )) +HKEY_PERFORMANCE_NLSTEXT = make_flag("HKEY_PERFORMANCE_NLSTEXT", ( 0x80000060 )) +RRF_RT_REG_NONE = make_flag("RRF_RT_REG_NONE", 0x00000001) +RRF_RT_REG_SZ = make_flag("RRF_RT_REG_SZ", 0x00000002) +RRF_RT_REG_EXPAND_SZ = make_flag("RRF_RT_REG_EXPAND_SZ", 0x00000004) +RRF_RT_REG_BINARY = make_flag("RRF_RT_REG_BINARY", 0x00000008) +RRF_RT_REG_DWORD = make_flag("RRF_RT_REG_DWORD", 0x00000010) +RRF_RT_REG_MULTI_SZ = make_flag("RRF_RT_REG_MULTI_SZ", 0x00000020) +RRF_RT_REG_QWORD = make_flag("RRF_RT_REG_QWORD", 0x00000040) +RRF_RT_DWORD = make_flag("RRF_RT_DWORD", ( RRF_RT_REG_BINARY | RRF_RT_REG_DWORD )) +RRF_RT_QWORD = make_flag("RRF_RT_QWORD", ( RRF_RT_REG_BINARY | RRF_RT_REG_QWORD )) +RRF_RT_ANY = make_flag("RRF_RT_ANY", 0x0000ffff) +RRF_NOEXPAND = make_flag("RRF_NOEXPAND", 0x10000000) +RRF_ZEROONFAILURE = make_flag("RRF_ZEROONFAILURE", 0x20000000) +ERROR_NOT_ALL_ASSIGNED = make_flag("ERROR_NOT_ALL_ASSIGNED", 1300) +S_OK = make_flag("S_OK", 0) +S_FALSE = make_flag("S_FALSE", 1) +E_NOINTERFACE = make_flag("E_NOINTERFACE", 0x80004002) +E_FAIL = make_flag("E_FAIL", 0x80004005) +DEBUG_EVENT_BREAKPOINT = make_flag("DEBUG_EVENT_BREAKPOINT", 0x00000001) +DEBUG_EVENT_EXCEPTION = make_flag("DEBUG_EVENT_EXCEPTION", 0x00000002) +DEBUG_EVENT_CREATE_THREAD = make_flag("DEBUG_EVENT_CREATE_THREAD", 0x00000004) +DEBUG_EVENT_EXIT_THREAD = make_flag("DEBUG_EVENT_EXIT_THREAD", 0x00000008) +DEBUG_EVENT_CREATE_PROCESS = make_flag("DEBUG_EVENT_CREATE_PROCESS", 0x00000010) +DEBUG_EVENT_EXIT_PROCESS = make_flag("DEBUG_EVENT_EXIT_PROCESS", 0x00000020) +DEBUG_EVENT_LOAD_MODULE = make_flag("DEBUG_EVENT_LOAD_MODULE", 0x00000040) +DEBUG_EVENT_UNLOAD_MODULE = make_flag("DEBUG_EVENT_UNLOAD_MODULE", 0x00000080) +DEBUG_EVENT_SYSTEM_ERROR = make_flag("DEBUG_EVENT_SYSTEM_ERROR", 0x00000100) +DEBUG_EVENT_SESSION_STATUS = make_flag("DEBUG_EVENT_SESSION_STATUS", 0x00000200) +DEBUG_EVENT_CHANGE_DEBUGGEE_STATE = make_flag("DEBUG_EVENT_CHANGE_DEBUGGEE_STATE", 0x00000400) +DEBUG_EVENT_CHANGE_ENGINE_STATE = make_flag("DEBUG_EVENT_CHANGE_ENGINE_STATE", 0x00000800) +DEBUG_EVENT_CHANGE_SYMBOL_STATE = make_flag("DEBUG_EVENT_CHANGE_SYMBOL_STATE", 0x00001000) +WOW64_MAXIMUM_SUPPORTED_EXTENSION = make_flag("WOW64_MAXIMUM_SUPPORTED_EXTENSION", 512) +WOW64_SIZE_OF_80387_REGISTERS = make_flag("WOW64_SIZE_OF_80387_REGISTERS", 80) +REG_NONE = make_flag("REG_NONE", ( 0 )) +REG_SZ = make_flag("REG_SZ", ( 1 )) +REG_EXPAND_SZ = make_flag("REG_EXPAND_SZ", ( 2 )) +REG_BINARY = make_flag("REG_BINARY", ( 3 )) +REG_DWORD = make_flag("REG_DWORD", ( 4 )) +REG_DWORD_LITTLE_ENDIAN = make_flag("REG_DWORD_LITTLE_ENDIAN", ( 4 )) +REG_DWORD_BIG_ENDIAN = make_flag("REG_DWORD_BIG_ENDIAN", ( 5 )) +REG_LINK = make_flag("REG_LINK", ( 6 )) +REG_MULTI_SZ = make_flag("REG_MULTI_SZ", ( 7 )) +REG_RESOURCE_LIST = make_flag("REG_RESOURCE_LIST", ( 8 )) +REG_FULL_RESOURCE_DESCRIPTOR = make_flag("REG_FULL_RESOURCE_DESCRIPTOR", ( 9 )) +REG_RESOURCE_REQUIREMENTS_LIST = make_flag("REG_RESOURCE_REQUIREMENTS_LIST", ( 10 )) +REG_QWORD = make_flag("REG_QWORD", ( 11 )) +REG_QWORD_LITTLE_ENDIAN = make_flag("REG_QWORD_LITTLE_ENDIAN", ( 11 )) +IMAGE_FILE_RELOCS_STRIPPED = make_flag("IMAGE_FILE_RELOCS_STRIPPED", 0x0001) +IMAGE_FILE_EXECUTABLE_IMAGE = make_flag("IMAGE_FILE_EXECUTABLE_IMAGE", 0x0002) +IMAGE_FILE_LINE_NUMS_STRIPPED = make_flag("IMAGE_FILE_LINE_NUMS_STRIPPED", 0x0004) +IMAGE_FILE_LOCAL_SYMS_STRIPPED = make_flag("IMAGE_FILE_LOCAL_SYMS_STRIPPED", 0x0008) +IMAGE_FILE_AGGRESIVE_WS_TRIM = make_flag("IMAGE_FILE_AGGRESIVE_WS_TRIM", 0x0010) +IMAGE_FILE_LARGE_ADDRESS_AWARE = make_flag("IMAGE_FILE_LARGE_ADDRESS_AWARE", 0x0020) +IMAGE_FILE_BYTES_REVERSED_LO = make_flag("IMAGE_FILE_BYTES_REVERSED_LO", 0x0080) +IMAGE_FILE_32BIT_MACHINE = make_flag("IMAGE_FILE_32BIT_MACHINE", 0x0100) +IMAGE_FILE_DEBUG_STRIPPED = make_flag("IMAGE_FILE_DEBUG_STRIPPED", 0x0200) +IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP = make_flag("IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP", 0x0400) +IMAGE_FILE_NET_RUN_FROM_SWAP = make_flag("IMAGE_FILE_NET_RUN_FROM_SWAP", 0x0800) +IMAGE_FILE_SYSTEM = make_flag("IMAGE_FILE_SYSTEM", 0x1000) +IMAGE_FILE_DLL = make_flag("IMAGE_FILE_DLL", 0x2000) +IMAGE_FILE_UP_SYSTEM_ONLY = make_flag("IMAGE_FILE_UP_SYSTEM_ONLY", 0x4000) +IMAGE_FILE_BYTES_REVERSED_HI = make_flag("IMAGE_FILE_BYTES_REVERSED_HI", 0x8000) +IMAGE_FILE_MACHINE_UNKNOWN = make_flag("IMAGE_FILE_MACHINE_UNKNOWN", 0) +IMAGE_FILE_MACHINE_I386 = make_flag("IMAGE_FILE_MACHINE_I386", 0x014c) +IMAGE_FILE_MACHINE_R3000 = make_flag("IMAGE_FILE_MACHINE_R3000", 0x0162) +IMAGE_FILE_MACHINE_R4000 = make_flag("IMAGE_FILE_MACHINE_R4000", 0x0166) +IMAGE_FILE_MACHINE_R10000 = make_flag("IMAGE_FILE_MACHINE_R10000", 0x0168) +IMAGE_FILE_MACHINE_WCEMIPSV2 = make_flag("IMAGE_FILE_MACHINE_WCEMIPSV2", 0x0169) +IMAGE_FILE_MACHINE_ALPHA = make_flag("IMAGE_FILE_MACHINE_ALPHA", 0x0184) +IMAGE_FILE_MACHINE_SH3 = make_flag("IMAGE_FILE_MACHINE_SH3", 0x01a2) +IMAGE_FILE_MACHINE_SH3DSP = make_flag("IMAGE_FILE_MACHINE_SH3DSP", 0x01a3) +IMAGE_FILE_MACHINE_SH3E = make_flag("IMAGE_FILE_MACHINE_SH3E", 0x01a4) +IMAGE_FILE_MACHINE_SH4 = make_flag("IMAGE_FILE_MACHINE_SH4", 0x01a6) +IMAGE_FILE_MACHINE_SH5 = make_flag("IMAGE_FILE_MACHINE_SH5", 0x01a8) +IMAGE_FILE_MACHINE_ARM = make_flag("IMAGE_FILE_MACHINE_ARM", 0x01c0) +IMAGE_FILE_MACHINE_THUMB = make_flag("IMAGE_FILE_MACHINE_THUMB", 0x01c2) +IMAGE_FILE_MACHINE_ARMNT = make_flag("IMAGE_FILE_MACHINE_ARMNT", 0x01c4) +IMAGE_FILE_MACHINE_AM33 = make_flag("IMAGE_FILE_MACHINE_AM33", 0x01d3) +IMAGE_FILE_MACHINE_POWERPC = make_flag("IMAGE_FILE_MACHINE_POWERPC", 0x01F0) +IMAGE_FILE_MACHINE_POWERPCFP = make_flag("IMAGE_FILE_MACHINE_POWERPCFP", 0x01f1) +IMAGE_FILE_MACHINE_IA64 = make_flag("IMAGE_FILE_MACHINE_IA64", 0x0200) +IMAGE_FILE_MACHINE_MIPS16 = make_flag("IMAGE_FILE_MACHINE_MIPS16", 0x0266) +IMAGE_FILE_MACHINE_ALPHA64 = make_flag("IMAGE_FILE_MACHINE_ALPHA64", 0x0284) +IMAGE_FILE_MACHINE_MIPSFPU = make_flag("IMAGE_FILE_MACHINE_MIPSFPU", 0x0366) +IMAGE_FILE_MACHINE_MIPSFPU16 = make_flag("IMAGE_FILE_MACHINE_MIPSFPU16", 0x0466) +IMAGE_FILE_MACHINE_AXP64 = make_flag("IMAGE_FILE_MACHINE_AXP64", IMAGE_FILE_MACHINE_ALPHA64) +IMAGE_FILE_MACHINE_TRICORE = make_flag("IMAGE_FILE_MACHINE_TRICORE", 0x0520) +IMAGE_FILE_MACHINE_CEF = make_flag("IMAGE_FILE_MACHINE_CEF", 0x0CEF) +IMAGE_FILE_MACHINE_EBC = make_flag("IMAGE_FILE_MACHINE_EBC", 0x0EBC) +IMAGE_FILE_MACHINE_AMD64 = make_flag("IMAGE_FILE_MACHINE_AMD64", 0x8664) +IMAGE_FILE_MACHINE_M32R = make_flag("IMAGE_FILE_MACHINE_M32R", 0x9041) +IMAGE_FILE_MACHINE_CEE = make_flag("IMAGE_FILE_MACHINE_CEE", 0xC0EE) +SECURITY_MANDATORY_UNTRUSTED_RID = make_flag("SECURITY_MANDATORY_UNTRUSTED_RID", ( 0x00000000 )) +SECURITY_MANDATORY_LOW_RID = make_flag("SECURITY_MANDATORY_LOW_RID", ( 0x00001000 )) +SECURITY_MANDATORY_MEDIUM_RID = make_flag("SECURITY_MANDATORY_MEDIUM_RID", ( 0x00002000 )) +SECURITY_MANDATORY_MEDIUM_PLUS_RID = make_flag("SECURITY_MANDATORY_MEDIUM_PLUS_RID", ( SECURITY_MANDATORY_MEDIUM_RID + 0x100 )) +SECURITY_MANDATORY_HIGH_RID = make_flag("SECURITY_MANDATORY_HIGH_RID", ( 0x00003000 )) +SECURITY_MANDATORY_SYSTEM_RID = make_flag("SECURITY_MANDATORY_SYSTEM_RID", ( 0x00004000 )) +SECURITY_MANDATORY_PROTECTED_PROCESS_RID = make_flag("SECURITY_MANDATORY_PROTECTED_PROCESS_RID", ( 0x00005000 )) +SC_MANAGER_CONNECT = make_flag("SC_MANAGER_CONNECT", 0x0001) +SC_MANAGER_CREATE_SERVICE = make_flag("SC_MANAGER_CREATE_SERVICE", 0x0002) +SC_MANAGER_ENUMERATE_SERVICE = make_flag("SC_MANAGER_ENUMERATE_SERVICE", 0x0004) +SC_MANAGER_LOCK = make_flag("SC_MANAGER_LOCK", 0x0008) +SC_MANAGER_QUERY_LOCK_STATUS = make_flag("SC_MANAGER_QUERY_LOCK_STATUS", 0x0010) +SC_MANAGER_MODIFY_BOOT_CONFIG = make_flag("SC_MANAGER_MODIFY_BOOT_CONFIG", 0x0020) +SC_MANAGER_ALL_ACCESS = make_flag("SC_MANAGER_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_LOCK | SC_MANAGER_QUERY_LOCK_STATUS | SC_MANAGER_MODIFY_BOOT_CONFIG )) +SERVICE_QUERY_CONFIG = make_flag("SERVICE_QUERY_CONFIG", 0x0001) +SERVICE_CHANGE_CONFIG = make_flag("SERVICE_CHANGE_CONFIG", 0x0002) +SERVICE_QUERY_STATUS = make_flag("SERVICE_QUERY_STATUS", 0x0004) +SERVICE_ENUMERATE_DEPENDENTS = make_flag("SERVICE_ENUMERATE_DEPENDENTS", 0x0008) +SERVICE_START = make_flag("SERVICE_START", 0x0010) +SERVICE_STOP = make_flag("SERVICE_STOP", 0x0020) +SERVICE_PAUSE_CONTINUE = make_flag("SERVICE_PAUSE_CONTINUE", 0x0040) +SERVICE_INTERROGATE = make_flag("SERVICE_INTERROGATE", 0x0080) +SERVICE_USER_DEFINED_CONTROL = make_flag("SERVICE_USER_DEFINED_CONTROL", 0x0100) +SERVICE_ALL_ACCESS = make_flag("SERVICE_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_INTERROGATE | SERVICE_USER_DEFINED_CONTROL )) +SERVICE_RUNS_IN_SYSTEM_PROCESS = make_flag("SERVICE_RUNS_IN_SYSTEM_PROCESS", 0x00000001) +SERVICE_KERNEL_DRIVER = make_flag("SERVICE_KERNEL_DRIVER", 0x00000001) +SERVICE_FILE_SYSTEM_DRIVER = make_flag("SERVICE_FILE_SYSTEM_DRIVER", 0x00000002) +SERVICE_ADAPTER = make_flag("SERVICE_ADAPTER", 0x00000004) +SERVICE_RECOGNIZER_DRIVER = make_flag("SERVICE_RECOGNIZER_DRIVER", 0x00000008) +SERVICE_DRIVER = make_flag("SERVICE_DRIVER", ( SERVICE_KERNEL_DRIVER | SERVICE_FILE_SYSTEM_DRIVER | SERVICE_RECOGNIZER_DRIVER )) +SERVICE_WIN32_OWN_PROCESS = make_flag("SERVICE_WIN32_OWN_PROCESS", 0x00000010) +SERVICE_WIN32_SHARE_PROCESS = make_flag("SERVICE_WIN32_SHARE_PROCESS", 0x00000020) +SERVICE_WIN32 = make_flag("SERVICE_WIN32", ( SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS )) +SERVICE_INTERACTIVE_PROCESS = make_flag("SERVICE_INTERACTIVE_PROCESS", 0x00000100) +SERVICE_TYPE_ALL = make_flag("SERVICE_TYPE_ALL", ( SERVICE_WIN32 | SERVICE_ADAPTER | SERVICE_DRIVER | SERVICE_INTERACTIVE_PROCESS )) +SERVICE_BOOT_START = make_flag("SERVICE_BOOT_START", 0x00000000) +SERVICE_SYSTEM_START = make_flag("SERVICE_SYSTEM_START", 0x00000001) +SERVICE_AUTO_START = make_flag("SERVICE_AUTO_START", 0x00000002) +SERVICE_DEMAND_START = make_flag("SERVICE_DEMAND_START", 0x00000003) +SERVICE_DISABLED = make_flag("SERVICE_DISABLED", 0x00000004) +SERVICE_ERROR_IGNORE = make_flag("SERVICE_ERROR_IGNORE", 0x00000000) +SERVICE_ERROR_NORMAL = make_flag("SERVICE_ERROR_NORMAL", 0x00000001) +SERVICE_ERROR_SEVERE = make_flag("SERVICE_ERROR_SEVERE", 0x00000002) +SERVICE_ERROR_CRITICAL = make_flag("SERVICE_ERROR_CRITICAL", 0x00000003) +SERVICE_ACTIVE = make_flag("SERVICE_ACTIVE", 0x00000001) +SERVICE_INACTIVE = make_flag("SERVICE_INACTIVE", 0x00000002) +SERVICE_STATE_ALL = make_flag("SERVICE_STATE_ALL", ( SERVICE_ACTIVE | SERVICE_INACTIVE )) +SERVICE_CONTROL_STOP = make_flag("SERVICE_CONTROL_STOP", 0x00000001) +SERVICE_CONTROL_PAUSE = make_flag("SERVICE_CONTROL_PAUSE", 0x00000002) +SERVICE_CONTROL_CONTINUE = make_flag("SERVICE_CONTROL_CONTINUE", 0x00000003) +SERVICE_CONTROL_INTERROGATE = make_flag("SERVICE_CONTROL_INTERROGATE", 0x00000004) +SERVICE_CONTROL_SHUTDOWN = make_flag("SERVICE_CONTROL_SHUTDOWN", 0x00000005) +SERVICE_CONTROL_PARAMCHANGE = make_flag("SERVICE_CONTROL_PARAMCHANGE", 0x00000006) +SERVICE_CONTROL_NETBINDADD = make_flag("SERVICE_CONTROL_NETBINDADD", 0x00000007) +SERVICE_CONTROL_NETBINDREMOVE = make_flag("SERVICE_CONTROL_NETBINDREMOVE", 0x00000008) +SERVICE_CONTROL_NETBINDENABLE = make_flag("SERVICE_CONTROL_NETBINDENABLE", 0x00000009) +SERVICE_CONTROL_NETBINDDISABLE = make_flag("SERVICE_CONTROL_NETBINDDISABLE", 0x0000000A) +SERVICE_CONTROL_DEVICEEVENT = make_flag("SERVICE_CONTROL_DEVICEEVENT", 0x0000000B) +SERVICE_CONTROL_HARDWAREPROFILECHANGE = make_flag("SERVICE_CONTROL_HARDWAREPROFILECHANGE", 0x0000000C) +SERVICE_CONTROL_POWEREVENT = make_flag("SERVICE_CONTROL_POWEREVENT", 0x0000000D) +SERVICE_CONTROL_SESSIONCHANGE = make_flag("SERVICE_CONTROL_SESSIONCHANGE", 0x0000000E) +SERVICE_CONTROL_PRESHUTDOWN = make_flag("SERVICE_CONTROL_PRESHUTDOWN", 0x0000000F) +SERVICE_CONTROL_TIMECHANGE = make_flag("SERVICE_CONTROL_TIMECHANGE", 0x00000010) +SERVICE_CONTROL_TRIGGEREVENT = make_flag("SERVICE_CONTROL_TRIGGEREVENT", 0x00000020) +SERVICE_STOPPED = make_flag("SERVICE_STOPPED", 0x00000001) +SERVICE_START_PENDING = make_flag("SERVICE_START_PENDING", 0x00000002) +SERVICE_STOP_PENDING = make_flag("SERVICE_STOP_PENDING", 0x00000003) +SERVICE_RUNNING = make_flag("SERVICE_RUNNING", 0x00000004) +SERVICE_CONTINUE_PENDING = make_flag("SERVICE_CONTINUE_PENDING", 0x00000005) +SERVICE_PAUSE_PENDING = make_flag("SERVICE_PAUSE_PENDING", 0x00000006) +SERVICE_PAUSED = make_flag("SERVICE_PAUSED", 0x00000007) +SERVICE_ACCEPT_STOP = make_flag("SERVICE_ACCEPT_STOP", 0x00000001) +SERVICE_ACCEPT_PAUSE_CONTINUE = make_flag("SERVICE_ACCEPT_PAUSE_CONTINUE", 0x00000002) +SERVICE_ACCEPT_SHUTDOWN = make_flag("SERVICE_ACCEPT_SHUTDOWN", 0x00000004) +SERVICE_ACCEPT_PARAMCHANGE = make_flag("SERVICE_ACCEPT_PARAMCHANGE", 0x00000008) +SERVICE_ACCEPT_NETBINDCHANGE = make_flag("SERVICE_ACCEPT_NETBINDCHANGE", 0x00000010) +SERVICE_ACCEPT_HARDWAREPROFILECHANGE = make_flag("SERVICE_ACCEPT_HARDWAREPROFILECHANGE", 0x00000020) +SERVICE_ACCEPT_POWEREVENT = make_flag("SERVICE_ACCEPT_POWEREVENT", 0x00000040) +SERVICE_ACCEPT_SESSIONCHANGE = make_flag("SERVICE_ACCEPT_SESSIONCHANGE", 0x00000080) +SERVICE_ACCEPT_PRESHUTDOWN = make_flag("SERVICE_ACCEPT_PRESHUTDOWN", 0x00000100) +SERVICE_ACCEPT_TIMECHANGE = make_flag("SERVICE_ACCEPT_TIMECHANGE", 0x00000200) +SERVICE_ACCEPT_TRIGGEREVENT = make_flag("SERVICE_ACCEPT_TRIGGEREVENT", 0x00000400) +DRIVE_UNKNOWN = make_flag("DRIVE_UNKNOWN", 0) +DRIVE_NO_ROOT_DIR = make_flag("DRIVE_NO_ROOT_DIR", 1) +DRIVE_REMOVABLE = make_flag("DRIVE_REMOVABLE", 2) +DRIVE_FIXED = make_flag("DRIVE_FIXED", 3) +DRIVE_REMOTE = make_flag("DRIVE_REMOTE", 4) +DRIVE_CDROM = make_flag("DRIVE_CDROM", 5) +DRIVE_RAMDISK = make_flag("DRIVE_RAMDISK", 6) +DUPLICATE_CLOSE_SOURCE = make_flag("DUPLICATE_CLOSE_SOURCE", 0x00000001) +DUPLICATE_SAME_ACCESS = make_flag("DUPLICATE_SAME_ACCESS", 0x00000002) +VER_NT_WORKSTATION = make_flag("VER_NT_WORKSTATION", 0x0000001) +VER_NT_DOMAIN_CONTROLLER = make_flag("VER_NT_DOMAIN_CONTROLLER", 0x0000002) +VER_NT_SERVER = make_flag("VER_NT_SERVER", 0x0000003) +SM_CXSCREEN = make_flag("SM_CXSCREEN", 0) +SM_CYSCREEN = make_flag("SM_CYSCREEN", 1) +SM_CXVSCROLL = make_flag("SM_CXVSCROLL", 2) +SM_CYHSCROLL = make_flag("SM_CYHSCROLL", 3) +SM_CYCAPTION = make_flag("SM_CYCAPTION", 4) +SM_CXBORDER = make_flag("SM_CXBORDER", 5) +SM_CYBORDER = make_flag("SM_CYBORDER", 6) +SM_CXDLGFRAME = make_flag("SM_CXDLGFRAME", 7) +SM_CYDLGFRAME = make_flag("SM_CYDLGFRAME", 8) +SM_CYVTHUMB = make_flag("SM_CYVTHUMB", 9) +SM_CXHTHUMB = make_flag("SM_CXHTHUMB", 10) +SM_CXICON = make_flag("SM_CXICON", 11) +SM_CYICON = make_flag("SM_CYICON", 12) +SM_CXCURSOR = make_flag("SM_CXCURSOR", 13) +SM_CYCURSOR = make_flag("SM_CYCURSOR", 14) +SM_CYMENU = make_flag("SM_CYMENU", 15) +SM_CXFULLSCREEN = make_flag("SM_CXFULLSCREEN", 16) +SM_CYFULLSCREEN = make_flag("SM_CYFULLSCREEN", 17) +SM_CYKANJIWINDOW = make_flag("SM_CYKANJIWINDOW", 18) +SM_MOUSEPRESENT = make_flag("SM_MOUSEPRESENT", 19) +SM_CYVSCROLL = make_flag("SM_CYVSCROLL", 20) +SM_CXHSCROLL = make_flag("SM_CXHSCROLL", 21) +SM_DEBUG = make_flag("SM_DEBUG", 22) +SM_SWAPBUTTON = make_flag("SM_SWAPBUTTON", 23) +SM_RESERVED1 = make_flag("SM_RESERVED1", 24) +SM_RESERVED2 = make_flag("SM_RESERVED2", 25) +SM_RESERVED3 = make_flag("SM_RESERVED3", 26) +SM_RESERVED4 = make_flag("SM_RESERVED4", 27) +SM_CXMIN = make_flag("SM_CXMIN", 28) +SM_CYMIN = make_flag("SM_CYMIN", 29) +SM_CXSIZE = make_flag("SM_CXSIZE", 30) +SM_CYSIZE = make_flag("SM_CYSIZE", 31) +SM_CXFRAME = make_flag("SM_CXFRAME", 32) +SM_CYFRAME = make_flag("SM_CYFRAME", 33) +SM_CXMINTRACK = make_flag("SM_CXMINTRACK", 34) +SM_CYMINTRACK = make_flag("SM_CYMINTRACK", 35) +SM_CXDOUBLECLK = make_flag("SM_CXDOUBLECLK", 36) +SM_CYDOUBLECLK = make_flag("SM_CYDOUBLECLK", 37) +SM_CXICONSPACING = make_flag("SM_CXICONSPACING", 38) +SM_CYICONSPACING = make_flag("SM_CYICONSPACING", 39) +SM_MENUDROPALIGNMENT = make_flag("SM_MENUDROPALIGNMENT", 40) +SM_PENWINDOWS = make_flag("SM_PENWINDOWS", 41) +SM_DBCSENABLED = make_flag("SM_DBCSENABLED", 42) +SM_CMOUSEBUTTONS = make_flag("SM_CMOUSEBUTTONS", 43) +SM_CXFIXEDFRAME = make_flag("SM_CXFIXEDFRAME", SM_CXDLGFRAME) +SM_CYFIXEDFRAME = make_flag("SM_CYFIXEDFRAME", SM_CYDLGFRAME) +SM_CXSIZEFRAME = make_flag("SM_CXSIZEFRAME", SM_CXFRAME) +SM_CYSIZEFRAME = make_flag("SM_CYSIZEFRAME", SM_CYFRAME) +SM_SECURE = make_flag("SM_SECURE", 44) +SM_CXEDGE = make_flag("SM_CXEDGE", 45) +SM_CYEDGE = make_flag("SM_CYEDGE", 46) +SM_CXMINSPACING = make_flag("SM_CXMINSPACING", 47) +SM_CYMINSPACING = make_flag("SM_CYMINSPACING", 48) +SM_CXSMICON = make_flag("SM_CXSMICON", 49) +SM_CYSMICON = make_flag("SM_CYSMICON", 50) +SM_CYSMCAPTION = make_flag("SM_CYSMCAPTION", 51) +SM_CXSMSIZE = make_flag("SM_CXSMSIZE", 52) +SM_CYSMSIZE = make_flag("SM_CYSMSIZE", 53) +SM_CXMENUSIZE = make_flag("SM_CXMENUSIZE", 54) +SM_CYMENUSIZE = make_flag("SM_CYMENUSIZE", 55) +SM_ARRANGE = make_flag("SM_ARRANGE", 56) +SM_CXMINIMIZED = make_flag("SM_CXMINIMIZED", 57) +SM_CYMINIMIZED = make_flag("SM_CYMINIMIZED", 58) +SM_CXMAXTRACK = make_flag("SM_CXMAXTRACK", 59) +SM_CYMAXTRACK = make_flag("SM_CYMAXTRACK", 60) +SM_CXMAXIMIZED = make_flag("SM_CXMAXIMIZED", 61) +SM_CYMAXIMIZED = make_flag("SM_CYMAXIMIZED", 62) +SM_NETWORK = make_flag("SM_NETWORK", 63) +SM_CLEANBOOT = make_flag("SM_CLEANBOOT", 67) +SM_CXDRAG = make_flag("SM_CXDRAG", 68) +SM_CYDRAG = make_flag("SM_CYDRAG", 69) +SM_SHOWSOUNDS = make_flag("SM_SHOWSOUNDS", 70) +SM_CXMENUCHECK = make_flag("SM_CXMENUCHECK", 71) +SM_CYMENUCHECK = make_flag("SM_CYMENUCHECK", 72) +SM_SLOWMACHINE = make_flag("SM_SLOWMACHINE", 73) +SM_MIDEASTENABLED = make_flag("SM_MIDEASTENABLED", 74) +SM_MOUSEWHEELPRESENT = make_flag("SM_MOUSEWHEELPRESENT", 75) +SM_XVIRTUALSCREEN = make_flag("SM_XVIRTUALSCREEN", 76) +SM_YVIRTUALSCREEN = make_flag("SM_YVIRTUALSCREEN", 77) +SM_CXVIRTUALSCREEN = make_flag("SM_CXVIRTUALSCREEN", 78) +SM_CYVIRTUALSCREEN = make_flag("SM_CYVIRTUALSCREEN", 79) +SM_CMONITORS = make_flag("SM_CMONITORS", 80) +SM_SAMEDISPLAYFORMAT = make_flag("SM_SAMEDISPLAYFORMAT", 81) +SM_IMMENABLED = make_flag("SM_IMMENABLED", 82) +SM_CXFOCUSBORDER = make_flag("SM_CXFOCUSBORDER", 83) +SM_CYFOCUSBORDER = make_flag("SM_CYFOCUSBORDER", 84) +SM_TABLETPC = make_flag("SM_TABLETPC", 86) +SM_MEDIACENTER = make_flag("SM_MEDIACENTER", 87) +SM_STARTER = make_flag("SM_STARTER", 88) +SM_SERVERR2 = make_flag("SM_SERVERR2", 89) +SM_MOUSEHORIZONTALWHEELPRESENT = make_flag("SM_MOUSEHORIZONTALWHEELPRESENT", 91) +SM_CXPADDEDBORDER = make_flag("SM_CXPADDEDBORDER", 92) +SM_DIGITIZER = make_flag("SM_DIGITIZER", 94) +SM_MAXIMUMTOUCHES = make_flag("SM_MAXIMUMTOUCHES", 95) +SM_REMOTESESSION = make_flag("SM_REMOTESESSION", 0x1000) +SM_SHUTTINGDOWN = make_flag("SM_SHUTTINGDOWN", 0x2000) +SM_REMOTECONTROL = make_flag("SM_REMOTECONTROL", 0x2001) +SM_CARETBLINKINGENABLED = make_flag("SM_CARETBLINKINGENABLED", 0x2002) +RPC_C_AUTHN_LEVEL_DEFAULT = make_flag("RPC_C_AUTHN_LEVEL_DEFAULT", 0) +RPC_C_AUTHN_LEVEL_NONE = make_flag("RPC_C_AUTHN_LEVEL_NONE", 1) +RPC_C_AUTHN_LEVEL_CONNECT = make_flag("RPC_C_AUTHN_LEVEL_CONNECT", 2) +RPC_C_AUTHN_LEVEL_CALL = make_flag("RPC_C_AUTHN_LEVEL_CALL", 3) +RPC_C_AUTHN_LEVEL_PKT = make_flag("RPC_C_AUTHN_LEVEL_PKT", 4) +RPC_C_AUTHN_LEVEL_PKT_INTEGRITY = make_flag("RPC_C_AUTHN_LEVEL_PKT_INTEGRITY", 5) +RPC_C_AUTHN_LEVEL_PKT_PRIVACY = make_flag("RPC_C_AUTHN_LEVEL_PKT_PRIVACY", 6) +RPC_C_IMP_LEVEL_DEFAULT = make_flag("RPC_C_IMP_LEVEL_DEFAULT", 0) +RPC_C_IMP_LEVEL_ANONYMOUS = make_flag("RPC_C_IMP_LEVEL_ANONYMOUS", 1) +RPC_C_IMP_LEVEL_IDENTIFY = make_flag("RPC_C_IMP_LEVEL_IDENTIFY", 2) +RPC_C_IMP_LEVEL_IMPERSONATE = make_flag("RPC_C_IMP_LEVEL_IMPERSONATE", 3) +RPC_C_IMP_LEVEL_DELEGATE = make_flag("RPC_C_IMP_LEVEL_DELEGATE", 4) +RPC_C_QOS_IDENTITY_STATIC = make_flag("RPC_C_QOS_IDENTITY_STATIC", 0) +RPC_C_QOS_IDENTITY_DYNAMIC = make_flag("RPC_C_QOS_IDENTITY_DYNAMIC", 1) +RPC_C_QOS_CAPABILITIES_DEFAULT = make_flag("RPC_C_QOS_CAPABILITIES_DEFAULT", 0x0) +RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH = make_flag("RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH", 0x1) +RPC_C_QOS_CAPABILITIES_MAKE_FULLSIC = make_flag("RPC_C_QOS_CAPABILITIES_MAKE_FULLSIC", 0x2) +RPC_C_QOS_CAPABILITIES_ANY_AUTHORITY = make_flag("RPC_C_QOS_CAPABILITIES_ANY_AUTHORITY", 0x4) +MAX_ADAPTER_NAME = make_flag("MAX_ADAPTER_NAME", 128) +MAXLEN_PHYSADDR = make_flag("MAXLEN_PHYSADDR", 8) +MAXLEN_IFDESCR = make_flag("MAXLEN_IFDESCR", 256) +MAX_INTERFACE_NAME_LEN = make_flag("MAX_INTERFACE_NAME_LEN", 256) +OBJ_INHERIT = make_flag("OBJ_INHERIT", 0x00000002) +OBJ_PERMANENT = make_flag("OBJ_PERMANENT", 0x00000010) +OBJ_EXCLUSIVE = make_flag("OBJ_EXCLUSIVE", 0x00000020) +OBJ_CASE_INSENSITIVE = make_flag("OBJ_CASE_INSENSITIVE", 0x00000040) +OBJ_OPENIF = make_flag("OBJ_OPENIF", 0x00000080) +OBJ_OPENLINK = make_flag("OBJ_OPENLINK", 0x00000100) +OBJ_KERNEL_HANDLE = make_flag("OBJ_KERNEL_HANDLE", 0x00000200) +OBJ_FORCE_ACCESS_CHECK = make_flag("OBJ_FORCE_ACCESS_CHECK", 0x00000400) +OBJ_VALID_ATTRIBUTES = make_flag("OBJ_VALID_ATTRIBUTES", 0x000007F2) +FILE_SUPERSEDE = make_flag("FILE_SUPERSEDE", 0x00000000) +FILE_OPEN = make_flag("FILE_OPEN", 0x00000001) +FILE_CREATE = make_flag("FILE_CREATE", 0x00000002) +FILE_OPEN_IF = make_flag("FILE_OPEN_IF", 0x00000003) +FILE_OVERWRITE = make_flag("FILE_OVERWRITE", 0x00000004) +FILE_OVERWRITE_IF = make_flag("FILE_OVERWRITE_IF", 0x00000005) +FILE_MAXIMUM_DISPOSITION = make_flag("FILE_MAXIMUM_DISPOSITION", 0x00000005) +TRUST_E_PROVIDER_UNKNOWN = make_flag("TRUST_E_PROVIDER_UNKNOWN", ( 0x800B0001 )) +TRUST_E_ACTION_UNKNOWN = make_flag("TRUST_E_ACTION_UNKNOWN", ( 0x800B0002 )) +TRUST_E_SUBJECT_FORM_UNKNOWN = make_flag("TRUST_E_SUBJECT_FORM_UNKNOWN", ( 0x800B0003 )) +DIGSIG_E_ENCODE = make_flag("DIGSIG_E_ENCODE", ( 0x800B0005 )) +TRUST_E_SUBJECT_NOT_TRUSTED = make_flag("TRUST_E_SUBJECT_NOT_TRUSTED", ( 0x800B0004 )) +DIGSIG_E_DECODE = make_flag("DIGSIG_E_DECODE", ( 0x800B0006 )) +DIGSIG_E_EXTENSIBILITY = make_flag("DIGSIG_E_EXTENSIBILITY", ( 0x800B0007 )) +PERSIST_E_SIZEDEFINITE = make_flag("PERSIST_E_SIZEDEFINITE", ( 0x800B0009 )) +DIGSIG_E_CRYPTO = make_flag("DIGSIG_E_CRYPTO", ( 0x800B0008 )) +PERSIST_E_SIZEINDEFINITE = make_flag("PERSIST_E_SIZEINDEFINITE", ( 0x800B000A )) +PERSIST_E_NOTSELFSIZING = make_flag("PERSIST_E_NOTSELFSIZING", ( 0x800B000B )) +TRUST_E_NOSIGNATURE = make_flag("TRUST_E_NOSIGNATURE", ( 0x800B0100 )) +TRUST_E_BAD_DIGEST = make_flag("TRUST_E_BAD_DIGEST", ( 0x80096010 )) +CERT_E_EXPIRED = make_flag("CERT_E_EXPIRED", ( 0x800B0101 )) +CERT_E_VALIDITYPERIODNESTING = make_flag("CERT_E_VALIDITYPERIODNESTING", ( 0x800B0102 )) +CERT_E_PURPOSE = make_flag("CERT_E_PURPOSE", ( 0x800B0106 )) +CERT_E_ISSUERCHAINING = make_flag("CERT_E_ISSUERCHAINING", ( 0x800B0107 )) +CERT_E_MALFORMED = make_flag("CERT_E_MALFORMED", ( 0x800B0108 )) +CERT_E_UNTRUSTEDROOT = make_flag("CERT_E_UNTRUSTEDROOT", ( 0x800B0109 )) +CERT_E_CHAINING = make_flag("CERT_E_CHAINING", ( 0x800B010A )) +TRUST_E_FAIL = make_flag("TRUST_E_FAIL", ( 0x800B010B )) +CERT_E_REVOKED = make_flag("CERT_E_REVOKED", ( 0x800B010C )) +CERT_E_UNTRUSTEDTESTROOT = make_flag("CERT_E_UNTRUSTEDTESTROOT", ( 0x800B010D )) +CERT_E_REVOCATION_FAILURE = make_flag("CERT_E_REVOCATION_FAILURE", ( 0x800B010E )) +CERT_E_CN_NO_MATCH = make_flag("CERT_E_CN_NO_MATCH", ( 0x800B010F )) +CERT_E_WRONG_USAGE = make_flag("CERT_E_WRONG_USAGE", ( 0x800B0110 )) +TRUST_E_EXPLICIT_DISTRUST = make_flag("TRUST_E_EXPLICIT_DISTRUST", ( 0x800B0111 )) +CERT_E_UNTRUSTEDCA = make_flag("CERT_E_UNTRUSTEDCA", ( 0x800B0112 )) +CERT_E_INVALID_POLICY = make_flag("CERT_E_INVALID_POLICY", ( 0x800B0113 )) +CERT_E_INVALID_NAME = make_flag("CERT_E_INVALID_NAME", ( 0x800B0114 )) +CRYPT_E_FILE_ERROR = make_flag("CRYPT_E_FILE_ERROR", ( 0x80092003 )) +CRYPT_E_MSG_ERROR = make_flag("CRYPT_E_MSG_ERROR", ( 0x80091001 )) +CRYPT_E_UNKNOWN_ALGO = make_flag("CRYPT_E_UNKNOWN_ALGO", ( 0x80091002 )) +CRYPT_E_OID_FORMAT = make_flag("CRYPT_E_OID_FORMAT", ( 0x80091003 )) +CRYPT_E_INVALID_MSG_TYPE = make_flag("CRYPT_E_INVALID_MSG_TYPE", ( 0x80091004 )) +CRYPT_E_UNEXPECTED_ENCODING = make_flag("CRYPT_E_UNEXPECTED_ENCODING", ( 0x80091005 )) +CRYPT_E_AUTH_ATTR_MISSING = make_flag("CRYPT_E_AUTH_ATTR_MISSING", ( 0x80091006 )) +CRYPT_E_HASH_VALUE = make_flag("CRYPT_E_HASH_VALUE", ( 0x80091007 )) +E_INVALIDARG = make_flag("E_INVALIDARG", ( 0x80070057 )) +CRYPT_E_NOT_DECRYPTED = make_flag("CRYPT_E_NOT_DECRYPTED", ( 0x8009100A )) +CRYPT_E_INVALID_INDEX = make_flag("CRYPT_E_INVALID_INDEX", ( 0x80091008 )) +CRYPT_E_ATTRIBUTES_MISSING = make_flag("CRYPT_E_ATTRIBUTES_MISSING", ( 0x8009100F )) +IMAGE_SCN_TYPE_REG = make_flag("IMAGE_SCN_TYPE_REG", 0x00000000) +IMAGE_SCN_TYPE_DSECT = make_flag("IMAGE_SCN_TYPE_DSECT", 0x00000001) +IMAGE_SCN_TYPE_NOLOAD = make_flag("IMAGE_SCN_TYPE_NOLOAD", 0x00000002) +IMAGE_SCN_TYPE_GROUP = make_flag("IMAGE_SCN_TYPE_GROUP", 0x00000004) +IMAGE_SCN_TYPE_NO_PAD = make_flag("IMAGE_SCN_TYPE_NO_PAD", 0x00000008) +IMAGE_SCN_TYPE_COPY = make_flag("IMAGE_SCN_TYPE_COPY", 0x00000010) +IMAGE_SCN_CNT_CODE = make_flag("IMAGE_SCN_CNT_CODE", 0x00000020) +IMAGE_SCN_CNT_INITIALIZED_DATA = make_flag("IMAGE_SCN_CNT_INITIALIZED_DATA", 0x00000040) +IMAGE_SCN_CNT_UNINITIALIZED_DATA = make_flag("IMAGE_SCN_CNT_UNINITIALIZED_DATA", 0x00000080) +IMAGE_SCN_LNK_OTHER = make_flag("IMAGE_SCN_LNK_OTHER", 0x00000100) +IMAGE_SCN_LNK_INFO = make_flag("IMAGE_SCN_LNK_INFO", 0x00000200) +IMAGE_SCN_TYPE_OVER = make_flag("IMAGE_SCN_TYPE_OVER", 0x00000400) +IMAGE_SCN_LNK_REMOVE = make_flag("IMAGE_SCN_LNK_REMOVE", 0x00000800) +IMAGE_SCN_LNK_COMDAT = make_flag("IMAGE_SCN_LNK_COMDAT", 0x00001000) +IMAGE_SCN_NO_DEFER_SPEC_EXC = make_flag("IMAGE_SCN_NO_DEFER_SPEC_EXC", 0x00004000) +IMAGE_SCN_GPREL = make_flag("IMAGE_SCN_GPREL", 0x00008000) +IMAGE_SCN_MEM_FARDATA = make_flag("IMAGE_SCN_MEM_FARDATA", 0x00008000) +IMAGE_SCN_MEM_PURGEABLE = make_flag("IMAGE_SCN_MEM_PURGEABLE", 0x00020000) +IMAGE_SCN_MEM_16BIT = make_flag("IMAGE_SCN_MEM_16BIT", 0x00020000) +IMAGE_SCN_MEM_LOCKED = make_flag("IMAGE_SCN_MEM_LOCKED", 0x00040000) +IMAGE_SCN_MEM_PRELOAD = make_flag("IMAGE_SCN_MEM_PRELOAD", 0x00080000) +IMAGE_SCN_ALIGN_1BYTES = make_flag("IMAGE_SCN_ALIGN_1BYTES", 0x00100000) +IMAGE_SCN_ALIGN_2BYTES = make_flag("IMAGE_SCN_ALIGN_2BYTES", 0x00200000) +IMAGE_SCN_ALIGN_4BYTES = make_flag("IMAGE_SCN_ALIGN_4BYTES", 0x00300000) +IMAGE_SCN_ALIGN_8BYTES = make_flag("IMAGE_SCN_ALIGN_8BYTES", 0x00400000) +IMAGE_SCN_ALIGN_16BYTES = make_flag("IMAGE_SCN_ALIGN_16BYTES", 0x00500000) +IMAGE_SCN_ALIGN_32BYTES = make_flag("IMAGE_SCN_ALIGN_32BYTES", 0x00600000) +IMAGE_SCN_ALIGN_64BYTES = make_flag("IMAGE_SCN_ALIGN_64BYTES", 0x00700000) +IMAGE_SCN_ALIGN_128BYTES = make_flag("IMAGE_SCN_ALIGN_128BYTES", 0x00800000) +IMAGE_SCN_ALIGN_256BYTES = make_flag("IMAGE_SCN_ALIGN_256BYTES", 0x00900000) +IMAGE_SCN_ALIGN_512BYTES = make_flag("IMAGE_SCN_ALIGN_512BYTES", 0x00A00000) +IMAGE_SCN_ALIGN_1024BYTES = make_flag("IMAGE_SCN_ALIGN_1024BYTES", 0x00B00000) +IMAGE_SCN_ALIGN_2048BYTES = make_flag("IMAGE_SCN_ALIGN_2048BYTES", 0x00C00000) +IMAGE_SCN_ALIGN_4096BYTES = make_flag("IMAGE_SCN_ALIGN_4096BYTES", 0x00D00000) +IMAGE_SCN_ALIGN_8192BYTES = make_flag("IMAGE_SCN_ALIGN_8192BYTES", 0x00E00000) +IMAGE_SCN_ALIGN_MASK = make_flag("IMAGE_SCN_ALIGN_MASK", 0x00F00000) +IMAGE_SCN_LNK_NRELOC_OVFL = make_flag("IMAGE_SCN_LNK_NRELOC_OVFL", 0x01000000) +IMAGE_SCN_MEM_DISCARDABLE = make_flag("IMAGE_SCN_MEM_DISCARDABLE", 0x02000000) +IMAGE_SCN_MEM_NOT_CACHED = make_flag("IMAGE_SCN_MEM_NOT_CACHED", 0x04000000) +IMAGE_SCN_MEM_NOT_PAGED = make_flag("IMAGE_SCN_MEM_NOT_PAGED", 0x08000000) +IMAGE_SCN_MEM_SHARED = make_flag("IMAGE_SCN_MEM_SHARED", 0x10000000) +IMAGE_SCN_MEM_EXECUTE = make_flag("IMAGE_SCN_MEM_EXECUTE", 0x20000000) +IMAGE_SCN_MEM_READ = make_flag("IMAGE_SCN_MEM_READ", 0x40000000) +IMAGE_SCN_MEM_WRITE = make_flag("IMAGE_SCN_MEM_WRITE", 0x80000000) +LPC_REQUEST = make_flag("LPC_REQUEST", 1) +LPC_REPLY = make_flag("LPC_REPLY", 2) +LPC_DATAGRAM = make_flag("LPC_DATAGRAM", 3) +LPC_LOST_REPLY = make_flag("LPC_LOST_REPLY", 4) +LPC_PORT_CLOSED = make_flag("LPC_PORT_CLOSED", 5) +LPC_CLIENT_DIED = make_flag("LPC_CLIENT_DIED", 6) +LPC_EXCEPTION = make_flag("LPC_EXCEPTION", 7) +LPC_DEBUG_EVENT = make_flag("LPC_DEBUG_EVENT", 8) +LPC_ERROR_EVENT = make_flag("LPC_ERROR_EVENT", 9) +LPC_CONNECTION_REQUEST = make_flag("LPC_CONNECTION_REQUEST", 10) +ALPC_MESSAGE_SECURITY_ATTRIBUTE = make_flag("ALPC_MESSAGE_SECURITY_ATTRIBUTE", 0x80000000) +ALPC_MESSAGE_VIEW_ATTRIBUTE = make_flag("ALPC_MESSAGE_VIEW_ATTRIBUTE", 0x40000000) +ALPC_MESSAGE_CONTEXT_ATTRIBUTE = make_flag("ALPC_MESSAGE_CONTEXT_ATTRIBUTE", 0x20000000) +ALPC_MESSAGE_HANDLE_ATTRIBUTE = make_flag("ALPC_MESSAGE_HANDLE_ATTRIBUTE", 0x10000000) +ALPC_MESSAGE_TOKEN_ATTRIBUTE = make_flag("ALPC_MESSAGE_TOKEN_ATTRIBUTE", 0x8000000) +ALPC_MESSAGE_DIRECT_ATTRIBUTE = make_flag("ALPC_MESSAGE_DIRECT_ATTRIBUTE", 0x4000000) +ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE = make_flag("ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE", 0x2000000) +ALPC_MSGFLG_REPLY_MESSAGE = make_flag("ALPC_MSGFLG_REPLY_MESSAGE", 0x1) +ALPC_MSGFLG_LPC_MODE = make_flag("ALPC_MSGFLG_LPC_MODE", 0x2) +ALPC_MSGFLG_RELEASE_MESSAGE = make_flag("ALPC_MSGFLG_RELEASE_MESSAGE", 0x10000) +ALPC_MSGFLG_SYNC_REQUEST = make_flag("ALPC_MSGFLG_SYNC_REQUEST", 0x20000) +ALPC_MSGFLG_WAIT_USER_MODE = make_flag("ALPC_MSGFLG_WAIT_USER_MODE", 0x100000) +ALPC_MSGFLG_WAIT_ALERTABLE = make_flag("ALPC_MSGFLG_WAIT_ALERTABLE", 0x200000) +ALPC_MSGFLG_WOW64_CALL = make_flag("ALPC_MSGFLG_WOW64_CALL", 0x80000000) +ALPC_PORFLG_ALLOW_LPC_REQUESTS = make_flag("ALPC_PORFLG_ALLOW_LPC_REQUESTS", 0x20000) +ALPC_PORFLG_WAITABLE_PORT = make_flag("ALPC_PORFLG_WAITABLE_PORT", 0x40000) +ALPC_PORFLG_SYSTEM_PROCESS = make_flag("ALPC_PORFLG_SYSTEM_PROCESS", 0x100000) +ALPC_CANCELFLG_TRY_CANCEL = make_flag("ALPC_CANCELFLG_TRY_CANCEL", 0x1) +ALPC_CANCELFLG_NO_CONTEXT_CHECK = make_flag("ALPC_CANCELFLG_NO_CONTEXT_CHECK", 0x8) +ALPC_CANCELFLGP_FLUSH = make_flag("ALPC_CANCELFLGP_FLUSH", 0x10000) +ALPC_HANDLEFLG_DUPLICATE_SAME_ACCESS = make_flag("ALPC_HANDLEFLG_DUPLICATE_SAME_ACCESS", 0x10000) +ALPC_HANDLEFLG_DUPLICATE_SAME_ATTRIBUTES = make_flag("ALPC_HANDLEFLG_DUPLICATE_SAME_ATTRIBUTES", 0x20000) +ALPC_HANDLEFLG_DUPLICATE_INHERIT = make_flag("ALPC_HANDLEFLG_DUPLICATE_INHERIT", 0x80000) +ALPC_SECFLG_CREATE_HANDLE = make_flag("ALPC_SECFLG_CREATE_HANDLE", 0x20000) +ALPC_VIEWFLG_NOT_SECURE = make_flag("ALPC_VIEWFLG_NOT_SECURE", 0x40000) +CERT_STORE_CERTIFICATE_CONTEXT = make_flag("CERT_STORE_CERTIFICATE_CONTEXT", 1) +CERT_STORE_CRL_CONTEXT = make_flag("CERT_STORE_CRL_CONTEXT", 2) +CERT_STORE_CTL_CONTEXT = make_flag("CERT_STORE_CTL_CONTEXT", 3) +WTD_UI_ALL = make_flag("WTD_UI_ALL", 1) +WTD_UI_NONE = make_flag("WTD_UI_NONE", 2) +WTD_UI_NOBAD = make_flag("WTD_UI_NOBAD", 3) +WTD_UI_NOGOOD = make_flag("WTD_UI_NOGOOD", 4) +WTD_REVOKE_NONE = make_flag("WTD_REVOKE_NONE", 0x00000000) +WTD_REVOKE_WHOLECHAIN = make_flag("WTD_REVOKE_WHOLECHAIN", 0x00000001) +WTD_CHOICE_FILE = make_flag("WTD_CHOICE_FILE", 1) +WTD_CHOICE_CATALOG = make_flag("WTD_CHOICE_CATALOG", 2) +WTD_CHOICE_BLOB = make_flag("WTD_CHOICE_BLOB", 3) +WTD_CHOICE_SIGNER = make_flag("WTD_CHOICE_SIGNER", 4) +WTD_CHOICE_CERT = make_flag("WTD_CHOICE_CERT", 5) +WTD_STATEACTION_IGNORE = make_flag("WTD_STATEACTION_IGNORE", 0x00000000) +WTD_STATEACTION_VERIFY = make_flag("WTD_STATEACTION_VERIFY", 0x00000001) +WTD_STATEACTION_CLOSE = make_flag("WTD_STATEACTION_CLOSE", 0x00000002) +WTD_STATEACTION_AUTO_CACHE = make_flag("WTD_STATEACTION_AUTO_CACHE", 0x00000003) +WTD_STATEACTION_AUTO_CACHE_FLUSH = make_flag("WTD_STATEACTION_AUTO_CACHE_FLUSH", 0x00000004) +COMPRESSION_FORMAT_NONE = make_flag("COMPRESSION_FORMAT_NONE", ( 0x0000 )) +COMPRESSION_FORMAT_DEFAULT = make_flag("COMPRESSION_FORMAT_DEFAULT", ( 0x0001 )) +COMPRESSION_FORMAT_LZNT1 = make_flag("COMPRESSION_FORMAT_LZNT1", ( 0x0002 )) +COMPRESSION_FORMAT_XPRESS = make_flag("COMPRESSION_FORMAT_XPRESS", ( 0x0003 )) +COMPRESSION_FORMAT_XPRESS_HUFF = make_flag("COMPRESSION_FORMAT_XPRESS_HUFF", ( 0x0004 )) +COMPRESSION_ENGINE_STANDARD = make_flag("COMPRESSION_ENGINE_STANDARD", ( 0x0000 )) +COMPRESSION_ENGINE_MAXIMUM = make_flag("COMPRESSION_ENGINE_MAXIMUM", ( 0x0100 )) +COMPRESSION_ENGINE_HIBER = make_flag("COMPRESSION_ENGINE_HIBER", ( 0x0200 )) +FILE_DIRECTORY_FILE = make_flag("FILE_DIRECTORY_FILE", 0x00000001) +FILE_WRITE_THROUGH = make_flag("FILE_WRITE_THROUGH", 0x00000002) +FILE_SEQUENTIAL_ONLY = make_flag("FILE_SEQUENTIAL_ONLY", 0x00000004) +FILE_NO_INTERMEDIATE_BUFFERING = make_flag("FILE_NO_INTERMEDIATE_BUFFERING", 0x00000008) +FILE_SYNCHRONOUS_IO_ALERT = make_flag("FILE_SYNCHRONOUS_IO_ALERT", 0x00000010) +FILE_SYNCHRONOUS_IO_NONALERT = make_flag("FILE_SYNCHRONOUS_IO_NONALERT", 0x00000020) +FILE_NON_DIRECTORY_FILE = make_flag("FILE_NON_DIRECTORY_FILE", 0x00000040) +FILE_CREATE_TREE_CONNECTION = make_flag("FILE_CREATE_TREE_CONNECTION", 0x00000080) +FILE_COMPLETE_IF_OPLOCKED = make_flag("FILE_COMPLETE_IF_OPLOCKED", 0x00000100) +FILE_NO_EA_KNOWLEDGE = make_flag("FILE_NO_EA_KNOWLEDGE", 0x00000200) +FILE_OPEN_REMOTE_INSTANCE = make_flag("FILE_OPEN_REMOTE_INSTANCE", 0x00000400) +FILE_RANDOM_ACCESS = make_flag("FILE_RANDOM_ACCESS", 0x00000800) +FILE_DELETE_ON_CLOSE = make_flag("FILE_DELETE_ON_CLOSE", 0x00001000) +FILE_OPEN_BY_FILE_ID = make_flag("FILE_OPEN_BY_FILE_ID", 0x00002000) +FILE_OPEN_FOR_BACKUP_INTENT = make_flag("FILE_OPEN_FOR_BACKUP_INTENT", 0x00004000) +FILE_NO_COMPRESSION = make_flag("FILE_NO_COMPRESSION", 0x00008000) +FILE_OPEN_REQUIRING_OPLOCK = make_flag("FILE_OPEN_REQUIRING_OPLOCK", 0x00010000) +FILE_RESERVE_OPFILTER = make_flag("FILE_RESERVE_OPFILTER", 0x00100000) +FILE_OPEN_REPARSE_POINT = make_flag("FILE_OPEN_REPARSE_POINT", 0x00200000) +FILE_OPEN_NO_RECALL = make_flag("FILE_OPEN_NO_RECALL", 0x00400000) +FILE_OPEN_FOR_FREE_SPACE_QUERY = make_flag("FILE_OPEN_FOR_FREE_SPACE_QUERY", 0x00800000) +FILE_VALID_OPTION_FLAGS = make_flag("FILE_VALID_OPTION_FLAGS", 0x00ffffff) +FILE_VALID_PIPE_OPTION_FLAGS = make_flag("FILE_VALID_PIPE_OPTION_FLAGS", 0x00000032) +FILE_VALID_MAILSLOT_OPTION_FLAGS = make_flag("FILE_VALID_MAILSLOT_OPTION_FLAGS", 0x00000032) +FILE_VALID_SET_FLAGS = make_flag("FILE_VALID_SET_FLAGS", 0x00000036) +FILE_SUPERSEDED = make_flag("FILE_SUPERSEDED", 0x00000000) +FILE_OPENED = make_flag("FILE_OPENED", 0x00000001) +FILE_CREATED = make_flag("FILE_CREATED", 0x00000002) +FILE_OVERWRITTEN = make_flag("FILE_OVERWRITTEN", 0x00000003) +FILE_EXISTS = make_flag("FILE_EXISTS", 0x00000004) +FILE_DOES_NOT_EXIST = make_flag("FILE_DOES_NOT_EXIST", 0x00000005) +API_SET_SCHEMA_VERSION_V2 = make_flag("API_SET_SCHEMA_VERSION_V2", 0x00000002) +API_SET_SCHEMA_VERSION_V3 = make_flag("API_SET_SCHEMA_VERSION_V3", 0x00000003) +API_SET_SCHEMA_VERSION_V4 = make_flag("API_SET_SCHEMA_VERSION_V4", 0x00000004) +API_SET_LOAD_SCHEMA_ORDINAL = make_flag("API_SET_LOAD_SCHEMA_ORDINAL", 1) +API_SET_LOOKUP_ORDINAL = make_flag("API_SET_LOOKUP_ORDINAL", 2) +API_SET_RELEASE_SCHEMA_ORDINAL = make_flag("API_SET_RELEASE_SCHEMA_ORDINAL", 3) +API_SET_SCHEMA_FLAGS_SEALED = make_flag("API_SET_SCHEMA_FLAGS_SEALED", 0x00000001) +API_SET_SCHEMA_FLAGS_HOST_EXTENSION = make_flag("API_SET_SCHEMA_FLAGS_HOST_EXTENSION", 0x00000002) +API_SET_SCHEMA_ENTRY_FLAGS_SEALED = make_flag("API_SET_SCHEMA_ENTRY_FLAGS_SEALED", 0x00000001) +API_SET_SCHEMA_ENTRY_FLAGS_EXTENSION = make_flag("API_SET_SCHEMA_ENTRY_FLAGS_EXTENSION", 0x00000002) +CMSG_VERIFY_SIGNER_PUBKEY = make_flag("CMSG_VERIFY_SIGNER_PUBKEY", 1) +CMSG_VERIFY_SIGNER_CERT = make_flag("CMSG_VERIFY_SIGNER_CERT", 2) +CMSG_VERIFY_SIGNER_CHAIN = make_flag("CMSG_VERIFY_SIGNER_CHAIN", 3) +CMSG_VERIFY_SIGNER_NULL = make_flag("CMSG_VERIFY_SIGNER_NULL", 4) +TXFS_MINIVERSION_COMMITTED_VIEW = make_flag("TXFS_MINIVERSION_COMMITTED_VIEW", ( 0x0000 )) +TXFS_MINIVERSION_DIRTY_VIEW = make_flag("TXFS_MINIVERSION_DIRTY_VIEW", ( 0xFFFF )) +TXFS_MINIVERSION_DEFAULT_VIEW = make_flag("TXFS_MINIVERSION_DEFAULT_VIEW", ( 0xFFFE )) +ATM_E164 = make_flag("ATM_E164", 0x01) +ATM_NSAP = make_flag("ATM_NSAP", 0x02) +ATM_AESA = make_flag("ATM_AESA", 0x02) +ATM_ADDR_SIZE = make_flag("ATM_ADDR_SIZE", 20) +DNS_ATMA_FORMAT_E164 = make_flag("DNS_ATMA_FORMAT_E164", ATM_E164) +DNS_ATMA_FORMAT_AESA = make_flag("DNS_ATMA_FORMAT_AESA", ATM_AESA) +DNS_ATMA_MAX_ADDR_LENGTH = make_flag("DNS_ATMA_MAX_ADDR_LENGTH", ATM_ADDR_SIZE) +DNS_TYPE_ZERO = make_flag("DNS_TYPE_ZERO", 0x0000) +DNS_TYPE_A = make_flag("DNS_TYPE_A", 0x0001) +DNS_TYPE_NS = make_flag("DNS_TYPE_NS", 0x0002) +DNS_TYPE_MD = make_flag("DNS_TYPE_MD", 0x0003) +DNS_TYPE_MF = make_flag("DNS_TYPE_MF", 0x0004) +DNS_TYPE_CNAME = make_flag("DNS_TYPE_CNAME", 0x0005) +DNS_TYPE_SOA = make_flag("DNS_TYPE_SOA", 0x0006) +DNS_TYPE_MB = make_flag("DNS_TYPE_MB", 0x0007) +DNS_TYPE_MG = make_flag("DNS_TYPE_MG", 0x0008) +DNS_TYPE_MR = make_flag("DNS_TYPE_MR", 0x0009) +DNS_TYPE_NULL = make_flag("DNS_TYPE_NULL", 0x000a) +DNS_TYPE_WKS = make_flag("DNS_TYPE_WKS", 0x000b) +DNS_TYPE_PTR = make_flag("DNS_TYPE_PTR", 0x000c) +DNS_TYPE_HINFO = make_flag("DNS_TYPE_HINFO", 0x000d) +DNS_TYPE_MINFO = make_flag("DNS_TYPE_MINFO", 0x000e) +DNS_TYPE_MX = make_flag("DNS_TYPE_MX", 0x000f) +DNS_TYPE_TEXT = make_flag("DNS_TYPE_TEXT", 0x0010) +DNS_TYPE_RP = make_flag("DNS_TYPE_RP", 0x0011) +DNS_TYPE_AFSDB = make_flag("DNS_TYPE_AFSDB", 0x0012) +DNS_TYPE_X25 = make_flag("DNS_TYPE_X25", 0x0013) +DNS_TYPE_ISDN = make_flag("DNS_TYPE_ISDN", 0x0014) +DNS_TYPE_RT = make_flag("DNS_TYPE_RT", 0x0015) +DNS_TYPE_NSAP = make_flag("DNS_TYPE_NSAP", 0x0016) +DNS_TYPE_NSAPPTR = make_flag("DNS_TYPE_NSAPPTR", 0x0017) +DNS_TYPE_SIG = make_flag("DNS_TYPE_SIG", 0x0018) +DNS_TYPE_KEY = make_flag("DNS_TYPE_KEY", 0x0019) +DNS_TYPE_PX = make_flag("DNS_TYPE_PX", 0x001a) +DNS_TYPE_GPOS = make_flag("DNS_TYPE_GPOS", 0x001b) +DNS_TYPE_AAAA = make_flag("DNS_TYPE_AAAA", 0x001c) +DNS_TYPE_LOC = make_flag("DNS_TYPE_LOC", 0x001d) +DNS_TYPE_NXT = make_flag("DNS_TYPE_NXT", 0x001e) +DNS_TYPE_EID = make_flag("DNS_TYPE_EID", 0x001f) +DNS_TYPE_NIMLOC = make_flag("DNS_TYPE_NIMLOC", 0x0020) +DNS_TYPE_SRV = make_flag("DNS_TYPE_SRV", 0x0021) +DNS_TYPE_ATMA = make_flag("DNS_TYPE_ATMA", 0x0022) +DNS_TYPE_NAPTR = make_flag("DNS_TYPE_NAPTR", 0x0023) +DNS_TYPE_KX = make_flag("DNS_TYPE_KX", 0x0024) +DNS_TYPE_CERT = make_flag("DNS_TYPE_CERT", 0x0025) +DNS_TYPE_A6 = make_flag("DNS_TYPE_A6", 0x0026) +DNS_TYPE_DNAME = make_flag("DNS_TYPE_DNAME", 0x0027) +DNS_TYPE_SINK = make_flag("DNS_TYPE_SINK", 0x0028) +DNS_TYPE_OPT = make_flag("DNS_TYPE_OPT", 0x0029) +DNS_TYPE_DS = make_flag("DNS_TYPE_DS", 0x002b) +DNS_TYPE_RRSIG = make_flag("DNS_TYPE_RRSIG", 0x002e) +DNS_TYPE_NSEC = make_flag("DNS_TYPE_NSEC", 0x002f) +DNS_TYPE_DNSKEY = make_flag("DNS_TYPE_DNSKEY", 0x0030) +DNS_TYPE_DHCID = make_flag("DNS_TYPE_DHCID", 0x0031) +DNS_TYPE_NSEC3 = make_flag("DNS_TYPE_NSEC3", 0x0032) +DNS_TYPE_NSEC3PARAM = make_flag("DNS_TYPE_NSEC3PARAM", 0x0033) +DNS_TYPE_UINFO = make_flag("DNS_TYPE_UINFO", 0x0064) +DNS_TYPE_UID = make_flag("DNS_TYPE_UID", 0x0065) +DNS_TYPE_GID = make_flag("DNS_TYPE_GID", 0x0066) +DNS_TYPE_UNSPEC = make_flag("DNS_TYPE_UNSPEC", 0x0067) +DNS_TYPE_ADDRS = make_flag("DNS_TYPE_ADDRS", 0x00f8) +DNS_TYPE_TKEY = make_flag("DNS_TYPE_TKEY", 0x00f9) +DNS_TYPE_TSIG = make_flag("DNS_TYPE_TSIG", 0x00fa) +DNS_TYPE_IXFR = make_flag("DNS_TYPE_IXFR", 0x00fb) +DNS_TYPE_AXFR = make_flag("DNS_TYPE_AXFR", 0x00fc) +DNS_TYPE_MAILB = make_flag("DNS_TYPE_MAILB", 0x00fd) +DNS_TYPE_MAILA = make_flag("DNS_TYPE_MAILA", 0x00fe) +DNS_TYPE_ALL = make_flag("DNS_TYPE_ALL", 0x00ff) +DNS_TYPE_ANY = make_flag("DNS_TYPE_ANY", 0x00ff) +DNS_TYPE_WINS = make_flag("DNS_TYPE_WINS", 0xff01) +DNS_TYPE_WINSR = make_flag("DNS_TYPE_WINSR", 0xff02) +DNS_TYPE_NBSTAT = make_flag("DNS_TYPE_NBSTAT", ( DNS_TYPE_WINSR )) +DNS_QUERY_STANDARD = make_flag("DNS_QUERY_STANDARD", 0x00000000) +DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE = make_flag("DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE", 0x00000001) +DNS_QUERY_USE_TCP_ONLY = make_flag("DNS_QUERY_USE_TCP_ONLY", 0x00000002) +DNS_QUERY_NO_RECURSION = make_flag("DNS_QUERY_NO_RECURSION", 0x00000004) +DNS_QUERY_BYPASS_CACHE = make_flag("DNS_QUERY_BYPASS_CACHE", 0x00000008) +DNS_QUERY_NO_WIRE_QUERY = make_flag("DNS_QUERY_NO_WIRE_QUERY", 0x00000010) +DNS_QUERY_NO_LOCAL_NAME = make_flag("DNS_QUERY_NO_LOCAL_NAME", 0x00000020) +DNS_QUERY_NO_HOSTS_FILE = make_flag("DNS_QUERY_NO_HOSTS_FILE", 0x00000040) +DNS_QUERY_NO_NETBT = make_flag("DNS_QUERY_NO_NETBT", 0x00000080) +DNS_QUERY_WIRE_ONLY = make_flag("DNS_QUERY_WIRE_ONLY", 0x00000100) +DNS_QUERY_RETURN_MESSAGE = make_flag("DNS_QUERY_RETURN_MESSAGE", 0x00000200) +DNS_QUERY_MULTICAST_ONLY = make_flag("DNS_QUERY_MULTICAST_ONLY", 0x00000400) +DNS_QUERY_NO_MULTICAST = make_flag("DNS_QUERY_NO_MULTICAST", 0x00000800) +DNS_QUERY_TREAT_AS_FQDN = make_flag("DNS_QUERY_TREAT_AS_FQDN", 0x00001000) +DNS_QUERY_ADDRCONFIG = make_flag("DNS_QUERY_ADDRCONFIG", 0x00002000) +DNS_QUERY_DUAL_ADDR = make_flag("DNS_QUERY_DUAL_ADDR", 0x00004000) +DNS_QUERY_DONT_RESET_TTL_VALUES = make_flag("DNS_QUERY_DONT_RESET_TTL_VALUES", 0x00100000) +DNS_QUERY_DISABLE_IDN_ENCODING = make_flag("DNS_QUERY_DISABLE_IDN_ENCODING", 0x00200000) +DNS_QUERY_APPEND_MULTILABEL = make_flag("DNS_QUERY_APPEND_MULTILABEL", 0x00800000) +DNS_QUERY_DNSSEC_OK = make_flag("DNS_QUERY_DNSSEC_OK", 0x01000000) +DNS_QUERY_DNSSEC_CHECKING_DISABLED = make_flag("DNS_QUERY_DNSSEC_CHECKING_DISABLED", 0x02000000) +DNS_QUERY_RESERVED = make_flag("DNS_QUERY_RESERVED", 0xf0000000) +FC_ALLOCATE_ALL_NODES = make_flag("FC_ALLOCATE_ALL_NODES", 0x01) +FC_DONT_FREE = make_flag("FC_DONT_FREE", 0x02) +FC_ALLOCED_ON_STACK = make_flag("FC_ALLOCED_ON_STACK", 0x04) +FC_SIMPLE_POINTER = make_flag("FC_SIMPLE_POINTER", 0x08) +FC_POINTER_DEREF = make_flag("FC_POINTER_DEREF", 0x10) +CERT_QUERY_OBJECT_FILE = make_flag("CERT_QUERY_OBJECT_FILE", 0x00000001) +CERT_QUERY_OBJECT_BLOB = make_flag("CERT_QUERY_OBJECT_BLOB", 0x00000002) +CERT_QUERY_CONTENT_CERT = make_flag("CERT_QUERY_CONTENT_CERT", 1) +CERT_QUERY_CONTENT_CTL = make_flag("CERT_QUERY_CONTENT_CTL", 2) +CERT_QUERY_CONTENT_CRL = make_flag("CERT_QUERY_CONTENT_CRL", 3) +CERT_QUERY_CONTENT_SERIALIZED_STORE = make_flag("CERT_QUERY_CONTENT_SERIALIZED_STORE", 4) +CERT_QUERY_CONTENT_SERIALIZED_CERT = make_flag("CERT_QUERY_CONTENT_SERIALIZED_CERT", 5) +CERT_QUERY_CONTENT_SERIALIZED_CTL = make_flag("CERT_QUERY_CONTENT_SERIALIZED_CTL", 6) +CERT_QUERY_CONTENT_SERIALIZED_CRL = make_flag("CERT_QUERY_CONTENT_SERIALIZED_CRL", 7) +CERT_QUERY_CONTENT_PKCS7_SIGNED = make_flag("CERT_QUERY_CONTENT_PKCS7_SIGNED", 8) +CERT_QUERY_CONTENT_PKCS7_UNSIGNED = make_flag("CERT_QUERY_CONTENT_PKCS7_UNSIGNED", 9) +CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED = make_flag("CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED", 10) +CERT_QUERY_CONTENT_PKCS10 = make_flag("CERT_QUERY_CONTENT_PKCS10", 11) +CERT_QUERY_CONTENT_PFX = make_flag("CERT_QUERY_CONTENT_PFX", 12) +CERT_QUERY_CONTENT_CERT_PAIR = make_flag("CERT_QUERY_CONTENT_CERT_PAIR", 13) +CERT_QUERY_CONTENT_PFX_AND_LOAD = make_flag("CERT_QUERY_CONTENT_PFX_AND_LOAD", 14) +CERT_QUERY_FORMAT_BINARY = make_flag("CERT_QUERY_FORMAT_BINARY", 1) +CERT_QUERY_FORMAT_BASE64_ENCODED = make_flag("CERT_QUERY_FORMAT_BASE64_ENCODED", 2) +CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED = make_flag("CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED", 3) +CERT_QUERY_FORMAT_FLAG_BINARY = make_flag("CERT_QUERY_FORMAT_FLAG_BINARY", ( 1 << CERT_QUERY_FORMAT_BINARY )) +CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED = make_flag("CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED", ( 1 << CERT_QUERY_FORMAT_BASE64_ENCODED )) +CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED = make_flag("CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED", ( 1 << CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED )) +CERT_QUERY_FORMAT_FLAG_ALL = make_flag("CERT_QUERY_FORMAT_FLAG_ALL", ( CERT_QUERY_FORMAT_FLAG_BINARY | CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED | CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED )) +CERT_QUERY_CONTENT_FLAG_CERT = make_flag("CERT_QUERY_CONTENT_FLAG_CERT", ( 1 << CERT_QUERY_CONTENT_CERT )) +CERT_QUERY_CONTENT_FLAG_CTL = make_flag("CERT_QUERY_CONTENT_FLAG_CTL", ( 1 << CERT_QUERY_CONTENT_CTL )) +CERT_QUERY_CONTENT_FLAG_CRL = make_flag("CERT_QUERY_CONTENT_FLAG_CRL", ( 1 << CERT_QUERY_CONTENT_CRL )) +CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE = make_flag("CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE", ( 1 << CERT_QUERY_CONTENT_SERIALIZED_STORE )) +CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT = make_flag("CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT", ( 1 << CERT_QUERY_CONTENT_SERIALIZED_CERT )) +CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL = make_flag("CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL", ( 1 << CERT_QUERY_CONTENT_SERIALIZED_CTL )) +CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL = make_flag("CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL", ( 1 << CERT_QUERY_CONTENT_SERIALIZED_CRL )) +CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED = make_flag("CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED", ( 1 << CERT_QUERY_CONTENT_PKCS7_SIGNED )) +CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED = make_flag("CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED", ( 1 << CERT_QUERY_CONTENT_PKCS7_UNSIGNED )) +CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED = make_flag("CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED", ( 1 << CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED )) +CERT_QUERY_CONTENT_FLAG_PKCS10 = make_flag("CERT_QUERY_CONTENT_FLAG_PKCS10", ( 1 << CERT_QUERY_CONTENT_PKCS10 )) +CERT_QUERY_CONTENT_FLAG_PFX = make_flag("CERT_QUERY_CONTENT_FLAG_PFX", ( 1 << CERT_QUERY_CONTENT_PFX )) +CERT_QUERY_CONTENT_FLAG_CERT_PAIR = make_flag("CERT_QUERY_CONTENT_FLAG_CERT_PAIR", ( 1 << CERT_QUERY_CONTENT_CERT_PAIR )) +CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD = make_flag("CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD", ( 1 << CERT_QUERY_CONTENT_PFX_AND_LOAD )) +CERT_QUERY_CONTENT_FLAG_ALL = make_flag("CERT_QUERY_CONTENT_FLAG_ALL", ( CERT_QUERY_CONTENT_FLAG_CERT | CERT_QUERY_CONTENT_FLAG_CTL | CERT_QUERY_CONTENT_FLAG_CRL | CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED | CERT_QUERY_CONTENT_FLAG_PKCS10 | CERT_QUERY_CONTENT_FLAG_PFX | CERT_QUERY_CONTENT_FLAG_CERT_PAIR )) +CRYPT_ASN_ENCODING = make_flag("CRYPT_ASN_ENCODING", 0x00000001) +CRYPT_NDR_ENCODING = make_flag("CRYPT_NDR_ENCODING", 0x00000002) +X509_ASN_ENCODING = make_flag("X509_ASN_ENCODING", 0x00000001) +X509_NDR_ENCODING = make_flag("X509_NDR_ENCODING", 0x00000002) +PKCS_7_ASN_ENCODING = make_flag("PKCS_7_ASN_ENCODING", 0x00010000) +PKCS_7_NDR_ENCODING = make_flag("PKCS_7_NDR_ENCODING", 0x00020000) +CERT_ENCODING_TYPE_MASK = make_flag("CERT_ENCODING_TYPE_MASK", 0x0000FFFF) +CMSG_ENCODING_TYPE_MASK = make_flag("CMSG_ENCODING_TYPE_MASK", 0xFFFF0000) +CERT_COMPARE_MASK = make_flag("CERT_COMPARE_MASK", 0xFFFF) +CERT_COMPARE_SHIFT = make_flag("CERT_COMPARE_SHIFT", 16) +CERT_COMPARE_ANY = make_flag("CERT_COMPARE_ANY", 0) +CERT_COMPARE_SHA1_HASH = make_flag("CERT_COMPARE_SHA1_HASH", 1) +CERT_COMPARE_NAME = make_flag("CERT_COMPARE_NAME", 2) +CERT_COMPARE_ATTR = make_flag("CERT_COMPARE_ATTR", 3) +CERT_COMPARE_MD5_HASH = make_flag("CERT_COMPARE_MD5_HASH", 4) +CERT_COMPARE_PROPERTY = make_flag("CERT_COMPARE_PROPERTY", 5) +CERT_COMPARE_PUBLIC_KEY = make_flag("CERT_COMPARE_PUBLIC_KEY", 6) +CERT_COMPARE_HASH = make_flag("CERT_COMPARE_HASH", CERT_COMPARE_SHA1_HASH) +CERT_COMPARE_NAME_STR_A = make_flag("CERT_COMPARE_NAME_STR_A", 7) +CERT_COMPARE_NAME_STR_W = make_flag("CERT_COMPARE_NAME_STR_W", 8) +CERT_COMPARE_KEY_SPEC = make_flag("CERT_COMPARE_KEY_SPEC", 9) +CERT_COMPARE_ENHKEY_USAGE = make_flag("CERT_COMPARE_ENHKEY_USAGE", 10) +CERT_COMPARE_CTL_USAGE = make_flag("CERT_COMPARE_CTL_USAGE", CERT_COMPARE_ENHKEY_USAGE) +CERT_COMPARE_SUBJECT_CERT = make_flag("CERT_COMPARE_SUBJECT_CERT", 11) +CERT_COMPARE_ISSUER_OF = make_flag("CERT_COMPARE_ISSUER_OF", 12) +CERT_COMPARE_EXISTING = make_flag("CERT_COMPARE_EXISTING", 13) +CERT_COMPARE_SIGNATURE_HASH = make_flag("CERT_COMPARE_SIGNATURE_HASH", 14) +CERT_COMPARE_KEY_IDENTIFIER = make_flag("CERT_COMPARE_KEY_IDENTIFIER", 15) +CERT_COMPARE_CERT_ID = make_flag("CERT_COMPARE_CERT_ID", 16) +CERT_COMPARE_CROSS_CERT_DIST_POINTS = make_flag("CERT_COMPARE_CROSS_CERT_DIST_POINTS", 17) +CERT_COMPARE_PUBKEY_MD5_HASH = make_flag("CERT_COMPARE_PUBKEY_MD5_HASH", 18) +CERT_COMPARE_SUBJECT_INFO_ACCESS = make_flag("CERT_COMPARE_SUBJECT_INFO_ACCESS", 19) +CERT_NAME_ISSUER_FLAG = make_flag("CERT_NAME_ISSUER_FLAG", 0x1) +CERT_NAME_DISABLE_IE4_UTF8_FLAG = make_flag("CERT_NAME_DISABLE_IE4_UTF8_FLAG", 0x00010000) +USAGE_MATCH_TYPE_AND = make_flag("USAGE_MATCH_TYPE_AND", 0x00000000) +USAGE_MATCH_TYPE_OR = make_flag("USAGE_MATCH_TYPE_OR", 0x00000001) +CERT_CHAIN_REVOCATION_CHECK_END_CERT = make_flag("CERT_CHAIN_REVOCATION_CHECK_END_CERT", 0x10000000) +CERT_CHAIN_REVOCATION_CHECK_CHAIN = make_flag("CERT_CHAIN_REVOCATION_CHECK_CHAIN", 0x20000000) +CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT = make_flag("CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT", 0x40000000) +CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY = make_flag("CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY", 0x80000000) +CERT_TRUST_NO_ERROR = make_flag("CERT_TRUST_NO_ERROR", 0x00000000) +CERT_TRUST_IS_NOT_TIME_VALID = make_flag("CERT_TRUST_IS_NOT_TIME_VALID", 0x00000001) +CERT_TRUST_IS_NOT_TIME_NESTED = make_flag("CERT_TRUST_IS_NOT_TIME_NESTED", 0x00000002) +CERT_TRUST_IS_REVOKED = make_flag("CERT_TRUST_IS_REVOKED", 0x00000004) +CERT_TRUST_IS_NOT_SIGNATURE_VALID = make_flag("CERT_TRUST_IS_NOT_SIGNATURE_VALID", 0x00000008) +CERT_TRUST_IS_NOT_VALID_FOR_USAGE = make_flag("CERT_TRUST_IS_NOT_VALID_FOR_USAGE", 0x00000010) +CERT_TRUST_IS_UNTRUSTED_ROOT = make_flag("CERT_TRUST_IS_UNTRUSTED_ROOT", 0x00000020) +CERT_TRUST_REVOCATION_STATUS_UNKNOWN = make_flag("CERT_TRUST_REVOCATION_STATUS_UNKNOWN", 0x00000040) +CERT_TRUST_IS_CYCLIC = make_flag("CERT_TRUST_IS_CYCLIC", 0x00000080) +CERT_TRUST_INVALID_EXTENSION = make_flag("CERT_TRUST_INVALID_EXTENSION", 0x00000100) +CERT_TRUST_INVALID_POLICY_CONSTRAINTS = make_flag("CERT_TRUST_INVALID_POLICY_CONSTRAINTS", 0x00000200) +CERT_TRUST_INVALID_BASIC_CONSTRAINTS = make_flag("CERT_TRUST_INVALID_BASIC_CONSTRAINTS", 0x00000400) +CERT_TRUST_INVALID_NAME_CONSTRAINTS = make_flag("CERT_TRUST_INVALID_NAME_CONSTRAINTS", 0x00000800) +CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT = make_flag("CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT", 0x00001000) +CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT = make_flag("CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT", 0x00002000) +CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT = make_flag("CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT", 0x00004000) +CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT = make_flag("CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT", 0x00008000) +CERT_TRUST_IS_OFFLINE_REVOCATION = make_flag("CERT_TRUST_IS_OFFLINE_REVOCATION", 0x01000000) +CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY = make_flag("CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY", 0x02000000) +CERT_TRUST_IS_EXPLICIT_DISTRUST = make_flag("CERT_TRUST_IS_EXPLICIT_DISTRUST", 0x04000000) +CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT = make_flag("CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT", 0x08000000) +CERT_TRUST_IS_PARTIAL_CHAIN = make_flag("CERT_TRUST_IS_PARTIAL_CHAIN", 0x00010000) +CERT_TRUST_CTL_IS_NOT_TIME_VALID = make_flag("CERT_TRUST_CTL_IS_NOT_TIME_VALID", 0x00020000) +CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID = make_flag("CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID", 0x00040000) +CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE = make_flag("CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE", 0x00080000) +CERT_TRUST_HAS_EXACT_MATCH_ISSUER = make_flag("CERT_TRUST_HAS_EXACT_MATCH_ISSUER", 0x00000001) +CERT_TRUST_HAS_KEY_MATCH_ISSUER = make_flag("CERT_TRUST_HAS_KEY_MATCH_ISSUER", 0x00000002) +CERT_TRUST_HAS_NAME_MATCH_ISSUER = make_flag("CERT_TRUST_HAS_NAME_MATCH_ISSUER", 0x00000004) +CERT_TRUST_IS_SELF_SIGNED = make_flag("CERT_TRUST_IS_SELF_SIGNED", 0x00000008) +CERT_TRUST_HAS_PREFERRED_ISSUER = make_flag("CERT_TRUST_HAS_PREFERRED_ISSUER", 0x00000100) +CERT_TRUST_HAS_ISSUANCE_CHAIN_POLICY = make_flag("CERT_TRUST_HAS_ISSUANCE_CHAIN_POLICY", 0x00000200) +CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS = make_flag("CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS", 0x00000400) +CERT_TRUST_IS_PEER_TRUSTED = make_flag("CERT_TRUST_IS_PEER_TRUSTED", 0x00000800) +CERT_TRUST_HAS_CRL_VALIDITY_EXTENDED = make_flag("CERT_TRUST_HAS_CRL_VALIDITY_EXTENDED", 0x00001000) +CERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORE = make_flag("CERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORE", 0x00002000) +CERT_TRUST_IS_COMPLEX_CHAIN = make_flag("CERT_TRUST_IS_COMPLEX_CHAIN", 0x00010000) +CMSG_TYPE_PARAM = make_flag("CMSG_TYPE_PARAM", 1) +CMSG_CONTENT_PARAM = make_flag("CMSG_CONTENT_PARAM", 2) +CMSG_BARE_CONTENT_PARAM = make_flag("CMSG_BARE_CONTENT_PARAM", 3) +CMSG_INNER_CONTENT_TYPE_PARAM = make_flag("CMSG_INNER_CONTENT_TYPE_PARAM", 4) +CMSG_SIGNER_COUNT_PARAM = make_flag("CMSG_SIGNER_COUNT_PARAM", 5) +CMSG_SIGNER_INFO_PARAM = make_flag("CMSG_SIGNER_INFO_PARAM", 6) +CMSG_SIGNER_CERT_INFO_PARAM = make_flag("CMSG_SIGNER_CERT_INFO_PARAM", 7) +CMSG_SIGNER_HASH_ALGORITHM_PARAM = make_flag("CMSG_SIGNER_HASH_ALGORITHM_PARAM", 8) +CMSG_SIGNER_AUTH_ATTR_PARAM = make_flag("CMSG_SIGNER_AUTH_ATTR_PARAM", 9) +CMSG_SIGNER_UNAUTH_ATTR_PARAM = make_flag("CMSG_SIGNER_UNAUTH_ATTR_PARAM", 10) +CMSG_CERT_COUNT_PARAM = make_flag("CMSG_CERT_COUNT_PARAM", 11) +CMSG_CERT_PARAM = make_flag("CMSG_CERT_PARAM", 12) +CMSG_CRL_COUNT_PARAM = make_flag("CMSG_CRL_COUNT_PARAM", 13) +CMSG_CRL_PARAM = make_flag("CMSG_CRL_PARAM", 14) +CMSG_ENVELOPE_ALGORITHM_PARAM = make_flag("CMSG_ENVELOPE_ALGORITHM_PARAM", 15) +CMSG_RECIPIENT_COUNT_PARAM = make_flag("CMSG_RECIPIENT_COUNT_PARAM", 17) +CMSG_RECIPIENT_INDEX_PARAM = make_flag("CMSG_RECIPIENT_INDEX_PARAM", 18) +CMSG_RECIPIENT_INFO_PARAM = make_flag("CMSG_RECIPIENT_INFO_PARAM", 19) +CMSG_HASH_ALGORITHM_PARAM = make_flag("CMSG_HASH_ALGORITHM_PARAM", 20) +CMSG_HASH_DATA_PARAM = make_flag("CMSG_HASH_DATA_PARAM", 21) +CMSG_COMPUTED_HASH_PARAM = make_flag("CMSG_COMPUTED_HASH_PARAM", 22) +CMSG_ENCRYPT_PARAM = make_flag("CMSG_ENCRYPT_PARAM", 26) +CMSG_ENCRYPTED_DIGEST = make_flag("CMSG_ENCRYPTED_DIGEST", 27) +CMSG_ENCODED_SIGNER = make_flag("CMSG_ENCODED_SIGNER", 28) +CMSG_ENCODED_MESSAGE = make_flag("CMSG_ENCODED_MESSAGE", 29) +CMSG_VERSION_PARAM = make_flag("CMSG_VERSION_PARAM", 30) +CMSG_ATTR_CERT_COUNT_PARAM = make_flag("CMSG_ATTR_CERT_COUNT_PARAM", 31) +CMSG_ATTR_CERT_PARAM = make_flag("CMSG_ATTR_CERT_PARAM", 32) +CMSG_CMS_RECIPIENT_COUNT_PARAM = make_flag("CMSG_CMS_RECIPIENT_COUNT_PARAM", 33) +CMSG_CMS_RECIPIENT_INDEX_PARAM = make_flag("CMSG_CMS_RECIPIENT_INDEX_PARAM", 34) +CMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAM = make_flag("CMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAM", 35) +CMSG_CMS_RECIPIENT_INFO_PARAM = make_flag("CMSG_CMS_RECIPIENT_INFO_PARAM", 36) +CMSG_UNPROTECTED_ATTR_PARAM = make_flag("CMSG_UNPROTECTED_ATTR_PARAM", 37) +CMSG_SIGNER_CERT_ID_PARAM = make_flag("CMSG_SIGNER_CERT_ID_PARAM", 38) +CMSG_CMS_SIGNER_INFO_PARAM = make_flag("CMSG_CMS_SIGNER_INFO_PARAM", 39) +CERT_INFO_VERSION_FLAG = make_flag("CERT_INFO_VERSION_FLAG", 1) +CERT_INFO_SERIAL_NUMBER_FLAG = make_flag("CERT_INFO_SERIAL_NUMBER_FLAG", 2) +CERT_INFO_SIGNATURE_ALGORITHM_FLAG = make_flag("CERT_INFO_SIGNATURE_ALGORITHM_FLAG", 3) +CERT_INFO_ISSUER_FLAG = make_flag("CERT_INFO_ISSUER_FLAG", 4) +CERT_INFO_NOT_BEFORE_FLAG = make_flag("CERT_INFO_NOT_BEFORE_FLAG", 5) +CERT_INFO_NOT_AFTER_FLAG = make_flag("CERT_INFO_NOT_AFTER_FLAG", 6) +CERT_INFO_SUBJECT_FLAG = make_flag("CERT_INFO_SUBJECT_FLAG", 7) +CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG = make_flag("CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG", 8) +CERT_INFO_ISSUER_UNIQUE_ID_FLAG = make_flag("CERT_INFO_ISSUER_UNIQUE_ID_FLAG", 9) +CERT_INFO_SUBJECT_UNIQUE_ID_FLAG = make_flag("CERT_INFO_SUBJECT_UNIQUE_ID_FLAG", 10) +CERT_INFO_EXTENSION_FLAG = make_flag("CERT_INFO_EXTENSION_FLAG", 11) +CERT_FIND_ANY = make_flag("CERT_FIND_ANY", ( CERT_COMPARE_ANY << CERT_COMPARE_SHIFT )) +CERT_FIND_SHA1_HASH = make_flag("CERT_FIND_SHA1_HASH", ( CERT_COMPARE_SHA1_HASH << CERT_COMPARE_SHIFT )) +CERT_FIND_MD5_HASH = make_flag("CERT_FIND_MD5_HASH", ( CERT_COMPARE_MD5_HASH << CERT_COMPARE_SHIFT )) +CERT_FIND_SIGNATURE_HASH = make_flag("CERT_FIND_SIGNATURE_HASH", ( CERT_COMPARE_SIGNATURE_HASH << CERT_COMPARE_SHIFT )) +CERT_FIND_KEY_IDENTIFIER = make_flag("CERT_FIND_KEY_IDENTIFIER", ( CERT_COMPARE_KEY_IDENTIFIER << CERT_COMPARE_SHIFT )) +CERT_FIND_HASH = make_flag("CERT_FIND_HASH", CERT_FIND_SHA1_HASH) +CERT_FIND_PROPERTY = make_flag("CERT_FIND_PROPERTY", ( CERT_COMPARE_PROPERTY << CERT_COMPARE_SHIFT )) +CERT_FIND_PUBLIC_KEY = make_flag("CERT_FIND_PUBLIC_KEY", ( CERT_COMPARE_PUBLIC_KEY << CERT_COMPARE_SHIFT )) +CERT_FIND_SUBJECT_NAME = make_flag("CERT_FIND_SUBJECT_NAME", ( CERT_COMPARE_NAME << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG )) +CERT_FIND_SUBJECT_ATTR = make_flag("CERT_FIND_SUBJECT_ATTR", ( CERT_COMPARE_ATTR << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG )) +CERT_FIND_ISSUER_NAME = make_flag("CERT_FIND_ISSUER_NAME", ( CERT_COMPARE_NAME << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG )) +CERT_FIND_ISSUER_ATTR = make_flag("CERT_FIND_ISSUER_ATTR", ( CERT_COMPARE_ATTR << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG )) +CERT_FIND_SUBJECT_STR_A = make_flag("CERT_FIND_SUBJECT_STR_A", ( CERT_COMPARE_NAME_STR_A << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG )) +CERT_FIND_SUBJECT_STR_W = make_flag("CERT_FIND_SUBJECT_STR_W", ( CERT_COMPARE_NAME_STR_W << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG )) +CERT_FIND_SUBJECT_STR = make_flag("CERT_FIND_SUBJECT_STR", CERT_FIND_SUBJECT_STR_W) +CERT_FIND_ISSUER_STR_A = make_flag("CERT_FIND_ISSUER_STR_A", ( CERT_COMPARE_NAME_STR_A << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG )) +CERT_FIND_ISSUER_STR_W = make_flag("CERT_FIND_ISSUER_STR_W", ( CERT_COMPARE_NAME_STR_W << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG )) +CERT_FIND_ISSUER_STR = make_flag("CERT_FIND_ISSUER_STR", CERT_FIND_ISSUER_STR_W) +CERT_FIND_KEY_SPEC = make_flag("CERT_FIND_KEY_SPEC", ( CERT_COMPARE_KEY_SPEC << CERT_COMPARE_SHIFT )) +CERT_FIND_ENHKEY_USAGE = make_flag("CERT_FIND_ENHKEY_USAGE", ( CERT_COMPARE_ENHKEY_USAGE << CERT_COMPARE_SHIFT )) +CERT_FIND_CTL_USAGE = make_flag("CERT_FIND_CTL_USAGE", CERT_FIND_ENHKEY_USAGE) +CERT_FIND_SUBJECT_CERT = make_flag("CERT_FIND_SUBJECT_CERT", ( CERT_COMPARE_SUBJECT_CERT << CERT_COMPARE_SHIFT )) +CERT_FIND_ISSUER_OF = make_flag("CERT_FIND_ISSUER_OF", ( CERT_COMPARE_ISSUER_OF << CERT_COMPARE_SHIFT )) +CERT_FIND_EXISTING = make_flag("CERT_FIND_EXISTING", ( CERT_COMPARE_EXISTING << CERT_COMPARE_SHIFT )) +CERT_FIND_CERT_ID = make_flag("CERT_FIND_CERT_ID", ( CERT_COMPARE_CERT_ID << CERT_COMPARE_SHIFT )) +CERT_FIND_CROSS_CERT_DIST_POINTS = make_flag("CERT_FIND_CROSS_CERT_DIST_POINTS", ( CERT_COMPARE_CROSS_CERT_DIST_POINTS << CERT_COMPARE_SHIFT )) +CERT_FIND_PUBKEY_MD5_HASH = make_flag("CERT_FIND_PUBKEY_MD5_HASH", ( CERT_COMPARE_PUBKEY_MD5_HASH << CERT_COMPARE_SHIFT )) +CERT_FIND_SUBJECT_INFO_ACCESS = make_flag("CERT_FIND_SUBJECT_INFO_ACCESS", ( CERT_COMPARE_SUBJECT_INFO_ACCESS << CERT_COMPARE_SHIFT )) +CERT_NAME_EMAIL_TYPE = make_flag("CERT_NAME_EMAIL_TYPE", 1) +CERT_NAME_RDN_TYPE = make_flag("CERT_NAME_RDN_TYPE", 2) +CERT_NAME_ATTR_TYPE = make_flag("CERT_NAME_ATTR_TYPE", 3) +CERT_NAME_SIMPLE_DISPLAY_TYPE = make_flag("CERT_NAME_SIMPLE_DISPLAY_TYPE", 4) +CERT_NAME_FRIENDLY_DISPLAY_TYPE = make_flag("CERT_NAME_FRIENDLY_DISPLAY_TYPE", 5) +CERT_NAME_DNS_TYPE = make_flag("CERT_NAME_DNS_TYPE", 6) +CERT_NAME_URL_TYPE = make_flag("CERT_NAME_URL_TYPE", 7) +CERT_NAME_UPN_TYPE = make_flag("CERT_NAME_UPN_TYPE", 8) +CERT_KEY_PROV_HANDLE_PROP_ID = make_flag("CERT_KEY_PROV_HANDLE_PROP_ID", 1) +CERT_KEY_PROV_INFO_PROP_ID = make_flag("CERT_KEY_PROV_INFO_PROP_ID", 2) +CERT_SHA1_HASH_PROP_ID = make_flag("CERT_SHA1_HASH_PROP_ID", 3) +CERT_MD5_HASH_PROP_ID = make_flag("CERT_MD5_HASH_PROP_ID", 4) +CERT_HASH_PROP_ID = make_flag("CERT_HASH_PROP_ID", CERT_SHA1_HASH_PROP_ID) +CERT_KEY_CONTEXT_PROP_ID = make_flag("CERT_KEY_CONTEXT_PROP_ID", 5) +CERT_KEY_SPEC_PROP_ID = make_flag("CERT_KEY_SPEC_PROP_ID", 6) +CERT_IE30_RESERVED_PROP_ID = make_flag("CERT_IE30_RESERVED_PROP_ID", 7) +CERT_PUBKEY_HASH_RESERVED_PROP_ID = make_flag("CERT_PUBKEY_HASH_RESERVED_PROP_ID", 8) +CERT_ENHKEY_USAGE_PROP_ID = make_flag("CERT_ENHKEY_USAGE_PROP_ID", 9) +CERT_CTL_USAGE_PROP_ID = make_flag("CERT_CTL_USAGE_PROP_ID", CERT_ENHKEY_USAGE_PROP_ID) +CERT_NEXT_UPDATE_LOCATION_PROP_ID = make_flag("CERT_NEXT_UPDATE_LOCATION_PROP_ID", 10) +CERT_FRIENDLY_NAME_PROP_ID = make_flag("CERT_FRIENDLY_NAME_PROP_ID", 11) +CERT_PVK_FILE_PROP_ID = make_flag("CERT_PVK_FILE_PROP_ID", 12) +CERT_DESCRIPTION_PROP_ID = make_flag("CERT_DESCRIPTION_PROP_ID", 13) +CERT_ACCESS_STATE_PROP_ID = make_flag("CERT_ACCESS_STATE_PROP_ID", 14) +CERT_SIGNATURE_HASH_PROP_ID = make_flag("CERT_SIGNATURE_HASH_PROP_ID", 15) +CERT_SMART_CARD_DATA_PROP_ID = make_flag("CERT_SMART_CARD_DATA_PROP_ID", 16) +CERT_EFS_PROP_ID = make_flag("CERT_EFS_PROP_ID", 17) +CERT_FORTEZZA_DATA_PROP_ID = make_flag("CERT_FORTEZZA_DATA_PROP_ID", 18) +CERT_ARCHIVED_PROP_ID = make_flag("CERT_ARCHIVED_PROP_ID", 19) +CERT_KEY_IDENTIFIER_PROP_ID = make_flag("CERT_KEY_IDENTIFIER_PROP_ID", 20) +CERT_AUTO_ENROLL_PROP_ID = make_flag("CERT_AUTO_ENROLL_PROP_ID", 21) +CERT_PUBKEY_ALG_PARA_PROP_ID = make_flag("CERT_PUBKEY_ALG_PARA_PROP_ID", 22) +CERT_CROSS_CERT_DIST_POINTS_PROP_ID = make_flag("CERT_CROSS_CERT_DIST_POINTS_PROP_ID", 23) +CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID = make_flag("CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID", 24) +CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID = make_flag("CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID", 25) +CERT_ENROLLMENT_PROP_ID = make_flag("CERT_ENROLLMENT_PROP_ID", 26) +CERT_DATE_STAMP_PROP_ID = make_flag("CERT_DATE_STAMP_PROP_ID", 27) +CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID = make_flag("CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID", 28) +CERT_SUBJECT_NAME_MD5_HASH_PROP_ID = make_flag("CERT_SUBJECT_NAME_MD5_HASH_PROP_ID", 29) +CERT_EXTENDED_ERROR_INFO_PROP_ID = make_flag("CERT_EXTENDED_ERROR_INFO_PROP_ID", 30) +CERT_RENEWAL_PROP_ID = make_flag("CERT_RENEWAL_PROP_ID", 64) +CERT_ARCHIVED_KEY_HASH_PROP_ID = make_flag("CERT_ARCHIVED_KEY_HASH_PROP_ID", 65) +CERT_AUTO_ENROLL_RETRY_PROP_ID = make_flag("CERT_AUTO_ENROLL_RETRY_PROP_ID", 66) +CERT_AIA_URL_RETRIEVED_PROP_ID = make_flag("CERT_AIA_URL_RETRIEVED_PROP_ID", 67) +CERT_AUTHORITY_INFO_ACCESS_PROP_ID = make_flag("CERT_AUTHORITY_INFO_ACCESS_PROP_ID", 68) +CERT_BACKED_UP_PROP_ID = make_flag("CERT_BACKED_UP_PROP_ID", 69) +CERT_OCSP_RESPONSE_PROP_ID = make_flag("CERT_OCSP_RESPONSE_PROP_ID", 70) +CERT_REQUEST_ORIGINATOR_PROP_ID = make_flag("CERT_REQUEST_ORIGINATOR_PROP_ID", 71) +CERT_SOURCE_LOCATION_PROP_ID = make_flag("CERT_SOURCE_LOCATION_PROP_ID", 72) +CRYPT_ACQUIRE_CACHE_FLAG = make_flag("CRYPT_ACQUIRE_CACHE_FLAG", 0x00000001) +CRYPT_ACQUIRE_USE_PROV_INFO_FLAG = make_flag("CRYPT_ACQUIRE_USE_PROV_INFO_FLAG", 0x00000002) +CRYPT_ACQUIRE_COMPARE_KEY_FLAG = make_flag("CRYPT_ACQUIRE_COMPARE_KEY_FLAG", 0x00000004) +CRYPT_ACQUIRE_NO_HEALING = make_flag("CRYPT_ACQUIRE_NO_HEALING", 0x00000008) +CRYPT_ACQUIRE_SILENT_FLAG = make_flag("CRYPT_ACQUIRE_SILENT_FLAG", 0x00000040) +CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK = make_flag("CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK", 0x00070000) +CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG = make_flag("CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG", 0x00010000) +CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG = make_flag("CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG", 0x00020000) +CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG = make_flag("CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG", 0x00040000) +CERT_STORE_PROV_MSG = make_flag("CERT_STORE_PROV_MSG", ( 1 )) +CERT_STORE_PROV_MEMORY = make_flag("CERT_STORE_PROV_MEMORY", ( 2 )) +CERT_STORE_PROV_FILE = make_flag("CERT_STORE_PROV_FILE", ( 3 )) +CERT_STORE_PROV_REG = make_flag("CERT_STORE_PROV_REG", ( 4 )) +CERT_STORE_PROV_PKCS7 = make_flag("CERT_STORE_PROV_PKCS7", ( 5 )) +CERT_STORE_PROV_SERIALIZED = make_flag("CERT_STORE_PROV_SERIALIZED", ( 6 )) +CERT_STORE_PROV_FILENAME_A = make_flag("CERT_STORE_PROV_FILENAME_A", ( 7 )) +CERT_STORE_PROV_FILENAME_W = make_flag("CERT_STORE_PROV_FILENAME_W", ( 8 )) +CERT_STORE_PROV_FILENAME = make_flag("CERT_STORE_PROV_FILENAME", CERT_STORE_PROV_FILENAME_W) +CERT_STORE_PROV_SYSTEM_A = make_flag("CERT_STORE_PROV_SYSTEM_A", ( 9 )) +CERT_STORE_PROV_SYSTEM_W = make_flag("CERT_STORE_PROV_SYSTEM_W", ( 10 )) +CERT_STORE_PROV_SYSTEM = make_flag("CERT_STORE_PROV_SYSTEM", CERT_STORE_PROV_SYSTEM_W) +CERT_STORE_PROV_COLLECTION = make_flag("CERT_STORE_PROV_COLLECTION", ( 11 )) +CERT_STORE_PROV_SYSTEM_REGISTRY_A = make_flag("CERT_STORE_PROV_SYSTEM_REGISTRY_A", ( 12 )) +CERT_STORE_PROV_SYSTEM_REGISTRY_W = make_flag("CERT_STORE_PROV_SYSTEM_REGISTRY_W", ( 13 )) +CERT_STORE_PROV_SYSTEM_REGISTRY = make_flag("CERT_STORE_PROV_SYSTEM_REGISTRY", CERT_STORE_PROV_SYSTEM_REGISTRY_W) +CERT_STORE_PROV_PHYSICAL_W = make_flag("CERT_STORE_PROV_PHYSICAL_W", ( 14 )) +CERT_STORE_PROV_PHYSICAL = make_flag("CERT_STORE_PROV_PHYSICAL", CERT_STORE_PROV_PHYSICAL_W) +CERT_STORE_PROV_SMART_CARD_W = make_flag("CERT_STORE_PROV_SMART_CARD_W", ( 15 )) +CERT_STORE_PROV_SMART_CARD = make_flag("CERT_STORE_PROV_SMART_CARD", CERT_STORE_PROV_SMART_CARD_W) +CERT_STORE_PROV_LDAP_W = make_flag("CERT_STORE_PROV_LDAP_W", ( 16 )) +CERT_STORE_PROV_LDAP = make_flag("CERT_STORE_PROV_LDAP", CERT_STORE_PROV_LDAP_W) +CERT_STORE_PROV_PKCS12 = make_flag("CERT_STORE_PROV_PKCS12", ( 17 )) +CRYPT_E_NOT_FOUND = make_flag("CRYPT_E_NOT_FOUND", ( 0x80092004 )) +CERT_STORE_NO_CRYPT_RELEASE_FLAG = make_flag("CERT_STORE_NO_CRYPT_RELEASE_FLAG", 0x00000001) +CERT_STORE_SET_LOCALIZED_NAME_FLAG = make_flag("CERT_STORE_SET_LOCALIZED_NAME_FLAG", 0x00000002) +CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG = make_flag("CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG", 0x00000004) +CERT_STORE_DELETE_FLAG = make_flag("CERT_STORE_DELETE_FLAG", 0x00000010) +CERT_STORE_UNSAFE_PHYSICAL_FLAG = make_flag("CERT_STORE_UNSAFE_PHYSICAL_FLAG", 0x00000020) +CERT_STORE_SHARE_STORE_FLAG = make_flag("CERT_STORE_SHARE_STORE_FLAG", 0x00000040) +CERT_STORE_SHARE_CONTEXT_FLAG = make_flag("CERT_STORE_SHARE_CONTEXT_FLAG", 0x00000080) +CERT_STORE_MANIFOLD_FLAG = make_flag("CERT_STORE_MANIFOLD_FLAG", 0x00000100) +CERT_STORE_ENUM_ARCHIVED_FLAG = make_flag("CERT_STORE_ENUM_ARCHIVED_FLAG", 0x00000200) +CERT_STORE_UPDATE_KEYID_FLAG = make_flag("CERT_STORE_UPDATE_KEYID_FLAG", 0x00000400) +CERT_STORE_BACKUP_RESTORE_FLAG = make_flag("CERT_STORE_BACKUP_RESTORE_FLAG", 0x00000800) +CERT_STORE_READONLY_FLAG = make_flag("CERT_STORE_READONLY_FLAG", 0x00008000) +CERT_STORE_OPEN_EXISTING_FLAG = make_flag("CERT_STORE_OPEN_EXISTING_FLAG", 0x00004000) +CERT_STORE_CREATE_NEW_FLAG = make_flag("CERT_STORE_CREATE_NEW_FLAG", 0x00002000) +CERT_STORE_MAXIMUM_ALLOWED_FLAG = make_flag("CERT_STORE_MAXIMUM_ALLOWED_FLAG", 0x00001000) +CRYPT_USER_KEYSET = make_flag("CRYPT_USER_KEYSET", 0x00001000) +PKCS12_PREFER_CNG_KSP = make_flag("PKCS12_PREFER_CNG_KSP", 0x00000100) +PKCS12_ALWAYS_CNG_KSP = make_flag("PKCS12_ALWAYS_CNG_KSP", 0x00000200) +PKCS12_ALLOW_OVERWRITE_KEY = make_flag("PKCS12_ALLOW_OVERWRITE_KEY", 0x00004000) +PKCS12_NO_PERSIST_KEY = make_flag("PKCS12_NO_PERSIST_KEY", 0x00008000) +CRYPT_VERIFYCONTEXT = make_flag("CRYPT_VERIFYCONTEXT", 0xF0000000) +CRYPT_NEWKEYSET = make_flag("CRYPT_NEWKEYSET", 0x00000008) +CRYPT_DELETEKEYSET = make_flag("CRYPT_DELETEKEYSET", 0x00000010) +CRYPT_MACHINE_KEYSET = make_flag("CRYPT_MACHINE_KEYSET", 0x00000020) +CRYPT_SILENT = make_flag("CRYPT_SILENT", 0x00000040) +CRYPT_DEFAULT_CONTAINER_OPTIONAL = make_flag("CRYPT_DEFAULT_CONTAINER_OPTIONAL", 0x00000080) +CRYPT_EXPORTABLE = make_flag("CRYPT_EXPORTABLE", 0x00000001) +CRYPT_USER_PROTECTED = make_flag("CRYPT_USER_PROTECTED", 0x00000002) +CRYPT_CREATE_SALT = make_flag("CRYPT_CREATE_SALT", 0x00000004) +CRYPT_UPDATE_KEY = make_flag("CRYPT_UPDATE_KEY", 0x00000008) +CRYPT_NO_SALT = make_flag("CRYPT_NO_SALT", 0x00000010) +CRYPT_PREGEN = make_flag("CRYPT_PREGEN", 0x00000040) +CRYPT_RECIPIENT = make_flag("CRYPT_RECIPIENT", 0x00000010) +CRYPT_INITIATOR = make_flag("CRYPT_INITIATOR", 0x00000040) +CRYPT_ONLINE = make_flag("CRYPT_ONLINE", 0x00000080) +CRYPT_SF = make_flag("CRYPT_SF", 0x00000100) +CRYPT_CREATE_IV = make_flag("CRYPT_CREATE_IV", 0x00000200) +CRYPT_KEK = make_flag("CRYPT_KEK", 0x00000400) +CRYPT_DATA_KEY = make_flag("CRYPT_DATA_KEY", 0x00000800) +CRYPT_VOLATILE = make_flag("CRYPT_VOLATILE", 0x00001000) +CRYPT_SGCKEY = make_flag("CRYPT_SGCKEY", 0x00002000) +CRYPT_ARCHIVABLE = make_flag("CRYPT_ARCHIVABLE", 0x00004000) +CRYPT_FORCE_KEY_PROTECTION_HIGH = make_flag("CRYPT_FORCE_KEY_PROTECTION_HIGH", 0x00008000) +CRYPT_ENCODE_DECODE_NONE = make_flag("CRYPT_ENCODE_DECODE_NONE", 0) +X509_CERT = make_flag("X509_CERT", ( 1 )) +X509_CERT_TO_BE_SIGNED = make_flag("X509_CERT_TO_BE_SIGNED", ( 2 )) +X509_CERT_CRL_TO_BE_SIGNED = make_flag("X509_CERT_CRL_TO_BE_SIGNED", ( 3 )) +X509_CERT_REQUEST_TO_BE_SIGNED = make_flag("X509_CERT_REQUEST_TO_BE_SIGNED", ( 4 )) +X509_EXTENSIONS = make_flag("X509_EXTENSIONS", ( 5 )) +X509_NAME_VALUE = make_flag("X509_NAME_VALUE", ( 6 )) +X509_NAME = make_flag("X509_NAME", ( 7 )) +X509_PUBLIC_KEY_INFO = make_flag("X509_PUBLIC_KEY_INFO", ( 8 )) +X509_AUTHORITY_KEY_ID = make_flag("X509_AUTHORITY_KEY_ID", ( 9 )) +X509_KEY_ATTRIBUTES = make_flag("X509_KEY_ATTRIBUTES", ( 10 )) +X509_KEY_USAGE_RESTRICTION = make_flag("X509_KEY_USAGE_RESTRICTION", ( 11 )) +X509_ALTERNATE_NAME = make_flag("X509_ALTERNATE_NAME", ( 12 )) +X509_BASIC_CONSTRAINTS = make_flag("X509_BASIC_CONSTRAINTS", ( 13 )) +X509_KEY_USAGE = make_flag("X509_KEY_USAGE", ( 14 )) +X509_BASIC_CONSTRAINTS2 = make_flag("X509_BASIC_CONSTRAINTS2", ( 15 )) +X509_CERT_POLICIES = make_flag("X509_CERT_POLICIES", ( 16 )) +PKCS_UTC_TIME = make_flag("PKCS_UTC_TIME", ( 17 )) +PKCS_TIME_REQUEST = make_flag("PKCS_TIME_REQUEST", ( 18 )) +RSA_CSP_PUBLICKEYBLOB = make_flag("RSA_CSP_PUBLICKEYBLOB", ( 19 )) +X509_UNICODE_NAME = make_flag("X509_UNICODE_NAME", ( 20 )) +X509_KEYGEN_REQUEST_TO_BE_SIGNED = make_flag("X509_KEYGEN_REQUEST_TO_BE_SIGNED", ( 21 )) +PKCS_ATTRIBUTE = make_flag("PKCS_ATTRIBUTE", ( 22 )) +PKCS_CONTENT_INFO_SEQUENCE_OF_ANY = make_flag("PKCS_CONTENT_INFO_SEQUENCE_OF_ANY", ( 23 )) +X509_UNICODE_NAME_VALUE = make_flag("X509_UNICODE_NAME_VALUE", ( 24 )) +X509_ANY_STRING = make_flag("X509_ANY_STRING", X509_NAME_VALUE) +X509_UNICODE_ANY_STRING = make_flag("X509_UNICODE_ANY_STRING", X509_UNICODE_NAME_VALUE) +X509_OCTET_STRING = make_flag("X509_OCTET_STRING", ( 25 )) +X509_BITS = make_flag("X509_BITS", ( 26 )) +X509_INTEGER = make_flag("X509_INTEGER", ( 27 )) +X509_MULTI_BYTE_INTEGER = make_flag("X509_MULTI_BYTE_INTEGER", ( 28 )) +X509_ENUMERATED = make_flag("X509_ENUMERATED", ( 29 )) +X509_CHOICE_OF_TIME = make_flag("X509_CHOICE_OF_TIME", ( 30 )) +CERT_SIMPLE_NAME_STR = make_flag("CERT_SIMPLE_NAME_STR", 1) +CERT_OID_NAME_STR = make_flag("CERT_OID_NAME_STR", 2) +CERT_X500_NAME_STR = make_flag("CERT_X500_NAME_STR", 3) +CERT_XML_NAME_STR = make_flag("CERT_XML_NAME_STR", 4) +AT_KEYEXCHANGE = make_flag("AT_KEYEXCHANGE", 1) +AT_SIGNATURE = make_flag("AT_SIGNATURE", 2) +MS_DEF_PROV_A = make_flag("MS_DEF_PROV_A", "Microsoft Base Cryptographic Provider v1.0") +MS_DEF_PROV_W = make_flag("MS_DEF_PROV_W", u"Microsoft Base Cryptographic Provider v1.0") +MS_DEF_PROV = make_flag("MS_DEF_PROV", MS_DEF_PROV_A) +MS_ENHANCED_PROV_A = make_flag("MS_ENHANCED_PROV_A", "Microsoft Enhanced Cryptographic Provider v1.0") +MS_ENHANCED_PROV_W = make_flag("MS_ENHANCED_PROV_W", u"Microsoft Enhanced Cryptographic Provider v1.0") +MS_ENHANCED_PROV = make_flag("MS_ENHANCED_PROV", MS_ENHANCED_PROV_A) +MS_STRONG_PROV_A = make_flag("MS_STRONG_PROV_A", "Microsoft Strong Cryptographic Provider") +MS_STRONG_PROV_W = make_flag("MS_STRONG_PROV_W", u"Microsoft Strong Cryptographic Provider") +MS_STRONG_PROV = make_flag("MS_STRONG_PROV", MS_STRONG_PROV_A) +MS_DEF_RSA_SIG_PROV_A = make_flag("MS_DEF_RSA_SIG_PROV_A", "Microsoft RSA Signature Cryptographic Provider") +MS_DEF_RSA_SIG_PROV_W = make_flag("MS_DEF_RSA_SIG_PROV_W", u"Microsoft RSA Signature Cryptographic Provider") +MS_DEF_RSA_SIG_PROV = make_flag("MS_DEF_RSA_SIG_PROV", MS_DEF_RSA_SIG_PROV_A) +MS_ENH_RSA_AES_PROV_A = make_flag("MS_ENH_RSA_AES_PROV_A", "Microsoft Enhanced RSA and AES Cryptographic Provider") +MS_ENH_RSA_AES_PROV_W = make_flag("MS_ENH_RSA_AES_PROV_W", u"Microsoft Enhanced RSA and AES Cryptographic Provider") +MS_ENH_RSA_AES_PROV_XP_A = make_flag("MS_ENH_RSA_AES_PROV_XP_A", "Microsoft Enhanced RSA and AES Cryptographic Provider ( Prototype ) ") +MS_ENH_RSA_AES_PROV_XP_W = make_flag("MS_ENH_RSA_AES_PROV_XP_W", u"Microsoft Enhanced RSA and AES Cryptographic Provider ( Prototype ) ") +CERT_STORE_ADD_NEW = make_flag("CERT_STORE_ADD_NEW", 1) +CERT_STORE_ADD_USE_EXISTING = make_flag("CERT_STORE_ADD_USE_EXISTING", 2) +CERT_STORE_ADD_REPLACE_EXISTING = make_flag("CERT_STORE_ADD_REPLACE_EXISTING", 3) +CERT_STORE_ADD_ALWAYS = make_flag("CERT_STORE_ADD_ALWAYS", 4) +CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES = make_flag("CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES", 5) +CERT_STORE_ADD_NEWER = make_flag("CERT_STORE_ADD_NEWER", 6) +CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES = make_flag("CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES", 7) +PROV_RSA_FULL = make_flag("PROV_RSA_FULL", 1) +PROV_RSA_SIG = make_flag("PROV_RSA_SIG", 2) +PROV_DSS = make_flag("PROV_DSS", 3) +PROV_FORTEZZA = make_flag("PROV_FORTEZZA", 4) +PROV_MS_EXCHANGE = make_flag("PROV_MS_EXCHANGE", 5) +PROV_SSL = make_flag("PROV_SSL", 6) +PROV_RSA_SCHANNEL = make_flag("PROV_RSA_SCHANNEL", 12) +PROV_DSS_DH = make_flag("PROV_DSS_DH", 13) +PROV_EC_ECDSA_SIG = make_flag("PROV_EC_ECDSA_SIG", 14) +PROV_EC_ECNRA_SIG = make_flag("PROV_EC_ECNRA_SIG", 15) +PROV_EC_ECDSA_FULL = make_flag("PROV_EC_ECDSA_FULL", 16) +PROV_EC_ECNRA_FULL = make_flag("PROV_EC_ECNRA_FULL", 17) +PROV_DH_SCHANNEL = make_flag("PROV_DH_SCHANNEL", 18) +PROV_SPYRUS_LYNKS = make_flag("PROV_SPYRUS_LYNKS", 20) +PROV_RNG = make_flag("PROV_RNG", 21) +PROV_INTEL_SEC = make_flag("PROV_INTEL_SEC", 22) +PROV_REPLACE_OWF = make_flag("PROV_REPLACE_OWF", 23) +PROV_RSA_AES = make_flag("PROV_RSA_AES", 24) +REPORT_NO_PRIVATE_KEY = make_flag("REPORT_NO_PRIVATE_KEY", 0x0001) +REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY = make_flag("REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY", 0x0002) +EXPORT_PRIVATE_KEYS = make_flag("EXPORT_PRIVATE_KEYS", 0x0004) +PKCS12_INCLUDE_EXTENDED_PROPERTIES = make_flag("PKCS12_INCLUDE_EXTENDED_PROPERTIES", 0x0010) +PKCS12_EXPORT_RESERVED_MASK = make_flag("PKCS12_EXPORT_RESERVED_MASK", 0xffff0000) +CERT_SYSTEM_STORE_UNPROTECTED_FLAG = make_flag("CERT_SYSTEM_STORE_UNPROTECTED_FLAG", 0x40000000) +CERT_SYSTEM_STORE_LOCATION_MASK = make_flag("CERT_SYSTEM_STORE_LOCATION_MASK", 0x00FF0000) +CERT_SYSTEM_STORE_LOCATION_SHIFT = make_flag("CERT_SYSTEM_STORE_LOCATION_SHIFT", 16) +CERT_SYSTEM_STORE_CURRENT_USER_ID = make_flag("CERT_SYSTEM_STORE_CURRENT_USER_ID", 1) +CERT_SYSTEM_STORE_LOCAL_MACHINE_ID = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE_ID", 2) +CERT_SYSTEM_STORE_CURRENT_SERVICE_ID = make_flag("CERT_SYSTEM_STORE_CURRENT_SERVICE_ID", 4) +CERT_SYSTEM_STORE_SERVICES_ID = make_flag("CERT_SYSTEM_STORE_SERVICES_ID", 5) +CERT_SYSTEM_STORE_USERS_ID = make_flag("CERT_SYSTEM_STORE_USERS_ID", 6) +CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID = make_flag("CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID", 7) +CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID", 8) +CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID", 9) +CERT_SYSTEM_STORE_CURRENT_USER = make_flag("CERT_SYSTEM_STORE_CURRENT_USER", ( CERT_SYSTEM_STORE_CURRENT_USER_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) +CERT_SYSTEM_STORE_LOCAL_MACHINE = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE", ( CERT_SYSTEM_STORE_LOCAL_MACHINE_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) +CERT_SYSTEM_STORE_CURRENT_SERVICE = make_flag("CERT_SYSTEM_STORE_CURRENT_SERVICE", ( CERT_SYSTEM_STORE_CURRENT_SERVICE_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) +CERT_SYSTEM_STORE_SERVICES = make_flag("CERT_SYSTEM_STORE_SERVICES", ( CERT_SYSTEM_STORE_SERVICES_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) +CERT_SYSTEM_STORE_USERS = make_flag("CERT_SYSTEM_STORE_USERS", ( CERT_SYSTEM_STORE_USERS_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) +CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY = make_flag("CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY", ( CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) +CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY", ( CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) +CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE", ( CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) +CMSG_DATA = make_flag("CMSG_DATA", 1) +CMSG_SIGNED = make_flag("CMSG_SIGNED", 2) +CMSG_ENVELOPED = make_flag("CMSG_ENVELOPED", 3) +CMSG_SIGNED_AND_ENVELOPED = make_flag("CMSG_SIGNED_AND_ENVELOPED", 4) +CMSG_HASHED = make_flag("CMSG_HASHED", 5) +CMSG_ENCRYPTED = make_flag("CMSG_ENCRYPTED", 6) +CMSG_BARE_CONTENT_FLAG = make_flag("CMSG_BARE_CONTENT_FLAG", 0x00000001) +CMSG_LENGTH_ONLY_FLAG = make_flag("CMSG_LENGTH_ONLY_FLAG", 0x00000002) +CMSG_DETACHED_FLAG = make_flag("CMSG_DETACHED_FLAG", 0x00000004) +CMSG_AUTHENTICATED_ATTRIBUTES_FLAG = make_flag("CMSG_AUTHENTICATED_ATTRIBUTES_FLAG", 0x00000008) +CMSG_CONTENTS_OCTETS_FLAG = make_flag("CMSG_CONTENTS_OCTETS_FLAG", 0x00000010) +CMSG_MAX_LENGTH_FLAG = make_flag("CMSG_MAX_LENGTH_FLAG", 0x00000020) +CMSG_CMS_ENCAPSULATED_CONTENT_FLAG = make_flag("CMSG_CMS_ENCAPSULATED_CONTENT_FLAG", 0x00000040) +CMSG_CRYPT_RELEASE_CONTEXT_FLAG = make_flag("CMSG_CRYPT_RELEASE_CONTEXT_FLAG", 0x00008000) +CMSG_INDEFINITE_LENGTH = make_flag("CMSG_INDEFINITE_LENGTH", ( 0xFFFFFFFF )) +CMSG_CTRL_VERIFY_SIGNATURE = make_flag("CMSG_CTRL_VERIFY_SIGNATURE", 1) +CMSG_CTRL_DECRYPT = make_flag("CMSG_CTRL_DECRYPT", 2) +CMSG_CTRL_VERIFY_HASH = make_flag("CMSG_CTRL_VERIFY_HASH", 5) +CMSG_CTRL_ADD_SIGNER = make_flag("CMSG_CTRL_ADD_SIGNER", 6) +CMSG_CTRL_DEL_SIGNER = make_flag("CMSG_CTRL_DEL_SIGNER", 7) +CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR = make_flag("CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR", 8) +CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR = make_flag("CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR", 9) +CMSG_CTRL_ADD_CERT = make_flag("CMSG_CTRL_ADD_CERT", 10) +CMSG_CTRL_DEL_CERT = make_flag("CMSG_CTRL_DEL_CERT", 11) +CMSG_CTRL_ADD_CRL = make_flag("CMSG_CTRL_ADD_CRL", 12) +CMSG_CTRL_DEL_CRL = make_flag("CMSG_CTRL_DEL_CRL", 13) +CMSG_CTRL_ADD_ATTR_CERT = make_flag("CMSG_CTRL_ADD_ATTR_CERT", 14) +CMSG_CTRL_DEL_ATTR_CERT = make_flag("CMSG_CTRL_DEL_ATTR_CERT", 15) +CMSG_CTRL_KEY_TRANS_DECRYPT = make_flag("CMSG_CTRL_KEY_TRANS_DECRYPT", 16) +CMSG_CTRL_KEY_AGREE_DECRYPT = make_flag("CMSG_CTRL_KEY_AGREE_DECRYPT", 17) +CMSG_CTRL_MAIL_LIST_DECRYPT = make_flag("CMSG_CTRL_MAIL_LIST_DECRYPT", 18) +CMSG_CTRL_VERIFY_SIGNATURE_EX = make_flag("CMSG_CTRL_VERIFY_SIGNATURE_EX", 19) +CMSG_CTRL_ADD_CMS_SIGNER_INFO = make_flag("CMSG_CTRL_ADD_CMS_SIGNER_INFO", 20) +CMSG_CTRL_ENABLE_STRONG_SIGNATURE = make_flag("CMSG_CTRL_ENABLE_STRONG_SIGNATURE", 21) +EVENTLOG_SUCCESS = make_flag("EVENTLOG_SUCCESS", 0x0000) +EVENTLOG_ERROR_TYPE = make_flag("EVENTLOG_ERROR_TYPE", 0x0001) +EVENTLOG_WARNING_TYPE = make_flag("EVENTLOG_WARNING_TYPE", 0x0002) +EVENTLOG_INFORMATION_TYPE = make_flag("EVENTLOG_INFORMATION_TYPE", 0x0004) +EVENTLOG_AUDIT_SUCCESS = make_flag("EVENTLOG_AUDIT_SUCCESS", 0x0008) +EVENTLOG_AUDIT_FAILURE = make_flag("EVENTLOG_AUDIT_FAILURE", 0x0010) +EVENTLOG_SEQUENTIAL_READ = make_flag("EVENTLOG_SEQUENTIAL_READ", 0x0001) +EVENTLOG_SEEK_READ = make_flag("EVENTLOG_SEEK_READ", 0x0002) +EVENTLOG_FORWARDS_READ = make_flag("EVENTLOG_FORWARDS_READ", 0x0004) +EVENTLOG_BACKWARDS_READ = make_flag("EVENTLOG_BACKWARDS_READ", 0x0008) +EVT_VARIANT_TYPE_MASK = make_flag("EVT_VARIANT_TYPE_MASK", 0x7f) +EVT_VARIANT_TYPE_ARRAY = make_flag("EVT_VARIANT_TYPE_ARRAY", 128) +ERROR_EVT_INVALID_CHANNEL_PATH = make_flag("ERROR_EVT_INVALID_CHANNEL_PATH", 15000L) +ERROR_EVT_INVALID_QUERY = make_flag("ERROR_EVT_INVALID_QUERY", 15001L) +ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND = make_flag("ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND", 15002L) +ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND = make_flag("ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND", 15003L) +ERROR_EVT_INVALID_PUBLISHER_NAME = make_flag("ERROR_EVT_INVALID_PUBLISHER_NAME", 15004L) +ERROR_EVT_INVALID_EVENT_DATA = make_flag("ERROR_EVT_INVALID_EVENT_DATA", 15005L) +ERROR_EVT_CHANNEL_NOT_FOUND = make_flag("ERROR_EVT_CHANNEL_NOT_FOUND", 15007L) +ERROR_EVT_MALFORMED_XML_TEXT = make_flag("ERROR_EVT_MALFORMED_XML_TEXT", 15008L) +ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL = make_flag("ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL", 15009L) +ERROR_EVT_CONFIGURATION_ERROR = make_flag("ERROR_EVT_CONFIGURATION_ERROR", 15010L) +ERROR_EVT_QUERY_RESULT_STALE = make_flag("ERROR_EVT_QUERY_RESULT_STALE", 15011L) +ERROR_EVT_QUERY_RESULT_INVALID_POSITION = make_flag("ERROR_EVT_QUERY_RESULT_INVALID_POSITION", 15012L) +ERROR_EVT_NON_VALIDATING_MSXML = make_flag("ERROR_EVT_NON_VALIDATING_MSXML", 15013L) +ERROR_EVT_FILTER_ALREADYSCOPED = make_flag("ERROR_EVT_FILTER_ALREADYSCOPED", 15014L) +ERROR_EVT_FILTER_NOTELTSET = make_flag("ERROR_EVT_FILTER_NOTELTSET", 15015L) +ERROR_EVT_FILTER_INVARG = make_flag("ERROR_EVT_FILTER_INVARG", 15016L) +ERROR_EVT_FILTER_INVTEST = make_flag("ERROR_EVT_FILTER_INVTEST", 15017L) +ERROR_EVT_FILTER_INVTYPE = make_flag("ERROR_EVT_FILTER_INVTYPE", 15018L) +ERROR_EVT_FILTER_PARSEERR = make_flag("ERROR_EVT_FILTER_PARSEERR", 15019L) +ERROR_EVT_FILTER_UNSUPPORTEDOP = make_flag("ERROR_EVT_FILTER_UNSUPPORTEDOP", 15020L) +ERROR_EVT_FILTER_UNEXPECTEDTOKEN = make_flag("ERROR_EVT_FILTER_UNEXPECTEDTOKEN", 15021L) +ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL = make_flag("ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL", 15022L) +ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE = make_flag("ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE", 15023L) +ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE = make_flag("ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE", 15024L) +ERROR_EVT_CHANNEL_CANNOT_ACTIVATE = make_flag("ERROR_EVT_CHANNEL_CANNOT_ACTIVATE", 15025L) +ERROR_EVT_FILTER_TOO_COMPLEX = make_flag("ERROR_EVT_FILTER_TOO_COMPLEX", 15026L) +ERROR_EVT_MESSAGE_NOT_FOUND = make_flag("ERROR_EVT_MESSAGE_NOT_FOUND", 15027L) +ERROR_EVT_MESSAGE_ID_NOT_FOUND = make_flag("ERROR_EVT_MESSAGE_ID_NOT_FOUND", 15028L) +ERROR_EVT_UNRESOLVED_VALUE_INSERT = make_flag("ERROR_EVT_UNRESOLVED_VALUE_INSERT", 15029L) +ERROR_EVT_UNRESOLVED_PARAMETER_INSERT = make_flag("ERROR_EVT_UNRESOLVED_PARAMETER_INSERT", 15030L) +ERROR_EVT_MAX_INSERTS_REACHED = make_flag("ERROR_EVT_MAX_INSERTS_REACHED", 15031L) +ERROR_EVT_EVENT_DEFINITION_NOT_FOUND = make_flag("ERROR_EVT_EVENT_DEFINITION_NOT_FOUND", 15032L) +ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND = make_flag("ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND", 15033L) +ERROR_EVT_VERSION_TOO_OLD = make_flag("ERROR_EVT_VERSION_TOO_OLD", 15034L) +ERROR_EVT_VERSION_TOO_NEW = make_flag("ERROR_EVT_VERSION_TOO_NEW", 15035L) +ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY = make_flag("ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY", 15036L) +ERROR_EVT_PUBLISHER_DISABLED = make_flag("ERROR_EVT_PUBLISHER_DISABLED", 15037L) +ERROR_EVT_FILTER_OUT_OF_RANGE = make_flag("ERROR_EVT_FILTER_OUT_OF_RANGE", 15038L) ERROR_SUCCESS = make_flag("ERROR_SUCCESS", 0) ERROR_INVALID_FUNCTION = make_flag("ERROR_INVALID_FUNCTION", 1) ERROR_FILE_NOT_FOUND = make_flag("ERROR_FILE_NOT_FOUND", 2) @@ -688,6 +1926,25 @@ RPC_S_UNKNOWN_IF = make_flag("RPC_S_UNKNOWN_IF", 1717) RPC_S_PROTOCOL_ERROR = make_flag("RPC_S_PROTOCOL_ERROR", 1728) RPC_S_UNSUPPORTED_TRANS_SYN = make_flag("RPC_S_UNSUPPORTED_TRANS_SYN", 1730) RPC_S_PROCNUM_OUT_OF_RANGE = make_flag("RPC_S_PROCNUM_OUT_OF_RANGE", 1745) +ERROR_RESOURCE_DATA_NOT_FOUND = make_flag("ERROR_RESOURCE_DATA_NOT_FOUND", 1812L) +ERROR_RESOURCE_TYPE_NOT_FOUND = make_flag("ERROR_RESOURCE_TYPE_NOT_FOUND", 1813L) +ERROR_RESOURCE_NAME_NOT_FOUND = make_flag("ERROR_RESOURCE_NAME_NOT_FOUND", 1814L) +ERROR_RESOURCE_LANG_NOT_FOUND = make_flag("ERROR_RESOURCE_LANG_NOT_FOUND", 1815L) +ERROR_WMI_GUID_NOT_FOUND = make_flag("ERROR_WMI_GUID_NOT_FOUND", 4200L) +ERROR_WMI_INSTANCE_NOT_FOUND = make_flag("ERROR_WMI_INSTANCE_NOT_FOUND", 4201L) +ERROR_WMI_ITEMID_NOT_FOUND = make_flag("ERROR_WMI_ITEMID_NOT_FOUND", 4202L) +ERROR_WMI_TRY_AGAIN = make_flag("ERROR_WMI_TRY_AGAIN", 4203L) +ERROR_WMI_DP_NOT_FOUND = make_flag("ERROR_WMI_DP_NOT_FOUND", 4204L) +ERROR_WMI_UNRESOLVED_INSTANCE_REF = make_flag("ERROR_WMI_UNRESOLVED_INSTANCE_REF", 4205L) +ERROR_WMI_ALREADY_ENABLED = make_flag("ERROR_WMI_ALREADY_ENABLED", 4206L) +ERROR_WMI_GUID_DISCONNECTED = make_flag("ERROR_WMI_GUID_DISCONNECTED", 4207L) +ERROR_WMI_SERVER_UNAVAILABLE = make_flag("ERROR_WMI_SERVER_UNAVAILABLE", 4208L) +ERROR_WMI_DP_FAILED = make_flag("ERROR_WMI_DP_FAILED", 4209L) +ERROR_WMI_INVALID_MOF = make_flag("ERROR_WMI_INVALID_MOF", 4210L) +ERROR_WMI_INVALID_REGINFO = make_flag("ERROR_WMI_INVALID_REGINFO", 4211L) +ERROR_WMI_ALREADY_DISABLED = make_flag("ERROR_WMI_ALREADY_DISABLED", 4212L) +ERROR_WMI_READ_ONLY = make_flag("ERROR_WMI_READ_ONLY", 4213L) +ERROR_WMI_SET_FAILURE = make_flag("ERROR_WMI_SET_FAILURE", 4214L) ERROR_INVALID_TRANSACTION = make_flag("ERROR_INVALID_TRANSACTION", 6700) ERROR_TRANSACTION_NOT_ACTIVE = make_flag("ERROR_TRANSACTION_NOT_ACTIVE", 6701) ERROR_TRANSACTION_REQUEST_NOT_VALID = make_flag("ERROR_TRANSACTION_REQUEST_NOT_VALID", 6702) @@ -741,6 +1998,9 @@ NTE_DECRYPTION_FAILURE = make_flag("NTE_DECRYPTION_FAILURE", ( 0x8009002C )) NTE_INTERNAL_ERROR = make_flag("NTE_INTERNAL_ERROR", ( 0x8009002D )) NTE_UI_REQUIRED = make_flag("NTE_UI_REQUIRED", ( 0x8009002E )) NTE_HMAC_NOT_SUPPORTED = make_flag("NTE_HMAC_NOT_SUPPORTED", ( 0x8009002F )) +E_UNEXPECTED = make_flag("E_UNEXPECTED", ( 0x8000FFFF )) +RPC_E_INVALID_OBJREF = make_flag("RPC_E_INVALID_OBJREF", 0x8001011D) +RPC_E_ACCESS_DENIED = make_flag("RPC_E_ACCESS_DENIED", 0x8001011B) PIPE_ACCESS_INBOUND = make_flag("PIPE_ACCESS_INBOUND", 0x00000001) PIPE_ACCESS_OUTBOUND = make_flag("PIPE_ACCESS_OUTBOUND", 0x00000002) PIPE_ACCESS_DUPLEX = make_flag("PIPE_ACCESS_DUPLEX", 0x00000003) @@ -758,6 +2018,367 @@ PIPE_UNLIMITED_INSTANCES = make_flag("PIPE_UNLIMITED_INSTANCES", 255) NMPWAIT_WAIT_FOREVER = make_flag("NMPWAIT_WAIT_FOREVER", 0xffffffff) NMPWAIT_NOWAIT = make_flag("NMPWAIT_NOWAIT", 0x00000001) NMPWAIT_USE_DEFAULT_WAIT = make_flag("NMPWAIT_USE_DEFAULT_WAIT", 0x00000000) +ACCESS_SYSTEM_SECURITY = make_flag("ACCESS_SYSTEM_SECURITY", ( 0x01000000 )) +MAXIMUM_ALLOWED = make_flag("MAXIMUM_ALLOWED", ( 0x02000000 )) +FILE_READ_DATA = make_flag("FILE_READ_DATA", ( 0x0001 )) +FILE_LIST_DIRECTORY = make_flag("FILE_LIST_DIRECTORY", ( 0x0001 )) +FILE_WRITE_DATA = make_flag("FILE_WRITE_DATA", ( 0x0002 )) +FILE_ADD_FILE = make_flag("FILE_ADD_FILE", ( 0x0002 )) +FILE_APPEND_DATA = make_flag("FILE_APPEND_DATA", ( 0x0004 )) +FILE_ADD_SUBDIRECTORY = make_flag("FILE_ADD_SUBDIRECTORY", ( 0x0004 )) +FILE_CREATE_PIPE_INSTANCE = make_flag("FILE_CREATE_PIPE_INSTANCE", ( 0x0004 )) +FILE_READ_EA = make_flag("FILE_READ_EA", ( 0x0008 )) +FILE_WRITE_EA = make_flag("FILE_WRITE_EA", ( 0x0010 )) +FILE_EXECUTE = make_flag("FILE_EXECUTE", ( 0x0020 )) +FILE_TRAVERSE = make_flag("FILE_TRAVERSE", ( 0x0020 )) +FILE_DELETE_CHILD = make_flag("FILE_DELETE_CHILD", ( 0x0040 )) +FILE_READ_ATTRIBUTES = make_flag("FILE_READ_ATTRIBUTES", ( 0x0080 )) +FILE_WRITE_ATTRIBUTES = make_flag("FILE_WRITE_ATTRIBUTES", ( 0x0100 )) +FILE_ALL_ACCESS = make_flag("FILE_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF )) +FILE_GENERIC_READ = make_flag("FILE_GENERIC_READ", ( STANDARD_RIGHTS_READ | FILE_READ_DATA | FILE_READ_ATTRIBUTES | FILE_READ_EA | SYNCHRONIZE )) +FILE_GENERIC_WRITE = make_flag("FILE_GENERIC_WRITE", ( STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE )) +FILE_GENERIC_EXECUTE = make_flag("FILE_GENERIC_EXECUTE", ( STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES | FILE_EXECUTE | SYNCHRONIZE )) +CALLBACK_MODIFY_STATE = make_flag("CALLBACK_MODIFY_STATE", 0x0001) +CALLBACK_ALL_ACCESS = make_flag("CALLBACK_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE| CALLBACK_MODIFY_STATE )) +EVENT_QUERY_STATE = make_flag("EVENT_QUERY_STATE", 0x0001) +EVENT_MODIFY_STATE = make_flag("EVENT_MODIFY_STATE", 0x0002) +EVENT_ALL_ACCESS = make_flag("EVENT_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3 )) +MUTANT_QUERY_STATE = make_flag("MUTANT_QUERY_STATE", 0x0001) +MUTANT_ALL_ACCESS = make_flag("MUTANT_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE| MUTANT_QUERY_STATE )) +SEMAPHORE_QUERY_STATE = make_flag("SEMAPHORE_QUERY_STATE", 0x0001) +SEMAPHORE_MODIFY_STATE = make_flag("SEMAPHORE_MODIFY_STATE", 0x0002) +SEMAPHORE_ALL_ACCESS = make_flag("SEMAPHORE_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3 )) +TIMER_QUERY_STATE = make_flag("TIMER_QUERY_STATE", 0x0001) +TIMER_MODIFY_STATE = make_flag("TIMER_MODIFY_STATE", 0x0002) +TIMER_ALL_ACCESS = make_flag("TIMER_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE| TIMER_QUERY_STATE|TIMER_MODIFY_STATE )) +IO_COMPLETION_QUERY_STATE = make_flag("IO_COMPLETION_QUERY_STATE", 0x0001) +IO_COMPLETION_MODIFY_STATE = make_flag("IO_COMPLETION_MODIFY_STATE", 0x0002) +IO_COMPLETION_ALL_ACCESS = make_flag("IO_COMPLETION_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3 )) +PORT_CONNECT = make_flag("PORT_CONNECT", ( 0x0001 )) +PORT_ALL_ACCESS = make_flag("PORT_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1 )) +OBJECT_TYPE_CREATE = make_flag("OBJECT_TYPE_CREATE", ( 0x0001 )) +OBJECT_TYPE_ALL_ACCESS = make_flag("OBJECT_TYPE_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | 0x1 )) +DIRECTORY_QUERY = make_flag("DIRECTORY_QUERY", ( 0x0001 )) +DIRECTORY_TRAVERSE = make_flag("DIRECTORY_TRAVERSE", ( 0x0002 )) +DIRECTORY_CREATE_OBJECT = make_flag("DIRECTORY_CREATE_OBJECT", ( 0x0004 )) +DIRECTORY_CREATE_SUBDIRECTORY = make_flag("DIRECTORY_CREATE_SUBDIRECTORY", ( 0x0008 )) +DIRECTORY_ALL_ACCESS = make_flag("DIRECTORY_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | 0xF )) +SYMBOLIC_LINK_QUERY = make_flag("SYMBOLIC_LINK_QUERY", ( 0x0001 )) +SYMBOLIC_LINK_ALL_ACCESS = make_flag("SYMBOLIC_LINK_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | 0x1 )) +PROCESS_TERMINATE = make_flag("PROCESS_TERMINATE", ( 0x0001 )) +PROCESS_CREATE_THREAD = make_flag("PROCESS_CREATE_THREAD", ( 0x0002 )) +PROCESS_SET_SESSIONID = make_flag("PROCESS_SET_SESSIONID", ( 0x0004 )) +PROCESS_VM_OPERATION = make_flag("PROCESS_VM_OPERATION", ( 0x0008 )) +PROCESS_VM_READ = make_flag("PROCESS_VM_READ", ( 0x0010 )) +PROCESS_VM_WRITE = make_flag("PROCESS_VM_WRITE", ( 0x0020 )) +PROCESS_DUP_HANDLE = make_flag("PROCESS_DUP_HANDLE", ( 0x0040 )) +PROCESS_CREATE_PROCESS = make_flag("PROCESS_CREATE_PROCESS", ( 0x0080 )) +PROCESS_SET_QUOTA = make_flag("PROCESS_SET_QUOTA", ( 0x0100 )) +PROCESS_SET_INFORMATION = make_flag("PROCESS_SET_INFORMATION", ( 0x0200 )) +PROCESS_QUERY_INFORMATION = make_flag("PROCESS_QUERY_INFORMATION", ( 0x0400 )) +PROCESS_SUSPEND_RESUME = make_flag("PROCESS_SUSPEND_RESUME", ( 0x0800 )) +PROCESS_QUERY_LIMITED_INFORMATION = make_flag("PROCESS_QUERY_LIMITED_INFORMATION", ( 0x1000 )) +PROCESS_SET_LIMITED_INFORMATION = make_flag("PROCESS_SET_LIMITED_INFORMATION", ( 0x2000 )) +PROCESS_ALL_ACCESS = make_flag("PROCESS_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF )) +THREAD_TERMINATE = make_flag("THREAD_TERMINATE", ( 0x0001 )) +THREAD_SUSPEND_RESUME = make_flag("THREAD_SUSPEND_RESUME", ( 0x0002 )) +THREAD_GET_CONTEXT = make_flag("THREAD_GET_CONTEXT", ( 0x0008 )) +THREAD_SET_CONTEXT = make_flag("THREAD_SET_CONTEXT", ( 0x0010 )) +THREAD_QUERY_INFORMATION = make_flag("THREAD_QUERY_INFORMATION", ( 0x0040 )) +THREAD_SET_INFORMATION = make_flag("THREAD_SET_INFORMATION", ( 0x0020 )) +THREAD_SET_THREAD_TOKEN = make_flag("THREAD_SET_THREAD_TOKEN", ( 0x0080 )) +THREAD_IMPERSONATE = make_flag("THREAD_IMPERSONATE", ( 0x0100 )) +THREAD_DIRECT_IMPERSONATION = make_flag("THREAD_DIRECT_IMPERSONATION", ( 0x0200 )) +THREAD_ALL_ACCESS = make_flag("THREAD_ALL_ACCESS", 0x001F03FF) +JOB_OBJECT_ASSIGN_PROCESS = make_flag("JOB_OBJECT_ASSIGN_PROCESS", ( 0x0001 )) +JOB_OBJECT_SET_ATTRIBUTES = make_flag("JOB_OBJECT_SET_ATTRIBUTES", ( 0x0002 )) +JOB_OBJECT_QUERY = make_flag("JOB_OBJECT_QUERY", ( 0x0004 )) +JOB_OBJECT_TERMINATE = make_flag("JOB_OBJECT_TERMINATE", ( 0x0008 )) +JOB_OBJECT_SET_SECURITY_ATTRIBUTES = make_flag("JOB_OBJECT_SET_SECURITY_ATTRIBUTES", ( 0x0010 )) +JOB_OBJECT_ALL_ACCESS = make_flag("JOB_OBJECT_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1F )) +KEY_QUERY_VALUE = make_flag("KEY_QUERY_VALUE", ( 0x0001 )) +KEY_SET_VALUE = make_flag("KEY_SET_VALUE", ( 0x0002 )) +KEY_CREATE_SUB_KEY = make_flag("KEY_CREATE_SUB_KEY", ( 0x0004 )) +KEY_ENUMERATE_SUB_KEYS = make_flag("KEY_ENUMERATE_SUB_KEYS", ( 0x0008 )) +KEY_NOTIFY = make_flag("KEY_NOTIFY", ( 0x0010 )) +KEY_CREATE_LINK = make_flag("KEY_CREATE_LINK", ( 0x0020 )) +KEY_WOW64_32KEY = make_flag("KEY_WOW64_32KEY", ( 0x0200 )) +KEY_WOW64_64KEY = make_flag("KEY_WOW64_64KEY", ( 0x0100 )) +KEY_WOW64_RES = make_flag("KEY_WOW64_RES", ( 0x0300 )) +KEY_READ = make_flag("KEY_READ", ( ( STANDARD_RIGHTS_READ|KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY ) & ( ~SYNCHRONIZE ) )) +KEY_WRITE = make_flag("KEY_WRITE", ( ( STANDARD_RIGHTS_WRITE|KEY_SET_VALUE|KEY_CREATE_SUB_KEY ) & ( ~SYNCHRONIZE ) )) +KEY_EXECUTE = make_flag("KEY_EXECUTE", ( ( KEY_READ ) & ( ~SYNCHRONIZE ) )) +KEY_ALL_ACCESS = make_flag("KEY_ALL_ACCESS", ( ( STANDARD_RIGHTS_ALL|KEY_QUERY_VALUE|KEY_SET_VALUE|KEY_CREATE_SUB_KEY|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY|KEY_CREATE_LINK ) & ( ~SYNCHRONIZE ) )) +CLUSAPI_READ_ACCESS = make_flag("CLUSAPI_READ_ACCESS", 0x00000001) +CLUSAPI_CHANGE_ACCESS = make_flag("CLUSAPI_CHANGE_ACCESS", 0x00000002) +CLUSAPI_NO_ACCESS = make_flag("CLUSAPI_NO_ACCESS", 0x00000004) +CLUSAPI_ALL_ACCESS = make_flag("CLUSAPI_ALL_ACCESS", ( CLUSAPI_READ_ACCESS | CLUSAPI_CHANGE_ACCESS )) +FAX_JOB_SUBMIT = make_flag("FAX_JOB_SUBMIT", ( 0x0001 )) +FAX_JOB_QUERY = make_flag("FAX_JOB_QUERY", ( 0x0002 )) +FAX_CONFIG_QUERY = make_flag("FAX_CONFIG_QUERY", ( 0x0004 )) +FAX_CONFIG_SET = make_flag("FAX_CONFIG_SET", ( 0x0008 )) +FAX_PORT_QUERY = make_flag("FAX_PORT_QUERY", ( 0x0010 )) +FAX_PORT_SET = make_flag("FAX_PORT_SET", ( 0x0020 )) +FAX_JOB_MANAGE = make_flag("FAX_JOB_MANAGE", ( 0x0040 )) +COM_EXECUTE = make_flag("COM_EXECUTE", ( 0x0001 )) +COM_EXECUTE_LOCAL = make_flag("COM_EXECUTE_LOCAL", ( 0x0002 )) +COM_EXECUTE_REMOTE = make_flag("COM_EXECUTE_REMOTE", ( 0x0004 )) +COM_ACTIVATE_LOCAL = make_flag("COM_ACTIVATE_LOCAL", ( 0x0008 )) +COM_ACTIVATE_REMOTE = make_flag("COM_ACTIVATE_REMOTE", ( 0x0010 )) +SECTION_QUERY = make_flag("SECTION_QUERY", 0x0001) +SECTION_MAP_WRITE = make_flag("SECTION_MAP_WRITE", 0x0002) +SECTION_MAP_READ = make_flag("SECTION_MAP_READ", 0x0004) +SECTION_MAP_EXECUTE = make_flag("SECTION_MAP_EXECUTE", 0x0008) +SECTION_EXTEND_SIZE = make_flag("SECTION_EXTEND_SIZE", 0x0010) +SECTION_MAP_EXECUTE_EXPLICIT = make_flag("SECTION_MAP_EXECUTE_EXPLICIT", 0x0020) +SECTION_ALL_ACCESS = make_flag("SECTION_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SECTION_QUERY| SECTION_MAP_WRITE |SECTION_MAP_READ |SECTION_MAP_EXECUTE |SECTION_EXTEND_SIZE )) +FILE_MAP_COPY = make_flag("FILE_MAP_COPY", SECTION_QUERY) +FILE_MAP_WRITE = make_flag("FILE_MAP_WRITE", SECTION_MAP_WRITE) +FILE_MAP_READ = make_flag("FILE_MAP_READ", SECTION_MAP_READ) +FILE_MAP_ALL_ACCESS = make_flag("FILE_MAP_ALL_ACCESS", SECTION_ALL_ACCESS) +FILE_MAP_EXECUTE = make_flag("FILE_MAP_EXECUTE", SECTION_MAP_EXECUTE_EXPLICIT) +SYMSEARCH_MASKOBJS = make_flag("SYMSEARCH_MASKOBJS", 0x01) +SYMSEARCH_RECURSE = make_flag("SYMSEARCH_RECURSE", 0X02) +SYMSEARCH_GLOBALSONLY = make_flag("SYMSEARCH_GLOBALSONLY", 0X04) +SYMSEARCH_ALLITEMS = make_flag("SYMSEARCH_ALLITEMS", 0X08) +OS_WINDOWS = make_flag("OS_WINDOWS", 0) +OS_NT = make_flag("OS_NT", 1) +OS_WIN95ORGREATER = make_flag("OS_WIN95ORGREATER", 2) +OS_NT4ORGREATER = make_flag("OS_NT4ORGREATER", 3) +OS_WIN98ORGREATER = make_flag("OS_WIN98ORGREATER", 5) +OS_WIN98_GOLD = make_flag("OS_WIN98_GOLD", 6) +OS_WIN2000ORGREATER = make_flag("OS_WIN2000ORGREATER", 7) +OS_WIN2000PRO = make_flag("OS_WIN2000PRO", 8) +OS_WIN2000SERVER = make_flag("OS_WIN2000SERVER", 9) +OS_WIN2000ADVSERVER = make_flag("OS_WIN2000ADVSERVER", 10) +OS_WIN2000DATACENTER = make_flag("OS_WIN2000DATACENTER", 11) +OS_WIN2000TERMINAL = make_flag("OS_WIN2000TERMINAL", 12) +OS_EMBEDDED = make_flag("OS_EMBEDDED", 13) +OS_TERMINALCLIENT = make_flag("OS_TERMINALCLIENT", 14) +OS_TERMINALREMOTEADMIN = make_flag("OS_TERMINALREMOTEADMIN", 15) +OS_WIN95_GOLD = make_flag("OS_WIN95_GOLD", 16) +OS_MEORGREATER = make_flag("OS_MEORGREATER", 17) +OS_XPORGREATER = make_flag("OS_XPORGREATER", 18) +OS_HOME = make_flag("OS_HOME", 19) +OS_PROFESSIONAL = make_flag("OS_PROFESSIONAL", 20) +OS_DATACENTER = make_flag("OS_DATACENTER", 21) +OS_ADVSERVER = make_flag("OS_ADVSERVER", 22) +OS_SERVER = make_flag("OS_SERVER", 23) +OS_TERMINALSERVER = make_flag("OS_TERMINALSERVER", 24) +OS_PERSONALTERMINALSERVER = make_flag("OS_PERSONALTERMINALSERVER", 25) +OS_FASTUSERSWITCHING = make_flag("OS_FASTUSERSWITCHING", 26) +OS_WELCOMELOGONUI = make_flag("OS_WELCOMELOGONUI", 27) +OS_DOMAINMEMBER = make_flag("OS_DOMAINMEMBER", 28) +OS_ANYSERVER = make_flag("OS_ANYSERVER", 29) +OS_WOW6432 = make_flag("OS_WOW6432", 30) +OS_WEBSERVER = make_flag("OS_WEBSERVER", 31) +OS_SMALLBUSINESSSERVER = make_flag("OS_SMALLBUSINESSSERVER", 32) +OS_TABLETPC = make_flag("OS_TABLETPC", 33) +OS_SERVERADMINUI = make_flag("OS_SERVERADMINUI", 34) +OS_MEDIACENTER = make_flag("OS_MEDIACENTER", 35) +OS_APPLIANCE = make_flag("OS_APPLIANCE", 36) +IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA = make_flag("IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA", 0x0020) +IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE = make_flag("IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE", 0x0040) +IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY = make_flag("IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY", 0x0080) +IMAGE_DLLCHARACTERISTICS_NX_COMPAT = make_flag("IMAGE_DLLCHARACTERISTICS_NX_COMPAT", 0x0100) +IMAGE_DLLCHARACTERISTICS_NO_ISOLATION = make_flag("IMAGE_DLLCHARACTERISTICS_NO_ISOLATION", 0x0200) +IMAGE_DLLCHARACTERISTICS_NO_SEH = make_flag("IMAGE_DLLCHARACTERISTICS_NO_SEH", 0x0400) +IMAGE_DLLCHARACTERISTICS_NO_BIND = make_flag("IMAGE_DLLCHARACTERISTICS_NO_BIND", 0x0800) +IMAGE_DLLCHARACTERISTICS_APPCONTAINER = make_flag("IMAGE_DLLCHARACTERISTICS_APPCONTAINER", 0x1000) +IMAGE_DLLCHARACTERISTICS_WDM_DRIVER = make_flag("IMAGE_DLLCHARACTERISTICS_WDM_DRIVER", 0x2000) +IMAGE_DLLCHARACTERISTICS_GUARD_CF = make_flag("IMAGE_DLLCHARACTERISTICS_GUARD_CF", 0x4000) +IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE = make_flag("IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE", 0x8000) +IMAGE_DIRECTORY_ENTRY_EXPORT = make_flag("IMAGE_DIRECTORY_ENTRY_EXPORT", 0) +IMAGE_DIRECTORY_ENTRY_IMPORT = make_flag("IMAGE_DIRECTORY_ENTRY_IMPORT", 1) +IMAGE_DIRECTORY_ENTRY_RESOURCE = make_flag("IMAGE_DIRECTORY_ENTRY_RESOURCE", 2) +IMAGE_DIRECTORY_ENTRY_EXCEPTION = make_flag("IMAGE_DIRECTORY_ENTRY_EXCEPTION", 3) +IMAGE_DIRECTORY_ENTRY_SECURITY = make_flag("IMAGE_DIRECTORY_ENTRY_SECURITY", 4) +IMAGE_DIRECTORY_ENTRY_BASERELOC = make_flag("IMAGE_DIRECTORY_ENTRY_BASERELOC", 5) +IMAGE_DIRECTORY_ENTRY_DEBUG = make_flag("IMAGE_DIRECTORY_ENTRY_DEBUG", 6) +IMAGE_DIRECTORY_ENTRY_ARCHITECTURE = make_flag("IMAGE_DIRECTORY_ENTRY_ARCHITECTURE", 7) +IMAGE_DIRECTORY_ENTRY_GLOBALPTR = make_flag("IMAGE_DIRECTORY_ENTRY_GLOBALPTR", 8) +IMAGE_DIRECTORY_ENTRY_TLS = make_flag("IMAGE_DIRECTORY_ENTRY_TLS", 9) +IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG = make_flag("IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG", 10) +IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT = make_flag("IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT", 11) +IMAGE_DIRECTORY_ENTRY_IAT = make_flag("IMAGE_DIRECTORY_ENTRY_IAT", 12) +IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT = make_flag("IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT", 13) +IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR = make_flag("IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR", 14) +IMAGE_REL_BASED_ABSOLUTE = make_flag("IMAGE_REL_BASED_ABSOLUTE", 0) +IMAGE_REL_BASED_HIGH = make_flag("IMAGE_REL_BASED_HIGH", 1) +IMAGE_REL_BASED_LOW = make_flag("IMAGE_REL_BASED_LOW", 2) +IMAGE_REL_BASED_HIGHLOW = make_flag("IMAGE_REL_BASED_HIGHLOW", 3) +IMAGE_REL_BASED_HIGHADJ = make_flag("IMAGE_REL_BASED_HIGHADJ", 4) +IMAGE_REL_BASED_MACHINE_SPECIFIC_5 = make_flag("IMAGE_REL_BASED_MACHINE_SPECIFIC_5", 5) +IMAGE_REL_BASED_RESERVED = make_flag("IMAGE_REL_BASED_RESERVED", 6) +IMAGE_REL_BASED_MACHINE_SPECIFIC_7 = make_flag("IMAGE_REL_BASED_MACHINE_SPECIFIC_7", 7) +IMAGE_REL_BASED_MACHINE_SPECIFIC_8 = make_flag("IMAGE_REL_BASED_MACHINE_SPECIFIC_8", 8) +IMAGE_REL_BASED_MACHINE_SPECIFIC_9 = make_flag("IMAGE_REL_BASED_MACHINE_SPECIFIC_9", 9) +IMAGE_REL_BASED_DIR64 = make_flag("IMAGE_REL_BASED_DIR64", 10) +TOKEN_SOURCE_LENGTH = make_flag("TOKEN_SOURCE_LENGTH", 8) +SID_HASH_SIZE = make_flag("SID_HASH_SIZE", 32) +TOKEN_MANDATORY_POLICY_OFF = make_flag("TOKEN_MANDATORY_POLICY_OFF", 0x0) +TOKEN_MANDATORY_POLICY_NO_WRITE_UP = make_flag("TOKEN_MANDATORY_POLICY_NO_WRITE_UP", 0x1) +TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN = make_flag("TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN", 0x2) +TOKEN_MANDATORY_POLICY_VALID_MASK = make_flag("TOKEN_MANDATORY_POLICY_VALID_MASK", ( TOKEN_MANDATORY_POLICY_NO_WRITE_UP | TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN )) +TOKEN_SECURITY_ATTRIBUTE_TYPE_INVALID = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_INVALID", 0x00) +TOKEN_SECURITY_ATTRIBUTE_TYPE_INT64 = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_INT64", 0x01) +TOKEN_SECURITY_ATTRIBUTE_TYPE_UINT64 = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_UINT64", 0x02) +TOKEN_SECURITY_ATTRIBUTE_TYPE_STRING = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_STRING", 0x03) +TOKEN_SECURITY_ATTRIBUTE_TYPE_FQBN = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_FQBN", 0x04) +TOKEN_SECURITY_ATTRIBUTE_TYPE_SID = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_SID", 0x05) +TOKEN_SECURITY_ATTRIBUTE_TYPE_BOOLEAN = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_BOOLEAN", 0x06) +TOKEN_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING", 0x10) +TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE = make_flag("TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE", 0x0001) +TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE = make_flag("TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE", 0x0002) +TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY = make_flag("TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY", 0x0004) +TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT = make_flag("TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT", 0x0008) +TOKEN_SECURITY_ATTRIBUTE_DISABLED = make_flag("TOKEN_SECURITY_ATTRIBUTE_DISABLED", 0x0010) +TOKEN_SECURITY_ATTRIBUTE_MANDATORY = make_flag("TOKEN_SECURITY_ATTRIBUTE_MANDATORY", 0x0020) +TOKEN_SECURITY_ATTRIBUTE_VALID_FLAGS = make_flag("TOKEN_SECURITY_ATTRIBUTE_VALID_FLAGS", ( TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE | TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE | TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY | TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT | TOKEN_SECURITY_ATTRIBUTE_DISABLED | TOKEN_SECURITY_ATTRIBUTE_MANDATORY )) +TOKEN_SECURITY_ATTRIBUTE_CUSTOM_FLAGS = make_flag("TOKEN_SECURITY_ATTRIBUTE_CUSTOM_FLAGS", 0xffff0000) +TOKEN_ASSIGN_PRIMARY = make_flag("TOKEN_ASSIGN_PRIMARY", ( 0x0001 )) +TOKEN_DUPLICATE = make_flag("TOKEN_DUPLICATE", ( 0x0002 )) +TOKEN_IMPERSONATE = make_flag("TOKEN_IMPERSONATE", ( 0x0004 )) +TOKEN_QUERY = make_flag("TOKEN_QUERY", ( 0x0008 )) +TOKEN_QUERY_SOURCE = make_flag("TOKEN_QUERY_SOURCE", ( 0x0010 )) +TOKEN_ADJUST_PRIVILEGES = make_flag("TOKEN_ADJUST_PRIVILEGES", ( 0x0020 )) +TOKEN_ADJUST_GROUPS = make_flag("TOKEN_ADJUST_GROUPS", ( 0x0040 )) +TOKEN_ADJUST_DEFAULT = make_flag("TOKEN_ADJUST_DEFAULT", ( 0x0080 )) +TOKEN_ADJUST_SESSIONID = make_flag("TOKEN_ADJUST_SESSIONID", ( 0x0100 )) +TOKEN_ALL_ACCESS_P = make_flag("TOKEN_ALL_ACCESS_P", ( STANDARD_RIGHTS_REQUIRED | TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_QUERY_SOURCE | TOKEN_ADJUST_PRIVILEGES | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT )) +TOKEN_ALL_ACCESS = make_flag("TOKEN_ALL_ACCESS", ( TOKEN_ALL_ACCESS_P | TOKEN_ADJUST_SESSIONID )) +SE_PRIVILEGE_ENABLED_BY_DEFAULT = make_flag("SE_PRIVILEGE_ENABLED_BY_DEFAULT", ( 0x00000001 )) +SE_PRIVILEGE_ENABLED = make_flag("SE_PRIVILEGE_ENABLED", ( 0x00000002 )) +SE_PRIVILEGE_REMOVED = make_flag("SE_PRIVILEGE_REMOVED", ( 0X00000004 )) +SE_PRIVILEGE_USED_FOR_ACCESS = make_flag("SE_PRIVILEGE_USED_FOR_ACCESS", ( 0x80000000 )) +SE_CREATE_TOKEN_NAME = make_flag("SE_CREATE_TOKEN_NAME", ( "SeCreateTokenPrivilege" )) +SE_ASSIGNPRIMARYTOKEN_NAME = make_flag("SE_ASSIGNPRIMARYTOKEN_NAME", ( "SeAssignPrimaryTokenPrivilege" )) +SE_LOCK_MEMORY_NAME = make_flag("SE_LOCK_MEMORY_NAME", ( "SeLockMemoryPrivilege" )) +SE_INCREASE_QUOTA_NAME = make_flag("SE_INCREASE_QUOTA_NAME", ( "SeIncreaseQuotaPrivilege" )) +SE_UNSOLICITED_INPUT_NAME = make_flag("SE_UNSOLICITED_INPUT_NAME", ( "SeUnsolicitedInputPrivilege" )) +SE_MACHINE_ACCOUNT_NAME = make_flag("SE_MACHINE_ACCOUNT_NAME", ( "SeMachineAccountPrivilege" )) +SE_TCB_NAME = make_flag("SE_TCB_NAME", ( "SeTcbPrivilege" )) +SE_SECURITY_NAME = make_flag("SE_SECURITY_NAME", ( "SeSecurityPrivilege" )) +SE_TAKE_OWNERSHIP_NAME = make_flag("SE_TAKE_OWNERSHIP_NAME", ( "SeTakeOwnershipPrivilege" )) +SE_LOAD_DRIVER_NAME = make_flag("SE_LOAD_DRIVER_NAME", ( "SeLoadDriverPrivilege" )) +SE_SYSTEM_PROFILE_NAME = make_flag("SE_SYSTEM_PROFILE_NAME", ( "SeSystemProfilePrivilege" )) +SE_SYSTEMTIME_NAME = make_flag("SE_SYSTEMTIME_NAME", ( "SeSystemtimePrivilege" )) +SE_PROF_SINGLE_PROCESS_NAME = make_flag("SE_PROF_SINGLE_PROCESS_NAME", ( "SeProfileSingleProcessPrivilege" )) +SE_INC_BASE_PRIORITY_NAME = make_flag("SE_INC_BASE_PRIORITY_NAME", ( "SeIncreaseBasePriorityPrivilege" )) +SE_CREATE_PAGEFILE_NAME = make_flag("SE_CREATE_PAGEFILE_NAME", ( "SeCreatePagefilePrivilege" )) +SE_CREATE_PERMANENT_NAME = make_flag("SE_CREATE_PERMANENT_NAME", ( "SeCreatePermanentPrivilege" )) +SE_BACKUP_NAME = make_flag("SE_BACKUP_NAME", ( "SeBackupPrivilege" )) +SE_RESTORE_NAME = make_flag("SE_RESTORE_NAME", ( "SeRestorePrivilege" )) +SE_SHUTDOWN_NAME = make_flag("SE_SHUTDOWN_NAME", ( "SeShutdownPrivilege" )) +SE_DEBUG_NAME = make_flag("SE_DEBUG_NAME", ( "SeDebugPrivilege" )) +SE_AUDIT_NAME = make_flag("SE_AUDIT_NAME", ( "SeAuditPrivilege" )) +SE_SYSTEM_ENVIRONMENT_NAME = make_flag("SE_SYSTEM_ENVIRONMENT_NAME", ( "SeSystemEnvironmentPrivilege" )) +SE_CHANGE_NOTIFY_NAME = make_flag("SE_CHANGE_NOTIFY_NAME", ( "SeChangeNotifyPrivilege" )) +SE_REMOTE_SHUTDOWN_NAME = make_flag("SE_REMOTE_SHUTDOWN_NAME", ( "SeRemoteShutdownPrivilege" )) +SE_UNDOCK_NAME = make_flag("SE_UNDOCK_NAME", ( "SeUndockPrivilege" )) +SE_SYNC_AGENT_NAME = make_flag("SE_SYNC_AGENT_NAME", ( "SeSyncAgentPrivilege" )) +SE_ENABLE_DELEGATION_NAME = make_flag("SE_ENABLE_DELEGATION_NAME", ( "SeEnableDelegationPrivilege" )) +SE_MANAGE_VOLUME_NAME = make_flag("SE_MANAGE_VOLUME_NAME", ( "SeManageVolumePrivilege" )) +SE_IMPERSONATE_NAME = make_flag("SE_IMPERSONATE_NAME", ( "SeImpersonatePrivilege" )) +SE_CREATE_GLOBAL_NAME = make_flag("SE_CREATE_GLOBAL_NAME", ( "SeCreateGlobalPrivilege" )) +SE_TRUSTED_CREDMAN_ACCESS_NAME = make_flag("SE_TRUSTED_CREDMAN_ACCESS_NAME", ( "SeTrustedCredManAccessPrivilege" )) +SE_RELABEL_NAME = make_flag("SE_RELABEL_NAME", ( "SeRelabelPrivilege" )) +SE_INC_WORKING_SET_NAME = make_flag("SE_INC_WORKING_SET_NAME", ( "SeIncreaseWorkingSetPrivilege" )) +SE_TIME_ZONE_NAME = make_flag("SE_TIME_ZONE_NAME", ( "SeTimeZonePrivilege" )) +SE_CREATE_SYMBOLIC_LINK_NAME = make_flag("SE_CREATE_SYMBOLIC_LINK_NAME", ( "SeCreateSymbolicLinkPrivilege" )) +ACCESS_MIN_MS_ACE_TYPE = make_flag("ACCESS_MIN_MS_ACE_TYPE", ( 0x0 )) +ACCESS_ALLOWED_ACE_TYPE = make_flag("ACCESS_ALLOWED_ACE_TYPE", ( 0x0 )) +ACCESS_DENIED_ACE_TYPE = make_flag("ACCESS_DENIED_ACE_TYPE", ( 0x1 )) +SYSTEM_AUDIT_ACE_TYPE = make_flag("SYSTEM_AUDIT_ACE_TYPE", ( 0x2 )) +SYSTEM_ALARM_ACE_TYPE = make_flag("SYSTEM_ALARM_ACE_TYPE", ( 0x3 )) +ACCESS_MAX_MS_V2_ACE_TYPE = make_flag("ACCESS_MAX_MS_V2_ACE_TYPE", ( 0x3 )) +ACCESS_ALLOWED_COMPOUND_ACE_TYPE = make_flag("ACCESS_ALLOWED_COMPOUND_ACE_TYPE", ( 0x4 )) +ACCESS_MAX_MS_V3_ACE_TYPE = make_flag("ACCESS_MAX_MS_V3_ACE_TYPE", ( 0x4 )) +ACCESS_MIN_MS_OBJECT_ACE_TYPE = make_flag("ACCESS_MIN_MS_OBJECT_ACE_TYPE", ( 0x5 )) +ACCESS_ALLOWED_OBJECT_ACE_TYPE = make_flag("ACCESS_ALLOWED_OBJECT_ACE_TYPE", ( 0x5 )) +ACCESS_DENIED_OBJECT_ACE_TYPE = make_flag("ACCESS_DENIED_OBJECT_ACE_TYPE", ( 0x6 )) +SYSTEM_AUDIT_OBJECT_ACE_TYPE = make_flag("SYSTEM_AUDIT_OBJECT_ACE_TYPE", ( 0x7 )) +SYSTEM_ALARM_OBJECT_ACE_TYPE = make_flag("SYSTEM_ALARM_OBJECT_ACE_TYPE", ( 0x8 )) +ACCESS_MAX_MS_OBJECT_ACE_TYPE = make_flag("ACCESS_MAX_MS_OBJECT_ACE_TYPE", ( 0x8 )) +ACCESS_MAX_MS_V4_ACE_TYPE = make_flag("ACCESS_MAX_MS_V4_ACE_TYPE", ( 0x8 )) +ACCESS_MAX_MS_ACE_TYPE = make_flag("ACCESS_MAX_MS_ACE_TYPE", ( 0x8 )) +ACCESS_ALLOWED_CALLBACK_ACE_TYPE = make_flag("ACCESS_ALLOWED_CALLBACK_ACE_TYPE", ( 0x9 )) +ACCESS_DENIED_CALLBACK_ACE_TYPE = make_flag("ACCESS_DENIED_CALLBACK_ACE_TYPE", ( 0xA )) +ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE = make_flag("ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE", ( 0xB )) +ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE = make_flag("ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE", ( 0xC )) +SYSTEM_AUDIT_CALLBACK_ACE_TYPE = make_flag("SYSTEM_AUDIT_CALLBACK_ACE_TYPE", ( 0xD )) +SYSTEM_ALARM_CALLBACK_ACE_TYPE = make_flag("SYSTEM_ALARM_CALLBACK_ACE_TYPE", ( 0xE )) +SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE = make_flag("SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE", ( 0xF )) +SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE = make_flag("SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE", ( 0x10 )) +SYSTEM_MANDATORY_LABEL_ACE_TYPE = make_flag("SYSTEM_MANDATORY_LABEL_ACE_TYPE", ( 0x11 )) +ACCESS_MAX_MS_V5_ACE_TYPE = make_flag("ACCESS_MAX_MS_V5_ACE_TYPE", ( 0x11 )) +SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE = make_flag("SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE", ( 0x12 )) +SYSTEM_SCOPED_POLICY_ID_ACE_TYPE = make_flag("SYSTEM_SCOPED_POLICY_ID_ACE_TYPE", ( 0x13 )) +SYSTEM_PROCESS_TRUST_LABEL_ACE_TYPE = make_flag("SYSTEM_PROCESS_TRUST_LABEL_ACE_TYPE", ( 0x14 )) +ACCESS_MAX_MS_V5_ACE_TYPE = make_flag("ACCESS_MAX_MS_V5_ACE_TYPE", ( 0x14 )) +SEC_WINNT_AUTH_IDENTITY_ANSI = make_flag("SEC_WINNT_AUTH_IDENTITY_ANSI", 0x1) +SEC_WINNT_AUTH_IDENTITY_UNICODE = make_flag("SEC_WINNT_AUTH_IDENTITY_UNICODE", 0x2) +SE_OWNER_DEFAULTED = make_flag("SE_OWNER_DEFAULTED", 0x00000001) +SE_GROUP_DEFAULTED = make_flag("SE_GROUP_DEFAULTED", 0x00000002) +SE_DACL_PRESENT = make_flag("SE_DACL_PRESENT", 0x00000004) +SE_DACL_DEFAULTED = make_flag("SE_DACL_DEFAULTED", 0x00000008) +SE_SACL_PRESENT = make_flag("SE_SACL_PRESENT", 0x00000010) +SE_SACL_DEFAULTED = make_flag("SE_SACL_DEFAULTED", 0x00000020) +SE_DACL_AUTO_INHERIT_REQ = make_flag("SE_DACL_AUTO_INHERIT_REQ", 0x00000100) +SE_SACL_AUTO_INHERIT_REQ = make_flag("SE_SACL_AUTO_INHERIT_REQ", 0x00000200) +SE_DACL_AUTO_INHERITED = make_flag("SE_DACL_AUTO_INHERITED", 0x00000400) +SE_SACL_AUTO_INHERITED = make_flag("SE_SACL_AUTO_INHERITED", 0x00000800) +SE_DACL_PROTECTED = make_flag("SE_DACL_PROTECTED", 0x00001000) +SE_SACL_PROTECTED = make_flag("SE_SACL_PROTECTED", 0x00002000) +SE_RM_CONTROL_VALID = make_flag("SE_RM_CONTROL_VALID", 0x00004000) +SE_SELF_RELATIVE = make_flag("SE_SELF_RELATIVE", 0x00008000) +SDDL_REVISION_1 = make_flag("SDDL_REVISION_1", 0x1) +ACE_OBJECT_TYPE_PRESENT = make_flag("ACE_OBJECT_TYPE_PRESENT", 0x1) +ACE_INHERITED_OBJECT_TYPE_PRESENT = make_flag("ACE_INHERITED_OBJECT_TYPE_PRESENT", 0x2) +OBJECT_INHERIT_ACE = make_flag("OBJECT_INHERIT_ACE", ( 0x1 )) +CONTAINER_INHERIT_ACE = make_flag("CONTAINER_INHERIT_ACE", ( 0x2 )) +NO_PROPAGATE_INHERIT_ACE = make_flag("NO_PROPAGATE_INHERIT_ACE", ( 0x4 )) +INHERIT_ONLY_ACE = make_flag("INHERIT_ONLY_ACE", ( 0x8 )) +INHERITED_ACE = make_flag("INHERITED_ACE", ( 0x10 )) +VALID_INHERIT_FLAGS = make_flag("VALID_INHERIT_FLAGS", ( 0x1F )) +SUCCESSFUL_ACCESS_ACE_FLAG = make_flag("SUCCESSFUL_ACCESS_ACE_FLAG", ( 0x40 )) +FAILED_ACCESS_ACE_FLAG = make_flag("FAILED_ACCESS_ACE_FLAG", ( 0x80 )) +SYSTEM_MANDATORY_LABEL_NO_WRITE_UP = make_flag("SYSTEM_MANDATORY_LABEL_NO_WRITE_UP", 0x1) +SYSTEM_MANDATORY_LABEL_NO_READ_UP = make_flag("SYSTEM_MANDATORY_LABEL_NO_READ_UP", 0x2) +SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP = make_flag("SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP", 0x4) +SYSTEM_PROCESS_TRUST_LABEL_VALID_MASK = make_flag("SYSTEM_PROCESS_TRUST_LABEL_VALID_MASK", 0x00ffffff) +SYSTEM_PROCESS_TRUST_NOCONSTRAINT_MASK = make_flag("SYSTEM_PROCESS_TRUST_NOCONSTRAINT_MASK", 0xffffffff) +CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID", 0x00) +CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64 = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64", 0x01) +CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64 = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64", 0x02) +CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING", 0x03) +CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN", 0x04) +CLAIM_SECURITY_ATTRIBUTE_TYPE_SID = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_SID", 0x05) +CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN", 0x06) +CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING = make_flag("CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING", 0x10) +SE_GROUP_MANDATORY = make_flag("SE_GROUP_MANDATORY", ( 0x00000001 )) +SE_GROUP_ENABLED_BY_DEFAULT = make_flag("SE_GROUP_ENABLED_BY_DEFAULT", ( 0x00000002 )) +SE_GROUP_ENABLED = make_flag("SE_GROUP_ENABLED", ( 0x00000004 )) +SE_GROUP_OWNER = make_flag("SE_GROUP_OWNER", ( 0x00000008 )) +SE_GROUP_USE_FOR_DENY_ONLY = make_flag("SE_GROUP_USE_FOR_DENY_ONLY", ( 0x00000010 )) +SE_GROUP_INTEGRITY = make_flag("SE_GROUP_INTEGRITY", ( 0x00000020 )) +SE_GROUP_INTEGRITY_ENABLED = make_flag("SE_GROUP_INTEGRITY_ENABLED", ( 0x00000040 )) +SE_GROUP_LOGON_ID = make_flag("SE_GROUP_LOGON_ID", ( 0xC0000000 )) +SE_GROUP_RESOURCE = make_flag("SE_GROUP_RESOURCE", ( 0x20000000 )) +SE_GROUP_VALID_ATTRIBUTES = make_flag("SE_GROUP_VALID_ATTRIBUTES", ( SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED | SE_GROUP_OWNER | SE_GROUP_USE_FOR_DENY_ONLY | SE_GROUP_LOGON_ID | SE_GROUP_RESOURCE | SE_GROUP_INTEGRITY | SE_GROUP_INTEGRITY_ENABLED )) +OWNER_SECURITY_INFORMATION = make_flag("OWNER_SECURITY_INFORMATION", ( 0x00000001 )) +GROUP_SECURITY_INFORMATION = make_flag("GROUP_SECURITY_INFORMATION", ( 0x00000002 )) +DACL_SECURITY_INFORMATION = make_flag("DACL_SECURITY_INFORMATION", ( 0x00000004 )) +SACL_SECURITY_INFORMATION = make_flag("SACL_SECURITY_INFORMATION", ( 0x00000008 )) +LABEL_SECURITY_INFORMATION = make_flag("LABEL_SECURITY_INFORMATION", ( 0x00000010 )) +ATTRIBUTE_SECURITY_INFORMATION = make_flag("ATTRIBUTE_SECURITY_INFORMATION", ( 0x00000020 )) +SCOPE_SECURITY_INFORMATION = make_flag("SCOPE_SECURITY_INFORMATION", ( 0x00000040 )) +PROCESS_TRUST_LABEL_SECURITY_INFORMATION = make_flag("PROCESS_TRUST_LABEL_SECURITY_INFORMATION", ( 0x00000080 )) +BACKUP_SECURITY_INFORMATION = make_flag("BACKUP_SECURITY_INFORMATION", ( 0x00010000 )) +PROTECTED_DACL_SECURITY_INFORMATION = make_flag("PROTECTED_DACL_SECURITY_INFORMATION", ( 0x80000000 )) +PROTECTED_SACL_SECURITY_INFORMATION = make_flag("PROTECTED_SACL_SECURITY_INFORMATION", ( 0x40000000 )) +UNPROTECTED_DACL_SECURITY_INFORMATION = make_flag("UNPROTECTED_DACL_SECURITY_INFORMATION", ( 0x20000000 )) +UNPROTECTED_SACL_SECURITY_INFORMATION = make_flag("UNPROTECTED_SACL_SECURITY_INFORMATION", ( 0x10000000 )) RPC_REQUEST_TYPE_CALL = make_flag("RPC_REQUEST_TYPE_CALL", 0) RPC_REQUEST_TYPE_BIND = make_flag("RPC_REQUEST_TYPE_BIND", 1) RPC_RESPONSE_TYPE_BIND_OK = make_flag("RPC_RESPONSE_TYPE_BIND_OK", 1) @@ -766,275 +2387,9 @@ RPC_RESPONSE_TYPE_SUCCESS = make_flag("RPC_RESPONSE_TYPE_SUCCESS", 3) BIND_IF_SYNTAX_NDR32 = make_flag("BIND_IF_SYNTAX_NDR32", 1) BIND_IF_SYNTAX_NDR64 = make_flag("BIND_IF_SYNTAX_NDR64", 2) BIND_IF_SYNTAX_UNKNOWN = make_flag("BIND_IF_SYNTAX_UNKNOWN", 4) -CERT_QUERY_OBJECT_FILE = make_flag("CERT_QUERY_OBJECT_FILE", 0x00000001) -CERT_QUERY_OBJECT_BLOB = make_flag("CERT_QUERY_OBJECT_BLOB", 0x00000002) -CERT_QUERY_CONTENT_CERT = make_flag("CERT_QUERY_CONTENT_CERT", 1) -CERT_QUERY_CONTENT_CTL = make_flag("CERT_QUERY_CONTENT_CTL", 2) -CERT_QUERY_CONTENT_CRL = make_flag("CERT_QUERY_CONTENT_CRL", 3) -CERT_QUERY_CONTENT_SERIALIZED_STORE = make_flag("CERT_QUERY_CONTENT_SERIALIZED_STORE", 4) -CERT_QUERY_CONTENT_SERIALIZED_CERT = make_flag("CERT_QUERY_CONTENT_SERIALIZED_CERT", 5) -CERT_QUERY_CONTENT_SERIALIZED_CTL = make_flag("CERT_QUERY_CONTENT_SERIALIZED_CTL", 6) -CERT_QUERY_CONTENT_SERIALIZED_CRL = make_flag("CERT_QUERY_CONTENT_SERIALIZED_CRL", 7) -CERT_QUERY_CONTENT_PKCS7_SIGNED = make_flag("CERT_QUERY_CONTENT_PKCS7_SIGNED", 8) -CERT_QUERY_CONTENT_PKCS7_UNSIGNED = make_flag("CERT_QUERY_CONTENT_PKCS7_UNSIGNED", 9) -CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED = make_flag("CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED", 10) -CERT_QUERY_CONTENT_PKCS10 = make_flag("CERT_QUERY_CONTENT_PKCS10", 11) -CERT_QUERY_CONTENT_PFX = make_flag("CERT_QUERY_CONTENT_PFX", 12) -CERT_QUERY_CONTENT_CERT_PAIR = make_flag("CERT_QUERY_CONTENT_CERT_PAIR", 13) -CERT_QUERY_CONTENT_PFX_AND_LOAD = make_flag("CERT_QUERY_CONTENT_PFX_AND_LOAD", 14) -CERT_QUERY_FORMAT_BINARY = make_flag("CERT_QUERY_FORMAT_BINARY", 1) -CERT_QUERY_FORMAT_BASE64_ENCODED = make_flag("CERT_QUERY_FORMAT_BASE64_ENCODED", 2) -CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED = make_flag("CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED", 3) -CERT_QUERY_FORMAT_FLAG_BINARY = make_flag("CERT_QUERY_FORMAT_FLAG_BINARY", ( 1 << CERT_QUERY_FORMAT_BINARY )) -CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED = make_flag("CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED", ( 1 << CERT_QUERY_FORMAT_BASE64_ENCODED )) -CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED = make_flag("CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED", ( 1 << CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED )) -CERT_QUERY_FORMAT_FLAG_ALL = make_flag("CERT_QUERY_FORMAT_FLAG_ALL", ( CERT_QUERY_FORMAT_FLAG_BINARY | CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED | CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED )) -CERT_QUERY_CONTENT_FLAG_CERT = make_flag("CERT_QUERY_CONTENT_FLAG_CERT", ( 1 << CERT_QUERY_CONTENT_CERT )) -CERT_QUERY_CONTENT_FLAG_CTL = make_flag("CERT_QUERY_CONTENT_FLAG_CTL", ( 1 << CERT_QUERY_CONTENT_CTL )) -CERT_QUERY_CONTENT_FLAG_CRL = make_flag("CERT_QUERY_CONTENT_FLAG_CRL", ( 1 << CERT_QUERY_CONTENT_CRL )) -CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE = make_flag("CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE", ( 1 << CERT_QUERY_CONTENT_SERIALIZED_STORE )) -CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT = make_flag("CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT", ( 1 << CERT_QUERY_CONTENT_SERIALIZED_CERT )) -CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL = make_flag("CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL", ( 1 << CERT_QUERY_CONTENT_SERIALIZED_CTL )) -CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL = make_flag("CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL", ( 1 << CERT_QUERY_CONTENT_SERIALIZED_CRL )) -CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED = make_flag("CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED", ( 1 << CERT_QUERY_CONTENT_PKCS7_SIGNED )) -CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED = make_flag("CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED", ( 1 << CERT_QUERY_CONTENT_PKCS7_UNSIGNED )) -CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED = make_flag("CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED", ( 1 << CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED )) -CERT_QUERY_CONTENT_FLAG_PKCS10 = make_flag("CERT_QUERY_CONTENT_FLAG_PKCS10", ( 1 << CERT_QUERY_CONTENT_PKCS10 )) -CERT_QUERY_CONTENT_FLAG_PFX = make_flag("CERT_QUERY_CONTENT_FLAG_PFX", ( 1 << CERT_QUERY_CONTENT_PFX )) -CERT_QUERY_CONTENT_FLAG_CERT_PAIR = make_flag("CERT_QUERY_CONTENT_FLAG_CERT_PAIR", ( 1 << CERT_QUERY_CONTENT_CERT_PAIR )) -CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD = make_flag("CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD", ( 1 << CERT_QUERY_CONTENT_PFX_AND_LOAD )) -CERT_QUERY_CONTENT_FLAG_ALL = make_flag("CERT_QUERY_CONTENT_FLAG_ALL", ( CERT_QUERY_CONTENT_FLAG_CERT | CERT_QUERY_CONTENT_FLAG_CTL | CERT_QUERY_CONTENT_FLAG_CRL | CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED | CERT_QUERY_CONTENT_FLAG_PKCS10 | CERT_QUERY_CONTENT_FLAG_PFX | CERT_QUERY_CONTENT_FLAG_CERT_PAIR )) -CRYPT_ASN_ENCODING = make_flag("CRYPT_ASN_ENCODING", 0x00000001) -CRYPT_NDR_ENCODING = make_flag("CRYPT_NDR_ENCODING", 0x00000002) -X509_ASN_ENCODING = make_flag("X509_ASN_ENCODING", 0x00000001) -X509_NDR_ENCODING = make_flag("X509_NDR_ENCODING", 0x00000002) -PKCS_7_ASN_ENCODING = make_flag("PKCS_7_ASN_ENCODING", 0x00010000) -PKCS_7_NDR_ENCODING = make_flag("PKCS_7_NDR_ENCODING", 0x00020000) -CERT_ENCODING_TYPE_MASK = make_flag("CERT_ENCODING_TYPE_MASK", 0x0000FFFF) -CMSG_ENCODING_TYPE_MASK = make_flag("CMSG_ENCODING_TYPE_MASK", 0xFFFF0000) -CERT_COMPARE_MASK = make_flag("CERT_COMPARE_MASK", 0xFFFF) -CERT_COMPARE_SHIFT = make_flag("CERT_COMPARE_SHIFT", 16) -CERT_COMPARE_ANY = make_flag("CERT_COMPARE_ANY", 0) -CERT_COMPARE_SHA1_HASH = make_flag("CERT_COMPARE_SHA1_HASH", 1) -CERT_COMPARE_NAME = make_flag("CERT_COMPARE_NAME", 2) -CERT_COMPARE_ATTR = make_flag("CERT_COMPARE_ATTR", 3) -CERT_COMPARE_MD5_HASH = make_flag("CERT_COMPARE_MD5_HASH", 4) -CERT_COMPARE_PROPERTY = make_flag("CERT_COMPARE_PROPERTY", 5) -CERT_COMPARE_PUBLIC_KEY = make_flag("CERT_COMPARE_PUBLIC_KEY", 6) -CERT_COMPARE_HASH = make_flag("CERT_COMPARE_HASH", CERT_COMPARE_SHA1_HASH) -CERT_COMPARE_NAME_STR_A = make_flag("CERT_COMPARE_NAME_STR_A", 7) -CERT_COMPARE_NAME_STR_W = make_flag("CERT_COMPARE_NAME_STR_W", 8) -CERT_COMPARE_KEY_SPEC = make_flag("CERT_COMPARE_KEY_SPEC", 9) -CERT_COMPARE_ENHKEY_USAGE = make_flag("CERT_COMPARE_ENHKEY_USAGE", 10) -CERT_COMPARE_CTL_USAGE = make_flag("CERT_COMPARE_CTL_USAGE", CERT_COMPARE_ENHKEY_USAGE) -CERT_COMPARE_SUBJECT_CERT = make_flag("CERT_COMPARE_SUBJECT_CERT", 11) -CERT_COMPARE_ISSUER_OF = make_flag("CERT_COMPARE_ISSUER_OF", 12) -CERT_COMPARE_EXISTING = make_flag("CERT_COMPARE_EXISTING", 13) -CERT_COMPARE_SIGNATURE_HASH = make_flag("CERT_COMPARE_SIGNATURE_HASH", 14) -CERT_COMPARE_KEY_IDENTIFIER = make_flag("CERT_COMPARE_KEY_IDENTIFIER", 15) -CERT_COMPARE_CERT_ID = make_flag("CERT_COMPARE_CERT_ID", 16) -CERT_COMPARE_CROSS_CERT_DIST_POINTS = make_flag("CERT_COMPARE_CROSS_CERT_DIST_POINTS", 17) -CERT_COMPARE_PUBKEY_MD5_HASH = make_flag("CERT_COMPARE_PUBKEY_MD5_HASH", 18) -CERT_COMPARE_SUBJECT_INFO_ACCESS = make_flag("CERT_COMPARE_SUBJECT_INFO_ACCESS", 19) -CERT_NAME_ISSUER_FLAG = make_flag("CERT_NAME_ISSUER_FLAG", 0x1) -CERT_NAME_DISABLE_IE4_UTF8_FLAG = make_flag("CERT_NAME_DISABLE_IE4_UTF8_FLAG", 0x00010000) -USAGE_MATCH_TYPE_AND = make_flag("USAGE_MATCH_TYPE_AND", 0x00000000) -USAGE_MATCH_TYPE_OR = make_flag("USAGE_MATCH_TYPE_OR", 0x00000001) -CERT_CHAIN_REVOCATION_CHECK_END_CERT = make_flag("CERT_CHAIN_REVOCATION_CHECK_END_CERT", 0x10000000) -CERT_CHAIN_REVOCATION_CHECK_CHAIN = make_flag("CERT_CHAIN_REVOCATION_CHECK_CHAIN", 0x20000000) -CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT = make_flag("CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT", 0x40000000) -CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY = make_flag("CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY", 0x80000000) -CERT_TRUST_NO_ERROR = make_flag("CERT_TRUST_NO_ERROR", 0x00000000) -CERT_TRUST_IS_NOT_TIME_VALID = make_flag("CERT_TRUST_IS_NOT_TIME_VALID", 0x00000001) -CERT_TRUST_IS_NOT_TIME_NESTED = make_flag("CERT_TRUST_IS_NOT_TIME_NESTED", 0x00000002) -CERT_TRUST_IS_REVOKED = make_flag("CERT_TRUST_IS_REVOKED", 0x00000004) -CERT_TRUST_IS_NOT_SIGNATURE_VALID = make_flag("CERT_TRUST_IS_NOT_SIGNATURE_VALID", 0x00000008) -CERT_TRUST_IS_NOT_VALID_FOR_USAGE = make_flag("CERT_TRUST_IS_NOT_VALID_FOR_USAGE", 0x00000010) -CERT_TRUST_IS_UNTRUSTED_ROOT = make_flag("CERT_TRUST_IS_UNTRUSTED_ROOT", 0x00000020) -CERT_TRUST_REVOCATION_STATUS_UNKNOWN = make_flag("CERT_TRUST_REVOCATION_STATUS_UNKNOWN", 0x00000040) -CERT_TRUST_IS_CYCLIC = make_flag("CERT_TRUST_IS_CYCLIC", 0x00000080) -CERT_TRUST_INVALID_EXTENSION = make_flag("CERT_TRUST_INVALID_EXTENSION", 0x00000100) -CERT_TRUST_INVALID_POLICY_CONSTRAINTS = make_flag("CERT_TRUST_INVALID_POLICY_CONSTRAINTS", 0x00000200) -CERT_TRUST_INVALID_BASIC_CONSTRAINTS = make_flag("CERT_TRUST_INVALID_BASIC_CONSTRAINTS", 0x00000400) -CERT_TRUST_INVALID_NAME_CONSTRAINTS = make_flag("CERT_TRUST_INVALID_NAME_CONSTRAINTS", 0x00000800) -CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT = make_flag("CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT", 0x00001000) -CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT = make_flag("CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT", 0x00002000) -CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT = make_flag("CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT", 0x00004000) -CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT = make_flag("CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT", 0x00008000) -CERT_TRUST_IS_OFFLINE_REVOCATION = make_flag("CERT_TRUST_IS_OFFLINE_REVOCATION", 0x01000000) -CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY = make_flag("CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY", 0x02000000) -CERT_TRUST_IS_EXPLICIT_DISTRUST = make_flag("CERT_TRUST_IS_EXPLICIT_DISTRUST", 0x04000000) -CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT = make_flag("CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT", 0x08000000) -CERT_TRUST_IS_PARTIAL_CHAIN = make_flag("CERT_TRUST_IS_PARTIAL_CHAIN", 0x00010000) -CERT_TRUST_CTL_IS_NOT_TIME_VALID = make_flag("CERT_TRUST_CTL_IS_NOT_TIME_VALID", 0x00020000) -CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID = make_flag("CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID", 0x00040000) -CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE = make_flag("CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE", 0x00080000) -CERT_TRUST_HAS_EXACT_MATCH_ISSUER = make_flag("CERT_TRUST_HAS_EXACT_MATCH_ISSUER", 0x00000001) -CERT_TRUST_HAS_KEY_MATCH_ISSUER = make_flag("CERT_TRUST_HAS_KEY_MATCH_ISSUER", 0x00000002) -CERT_TRUST_HAS_NAME_MATCH_ISSUER = make_flag("CERT_TRUST_HAS_NAME_MATCH_ISSUER", 0x00000004) -CERT_TRUST_IS_SELF_SIGNED = make_flag("CERT_TRUST_IS_SELF_SIGNED", 0x00000008) -CERT_TRUST_HAS_PREFERRED_ISSUER = make_flag("CERT_TRUST_HAS_PREFERRED_ISSUER", 0x00000100) -CERT_TRUST_HAS_ISSUANCE_CHAIN_POLICY = make_flag("CERT_TRUST_HAS_ISSUANCE_CHAIN_POLICY", 0x00000200) -CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS = make_flag("CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS", 0x00000400) -CERT_TRUST_IS_PEER_TRUSTED = make_flag("CERT_TRUST_IS_PEER_TRUSTED", 0x00000800) -CERT_TRUST_HAS_CRL_VALIDITY_EXTENDED = make_flag("CERT_TRUST_HAS_CRL_VALIDITY_EXTENDED", 0x00001000) -CERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORE = make_flag("CERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORE", 0x00002000) -CERT_TRUST_IS_COMPLEX_CHAIN = make_flag("CERT_TRUST_IS_COMPLEX_CHAIN", 0x00010000) -CMSG_TYPE_PARAM = make_flag("CMSG_TYPE_PARAM", 1) -CMSG_CONTENT_PARAM = make_flag("CMSG_CONTENT_PARAM", 2) -CMSG_BARE_CONTENT_PARAM = make_flag("CMSG_BARE_CONTENT_PARAM", 3) -CMSG_INNER_CONTENT_TYPE_PARAM = make_flag("CMSG_INNER_CONTENT_TYPE_PARAM", 4) -CMSG_SIGNER_COUNT_PARAM = make_flag("CMSG_SIGNER_COUNT_PARAM", 5) -CMSG_SIGNER_INFO_PARAM = make_flag("CMSG_SIGNER_INFO_PARAM", 6) -CMSG_SIGNER_CERT_INFO_PARAM = make_flag("CMSG_SIGNER_CERT_INFO_PARAM", 7) -CMSG_SIGNER_HASH_ALGORITHM_PARAM = make_flag("CMSG_SIGNER_HASH_ALGORITHM_PARAM", 8) -CMSG_SIGNER_AUTH_ATTR_PARAM = make_flag("CMSG_SIGNER_AUTH_ATTR_PARAM", 9) -CMSG_SIGNER_UNAUTH_ATTR_PARAM = make_flag("CMSG_SIGNER_UNAUTH_ATTR_PARAM", 10) -CMSG_CERT_COUNT_PARAM = make_flag("CMSG_CERT_COUNT_PARAM", 11) -CMSG_CERT_PARAM = make_flag("CMSG_CERT_PARAM", 12) -CMSG_CRL_COUNT_PARAM = make_flag("CMSG_CRL_COUNT_PARAM", 13) -CMSG_CRL_PARAM = make_flag("CMSG_CRL_PARAM", 14) -CMSG_ENVELOPE_ALGORITHM_PARAM = make_flag("CMSG_ENVELOPE_ALGORITHM_PARAM", 15) -CMSG_RECIPIENT_COUNT_PARAM = make_flag("CMSG_RECIPIENT_COUNT_PARAM", 17) -CMSG_RECIPIENT_INDEX_PARAM = make_flag("CMSG_RECIPIENT_INDEX_PARAM", 18) -CMSG_RECIPIENT_INFO_PARAM = make_flag("CMSG_RECIPIENT_INFO_PARAM", 19) -CMSG_HASH_ALGORITHM_PARAM = make_flag("CMSG_HASH_ALGORITHM_PARAM", 20) -CMSG_HASH_DATA_PARAM = make_flag("CMSG_HASH_DATA_PARAM", 21) -CMSG_COMPUTED_HASH_PARAM = make_flag("CMSG_COMPUTED_HASH_PARAM", 22) -CMSG_ENCRYPT_PARAM = make_flag("CMSG_ENCRYPT_PARAM", 26) -CMSG_ENCRYPTED_DIGEST = make_flag("CMSG_ENCRYPTED_DIGEST", 27) -CMSG_ENCODED_SIGNER = make_flag("CMSG_ENCODED_SIGNER", 28) -CMSG_ENCODED_MESSAGE = make_flag("CMSG_ENCODED_MESSAGE", 29) -CMSG_VERSION_PARAM = make_flag("CMSG_VERSION_PARAM", 30) -CMSG_ATTR_CERT_COUNT_PARAM = make_flag("CMSG_ATTR_CERT_COUNT_PARAM", 31) -CMSG_ATTR_CERT_PARAM = make_flag("CMSG_ATTR_CERT_PARAM", 32) -CMSG_CMS_RECIPIENT_COUNT_PARAM = make_flag("CMSG_CMS_RECIPIENT_COUNT_PARAM", 33) -CMSG_CMS_RECIPIENT_INDEX_PARAM = make_flag("CMSG_CMS_RECIPIENT_INDEX_PARAM", 34) -CMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAM = make_flag("CMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAM", 35) -CMSG_CMS_RECIPIENT_INFO_PARAM = make_flag("CMSG_CMS_RECIPIENT_INFO_PARAM", 36) -CMSG_UNPROTECTED_ATTR_PARAM = make_flag("CMSG_UNPROTECTED_ATTR_PARAM", 37) -CMSG_SIGNER_CERT_ID_PARAM = make_flag("CMSG_SIGNER_CERT_ID_PARAM", 38) -CMSG_CMS_SIGNER_INFO_PARAM = make_flag("CMSG_CMS_SIGNER_INFO_PARAM", 39) -CERT_INFO_VERSION_FLAG = make_flag("CERT_INFO_VERSION_FLAG", 1) -CERT_INFO_SERIAL_NUMBER_FLAG = make_flag("CERT_INFO_SERIAL_NUMBER_FLAG", 2) -CERT_INFO_SIGNATURE_ALGORITHM_FLAG = make_flag("CERT_INFO_SIGNATURE_ALGORITHM_FLAG", 3) -CERT_INFO_ISSUER_FLAG = make_flag("CERT_INFO_ISSUER_FLAG", 4) -CERT_INFO_NOT_BEFORE_FLAG = make_flag("CERT_INFO_NOT_BEFORE_FLAG", 5) -CERT_INFO_NOT_AFTER_FLAG = make_flag("CERT_INFO_NOT_AFTER_FLAG", 6) -CERT_INFO_SUBJECT_FLAG = make_flag("CERT_INFO_SUBJECT_FLAG", 7) -CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG = make_flag("CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG", 8) -CERT_INFO_ISSUER_UNIQUE_ID_FLAG = make_flag("CERT_INFO_ISSUER_UNIQUE_ID_FLAG", 9) -CERT_INFO_SUBJECT_UNIQUE_ID_FLAG = make_flag("CERT_INFO_SUBJECT_UNIQUE_ID_FLAG", 10) -CERT_INFO_EXTENSION_FLAG = make_flag("CERT_INFO_EXTENSION_FLAG", 11) -CERT_FIND_ANY = make_flag("CERT_FIND_ANY", ( CERT_COMPARE_ANY << CERT_COMPARE_SHIFT )) -CERT_FIND_SHA1_HASH = make_flag("CERT_FIND_SHA1_HASH", ( CERT_COMPARE_SHA1_HASH << CERT_COMPARE_SHIFT )) -CERT_FIND_MD5_HASH = make_flag("CERT_FIND_MD5_HASH", ( CERT_COMPARE_MD5_HASH << CERT_COMPARE_SHIFT )) -CERT_FIND_SIGNATURE_HASH = make_flag("CERT_FIND_SIGNATURE_HASH", ( CERT_COMPARE_SIGNATURE_HASH << CERT_COMPARE_SHIFT )) -CERT_FIND_KEY_IDENTIFIER = make_flag("CERT_FIND_KEY_IDENTIFIER", ( CERT_COMPARE_KEY_IDENTIFIER << CERT_COMPARE_SHIFT )) -CERT_FIND_HASH = make_flag("CERT_FIND_HASH", CERT_FIND_SHA1_HASH) -CERT_FIND_PROPERTY = make_flag("CERT_FIND_PROPERTY", ( CERT_COMPARE_PROPERTY << CERT_COMPARE_SHIFT )) -CERT_FIND_PUBLIC_KEY = make_flag("CERT_FIND_PUBLIC_KEY", ( CERT_COMPARE_PUBLIC_KEY << CERT_COMPARE_SHIFT )) -CERT_FIND_SUBJECT_NAME = make_flag("CERT_FIND_SUBJECT_NAME", ( CERT_COMPARE_NAME << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG )) -CERT_FIND_SUBJECT_ATTR = make_flag("CERT_FIND_SUBJECT_ATTR", ( CERT_COMPARE_ATTR << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG )) -CERT_FIND_ISSUER_NAME = make_flag("CERT_FIND_ISSUER_NAME", ( CERT_COMPARE_NAME << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG )) -CERT_FIND_ISSUER_ATTR = make_flag("CERT_FIND_ISSUER_ATTR", ( CERT_COMPARE_ATTR << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG )) -CERT_FIND_SUBJECT_STR_A = make_flag("CERT_FIND_SUBJECT_STR_A", ( CERT_COMPARE_NAME_STR_A << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG )) -CERT_FIND_SUBJECT_STR_W = make_flag("CERT_FIND_SUBJECT_STR_W", ( CERT_COMPARE_NAME_STR_W << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG )) -CERT_FIND_SUBJECT_STR = make_flag("CERT_FIND_SUBJECT_STR", CERT_FIND_SUBJECT_STR_W) -CERT_FIND_ISSUER_STR_A = make_flag("CERT_FIND_ISSUER_STR_A", ( CERT_COMPARE_NAME_STR_A << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG )) -CERT_FIND_ISSUER_STR_W = make_flag("CERT_FIND_ISSUER_STR_W", ( CERT_COMPARE_NAME_STR_W << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG )) -CERT_FIND_ISSUER_STR = make_flag("CERT_FIND_ISSUER_STR", CERT_FIND_ISSUER_STR_W) -CERT_FIND_KEY_SPEC = make_flag("CERT_FIND_KEY_SPEC", ( CERT_COMPARE_KEY_SPEC << CERT_COMPARE_SHIFT )) -CERT_FIND_ENHKEY_USAGE = make_flag("CERT_FIND_ENHKEY_USAGE", ( CERT_COMPARE_ENHKEY_USAGE << CERT_COMPARE_SHIFT )) -CERT_FIND_CTL_USAGE = make_flag("CERT_FIND_CTL_USAGE", CERT_FIND_ENHKEY_USAGE) -CERT_FIND_SUBJECT_CERT = make_flag("CERT_FIND_SUBJECT_CERT", ( CERT_COMPARE_SUBJECT_CERT << CERT_COMPARE_SHIFT )) -CERT_FIND_ISSUER_OF = make_flag("CERT_FIND_ISSUER_OF", ( CERT_COMPARE_ISSUER_OF << CERT_COMPARE_SHIFT )) -CERT_FIND_EXISTING = make_flag("CERT_FIND_EXISTING", ( CERT_COMPARE_EXISTING << CERT_COMPARE_SHIFT )) -CERT_FIND_CERT_ID = make_flag("CERT_FIND_CERT_ID", ( CERT_COMPARE_CERT_ID << CERT_COMPARE_SHIFT )) -CERT_FIND_CROSS_CERT_DIST_POINTS = make_flag("CERT_FIND_CROSS_CERT_DIST_POINTS", ( CERT_COMPARE_CROSS_CERT_DIST_POINTS << CERT_COMPARE_SHIFT )) -CERT_FIND_PUBKEY_MD5_HASH = make_flag("CERT_FIND_PUBKEY_MD5_HASH", ( CERT_COMPARE_PUBKEY_MD5_HASH << CERT_COMPARE_SHIFT )) -CERT_FIND_SUBJECT_INFO_ACCESS = make_flag("CERT_FIND_SUBJECT_INFO_ACCESS", ( CERT_COMPARE_SUBJECT_INFO_ACCESS << CERT_COMPARE_SHIFT )) -CERT_NAME_EMAIL_TYPE = make_flag("CERT_NAME_EMAIL_TYPE", 1) -CERT_NAME_RDN_TYPE = make_flag("CERT_NAME_RDN_TYPE", 2) -CERT_NAME_ATTR_TYPE = make_flag("CERT_NAME_ATTR_TYPE", 3) -CERT_NAME_SIMPLE_DISPLAY_TYPE = make_flag("CERT_NAME_SIMPLE_DISPLAY_TYPE", 4) -CERT_NAME_FRIENDLY_DISPLAY_TYPE = make_flag("CERT_NAME_FRIENDLY_DISPLAY_TYPE", 5) -CERT_NAME_DNS_TYPE = make_flag("CERT_NAME_DNS_TYPE", 6) -CERT_NAME_URL_TYPE = make_flag("CERT_NAME_URL_TYPE", 7) -CERT_NAME_UPN_TYPE = make_flag("CERT_NAME_UPN_TYPE", 8) -CERT_KEY_PROV_HANDLE_PROP_ID = make_flag("CERT_KEY_PROV_HANDLE_PROP_ID", 1) -CERT_KEY_PROV_INFO_PROP_ID = make_flag("CERT_KEY_PROV_INFO_PROP_ID", 2) -CERT_SHA1_HASH_PROP_ID = make_flag("CERT_SHA1_HASH_PROP_ID", 3) -CERT_MD5_HASH_PROP_ID = make_flag("CERT_MD5_HASH_PROP_ID", 4) -CERT_HASH_PROP_ID = make_flag("CERT_HASH_PROP_ID", CERT_SHA1_HASH_PROP_ID) -CERT_KEY_CONTEXT_PROP_ID = make_flag("CERT_KEY_CONTEXT_PROP_ID", 5) -CERT_KEY_SPEC_PROP_ID = make_flag("CERT_KEY_SPEC_PROP_ID", 6) -CERT_IE30_RESERVED_PROP_ID = make_flag("CERT_IE30_RESERVED_PROP_ID", 7) -CERT_PUBKEY_HASH_RESERVED_PROP_ID = make_flag("CERT_PUBKEY_HASH_RESERVED_PROP_ID", 8) -CERT_ENHKEY_USAGE_PROP_ID = make_flag("CERT_ENHKEY_USAGE_PROP_ID", 9) -CERT_CTL_USAGE_PROP_ID = make_flag("CERT_CTL_USAGE_PROP_ID", CERT_ENHKEY_USAGE_PROP_ID) -CERT_NEXT_UPDATE_LOCATION_PROP_ID = make_flag("CERT_NEXT_UPDATE_LOCATION_PROP_ID", 10) -CERT_FRIENDLY_NAME_PROP_ID = make_flag("CERT_FRIENDLY_NAME_PROP_ID", 11) -CERT_PVK_FILE_PROP_ID = make_flag("CERT_PVK_FILE_PROP_ID", 12) -CERT_DESCRIPTION_PROP_ID = make_flag("CERT_DESCRIPTION_PROP_ID", 13) -CERT_ACCESS_STATE_PROP_ID = make_flag("CERT_ACCESS_STATE_PROP_ID", 14) -CERT_SIGNATURE_HASH_PROP_ID = make_flag("CERT_SIGNATURE_HASH_PROP_ID", 15) -CERT_SMART_CARD_DATA_PROP_ID = make_flag("CERT_SMART_CARD_DATA_PROP_ID", 16) -CERT_EFS_PROP_ID = make_flag("CERT_EFS_PROP_ID", 17) -CERT_FORTEZZA_DATA_PROP_ID = make_flag("CERT_FORTEZZA_DATA_PROP_ID", 18) -CERT_ARCHIVED_PROP_ID = make_flag("CERT_ARCHIVED_PROP_ID", 19) -CERT_KEY_IDENTIFIER_PROP_ID = make_flag("CERT_KEY_IDENTIFIER_PROP_ID", 20) -CERT_AUTO_ENROLL_PROP_ID = make_flag("CERT_AUTO_ENROLL_PROP_ID", 21) -CERT_PUBKEY_ALG_PARA_PROP_ID = make_flag("CERT_PUBKEY_ALG_PARA_PROP_ID", 22) -CERT_CROSS_CERT_DIST_POINTS_PROP_ID = make_flag("CERT_CROSS_CERT_DIST_POINTS_PROP_ID", 23) -CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID = make_flag("CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID", 24) -CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID = make_flag("CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID", 25) -CERT_ENROLLMENT_PROP_ID = make_flag("CERT_ENROLLMENT_PROP_ID", 26) -CERT_DATE_STAMP_PROP_ID = make_flag("CERT_DATE_STAMP_PROP_ID", 27) -CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID = make_flag("CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID", 28) -CERT_SUBJECT_NAME_MD5_HASH_PROP_ID = make_flag("CERT_SUBJECT_NAME_MD5_HASH_PROP_ID", 29) -CERT_EXTENDED_ERROR_INFO_PROP_ID = make_flag("CERT_EXTENDED_ERROR_INFO_PROP_ID", 30) -CERT_RENEWAL_PROP_ID = make_flag("CERT_RENEWAL_PROP_ID", 64) -CERT_ARCHIVED_KEY_HASH_PROP_ID = make_flag("CERT_ARCHIVED_KEY_HASH_PROP_ID", 65) -CERT_AUTO_ENROLL_RETRY_PROP_ID = make_flag("CERT_AUTO_ENROLL_RETRY_PROP_ID", 66) -CERT_AIA_URL_RETRIEVED_PROP_ID = make_flag("CERT_AIA_URL_RETRIEVED_PROP_ID", 67) -CERT_AUTHORITY_INFO_ACCESS_PROP_ID = make_flag("CERT_AUTHORITY_INFO_ACCESS_PROP_ID", 68) -CERT_BACKED_UP_PROP_ID = make_flag("CERT_BACKED_UP_PROP_ID", 69) -CERT_OCSP_RESPONSE_PROP_ID = make_flag("CERT_OCSP_RESPONSE_PROP_ID", 70) -CERT_REQUEST_ORIGINATOR_PROP_ID = make_flag("CERT_REQUEST_ORIGINATOR_PROP_ID", 71) -CERT_SOURCE_LOCATION_PROP_ID = make_flag("CERT_SOURCE_LOCATION_PROP_ID", 72) -CRYPT_ACQUIRE_CACHE_FLAG = make_flag("CRYPT_ACQUIRE_CACHE_FLAG", 0x00000001) -CRYPT_ACQUIRE_USE_PROV_INFO_FLAG = make_flag("CRYPT_ACQUIRE_USE_PROV_INFO_FLAG", 0x00000002) -CRYPT_ACQUIRE_COMPARE_KEY_FLAG = make_flag("CRYPT_ACQUIRE_COMPARE_KEY_FLAG", 0x00000004) -CRYPT_ACQUIRE_NO_HEALING = make_flag("CRYPT_ACQUIRE_NO_HEALING", 0x00000008) -CRYPT_ACQUIRE_SILENT_FLAG = make_flag("CRYPT_ACQUIRE_SILENT_FLAG", 0x00000040) -CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK = make_flag("CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK", 0x00070000) -CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG = make_flag("CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG", 0x00010000) -CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG = make_flag("CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG", 0x00020000) -CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG = make_flag("CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG", 0x00040000) -CERT_STORE_PROV_MSG = make_flag("CERT_STORE_PROV_MSG", ( 1 )) -CERT_STORE_PROV_MEMORY = make_flag("CERT_STORE_PROV_MEMORY", ( 2 )) -CERT_STORE_PROV_FILE = make_flag("CERT_STORE_PROV_FILE", ( 3 )) -CERT_STORE_PROV_REG = make_flag("CERT_STORE_PROV_REG", ( 4 )) -CERT_STORE_PROV_PKCS7 = make_flag("CERT_STORE_PROV_PKCS7", ( 5 )) -CERT_STORE_PROV_SERIALIZED = make_flag("CERT_STORE_PROV_SERIALIZED", ( 6 )) -CERT_STORE_PROV_FILENAME_A = make_flag("CERT_STORE_PROV_FILENAME_A", ( 7 )) -CERT_STORE_PROV_FILENAME_W = make_flag("CERT_STORE_PROV_FILENAME_W", ( 8 )) -CERT_STORE_PROV_FILENAME = make_flag("CERT_STORE_PROV_FILENAME", CERT_STORE_PROV_FILENAME_W) -CERT_STORE_PROV_SYSTEM_A = make_flag("CERT_STORE_PROV_SYSTEM_A", ( 9 )) -CERT_STORE_PROV_SYSTEM_W = make_flag("CERT_STORE_PROV_SYSTEM_W", ( 10 )) -CERT_STORE_PROV_SYSTEM = make_flag("CERT_STORE_PROV_SYSTEM", CERT_STORE_PROV_SYSTEM_W) -CERT_STORE_PROV_COLLECTION = make_flag("CERT_STORE_PROV_COLLECTION", ( 11 )) -CERT_STORE_PROV_SYSTEM_REGISTRY_A = make_flag("CERT_STORE_PROV_SYSTEM_REGISTRY_A", ( 12 )) -CERT_STORE_PROV_SYSTEM_REGISTRY_W = make_flag("CERT_STORE_PROV_SYSTEM_REGISTRY_W", ( 13 )) -CERT_STORE_PROV_SYSTEM_REGISTRY = make_flag("CERT_STORE_PROV_SYSTEM_REGISTRY", CERT_STORE_PROV_SYSTEM_REGISTRY_W) -CERT_STORE_PROV_PHYSICAL_W = make_flag("CERT_STORE_PROV_PHYSICAL_W", ( 14 )) -CERT_STORE_PROV_PHYSICAL = make_flag("CERT_STORE_PROV_PHYSICAL", CERT_STORE_PROV_PHYSICAL_W) -CERT_STORE_PROV_SMART_CARD_W = make_flag("CERT_STORE_PROV_SMART_CARD_W", ( 15 )) -CERT_STORE_PROV_SMART_CARD = make_flag("CERT_STORE_PROV_SMART_CARD", CERT_STORE_PROV_SMART_CARD_W) -CERT_STORE_PROV_LDAP_W = make_flag("CERT_STORE_PROV_LDAP_W", ( 16 )) -CERT_STORE_PROV_LDAP = make_flag("CERT_STORE_PROV_LDAP", CERT_STORE_PROV_LDAP_W) -CERT_STORE_PROV_PKCS12 = make_flag("CERT_STORE_PROV_PKCS12", ( 17 )) +szOID_TRUSTED_CODESIGNING_CA_LIST = make_flag("szOID_TRUSTED_CODESIGNING_CA_LIST", "1.3.6.1.4.1.311.2.2.1") +szOID_TRUSTED_CLIENT_AUTH_CA_LIST = make_flag("szOID_TRUSTED_CLIENT_AUTH_CA_LIST", "1.3.6.1.4.1.311.2.2.2") +szOID_TRUSTED_SERVER_AUTH_CA_LIST = make_flag("szOID_TRUSTED_SERVER_AUTH_CA_LIST", "1.3.6.1.4.1.311.2.2.3") szOID_RSA = make_flag("szOID_RSA", "1.2.840.113549") szOID_PKCS = make_flag("szOID_PKCS", "1.2.840.113549.1") szOID_RSA_HASH = make_flag("szOID_RSA_HASH", "1.2.840.113549.2") @@ -1185,224 +2540,129 @@ szOID_INFOSEC_mosaicUpdatedInteg = make_flag("szOID_INFOSEC_mosaicUpdatedInteg", szOID_NIST_sha256 = make_flag("szOID_NIST_sha256", "2.16.840.1.101.3.4.2.1") szOID_NIST_sha384 = make_flag("szOID_NIST_sha384", "2.16.840.1.101.3.4.2.2") szOID_NIST_sha512 = make_flag("szOID_NIST_sha512", "2.16.840.1.101.3.4.2.3") -CRYPT_E_NOT_FOUND = make_flag("CRYPT_E_NOT_FOUND", ( 0x80092004 )) -CERT_STORE_NO_CRYPT_RELEASE_FLAG = make_flag("CERT_STORE_NO_CRYPT_RELEASE_FLAG", 0x00000001) -CERT_STORE_SET_LOCALIZED_NAME_FLAG = make_flag("CERT_STORE_SET_LOCALIZED_NAME_FLAG", 0x00000002) -CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG = make_flag("CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG", 0x00000004) -CERT_STORE_DELETE_FLAG = make_flag("CERT_STORE_DELETE_FLAG", 0x00000010) -CERT_STORE_UNSAFE_PHYSICAL_FLAG = make_flag("CERT_STORE_UNSAFE_PHYSICAL_FLAG", 0x00000020) -CERT_STORE_SHARE_STORE_FLAG = make_flag("CERT_STORE_SHARE_STORE_FLAG", 0x00000040) -CERT_STORE_SHARE_CONTEXT_FLAG = make_flag("CERT_STORE_SHARE_CONTEXT_FLAG", 0x00000080) -CERT_STORE_MANIFOLD_FLAG = make_flag("CERT_STORE_MANIFOLD_FLAG", 0x00000100) -CERT_STORE_ENUM_ARCHIVED_FLAG = make_flag("CERT_STORE_ENUM_ARCHIVED_FLAG", 0x00000200) -CERT_STORE_UPDATE_KEYID_FLAG = make_flag("CERT_STORE_UPDATE_KEYID_FLAG", 0x00000400) -CERT_STORE_BACKUP_RESTORE_FLAG = make_flag("CERT_STORE_BACKUP_RESTORE_FLAG", 0x00000800) -CERT_STORE_READONLY_FLAG = make_flag("CERT_STORE_READONLY_FLAG", 0x00008000) -CERT_STORE_OPEN_EXISTING_FLAG = make_flag("CERT_STORE_OPEN_EXISTING_FLAG", 0x00004000) -CERT_STORE_CREATE_NEW_FLAG = make_flag("CERT_STORE_CREATE_NEW_FLAG", 0x00002000) -CERT_STORE_MAXIMUM_ALLOWED_FLAG = make_flag("CERT_STORE_MAXIMUM_ALLOWED_FLAG", 0x00001000) -CRYPT_USER_KEYSET = make_flag("CRYPT_USER_KEYSET", 0x00001000) -PKCS12_PREFER_CNG_KSP = make_flag("PKCS12_PREFER_CNG_KSP", 0x00000100) -PKCS12_ALWAYS_CNG_KSP = make_flag("PKCS12_ALWAYS_CNG_KSP", 0x00000200) -PKCS12_ALLOW_OVERWRITE_KEY = make_flag("PKCS12_ALLOW_OVERWRITE_KEY", 0x00004000) -PKCS12_NO_PERSIST_KEY = make_flag("PKCS12_NO_PERSIST_KEY", 0x00008000) -CRYPT_VERIFYCONTEXT = make_flag("CRYPT_VERIFYCONTEXT", 0xF0000000) -CRYPT_NEWKEYSET = make_flag("CRYPT_NEWKEYSET", 0x00000008) -CRYPT_DELETEKEYSET = make_flag("CRYPT_DELETEKEYSET", 0x00000010) -CRYPT_MACHINE_KEYSET = make_flag("CRYPT_MACHINE_KEYSET", 0x00000020) -CRYPT_SILENT = make_flag("CRYPT_SILENT", 0x00000040) -CRYPT_DEFAULT_CONTAINER_OPTIONAL = make_flag("CRYPT_DEFAULT_CONTAINER_OPTIONAL", 0x00000080) -CRYPT_EXPORTABLE = make_flag("CRYPT_EXPORTABLE", 0x00000001) -CRYPT_USER_PROTECTED = make_flag("CRYPT_USER_PROTECTED", 0x00000002) -CRYPT_CREATE_SALT = make_flag("CRYPT_CREATE_SALT", 0x00000004) -CRYPT_UPDATE_KEY = make_flag("CRYPT_UPDATE_KEY", 0x00000008) -CRYPT_NO_SALT = make_flag("CRYPT_NO_SALT", 0x00000010) -CRYPT_PREGEN = make_flag("CRYPT_PREGEN", 0x00000040) -CRYPT_RECIPIENT = make_flag("CRYPT_RECIPIENT", 0x00000010) -CRYPT_INITIATOR = make_flag("CRYPT_INITIATOR", 0x00000040) -CRYPT_ONLINE = make_flag("CRYPT_ONLINE", 0x00000080) -CRYPT_SF = make_flag("CRYPT_SF", 0x00000100) -CRYPT_CREATE_IV = make_flag("CRYPT_CREATE_IV", 0x00000200) -CRYPT_KEK = make_flag("CRYPT_KEK", 0x00000400) -CRYPT_DATA_KEY = make_flag("CRYPT_DATA_KEY", 0x00000800) -CRYPT_VOLATILE = make_flag("CRYPT_VOLATILE", 0x00001000) -CRYPT_SGCKEY = make_flag("CRYPT_SGCKEY", 0x00002000) -CRYPT_ARCHIVABLE = make_flag("CRYPT_ARCHIVABLE", 0x00004000) -CRYPT_FORCE_KEY_PROTECTION_HIGH = make_flag("CRYPT_FORCE_KEY_PROTECTION_HIGH", 0x00008000) -CRYPT_ENCODE_DECODE_NONE = make_flag("CRYPT_ENCODE_DECODE_NONE", 0) -X509_CERT = make_flag("X509_CERT", ( 1 )) -X509_CERT_TO_BE_SIGNED = make_flag("X509_CERT_TO_BE_SIGNED", ( 2 )) -X509_CERT_CRL_TO_BE_SIGNED = make_flag("X509_CERT_CRL_TO_BE_SIGNED", ( 3 )) -X509_CERT_REQUEST_TO_BE_SIGNED = make_flag("X509_CERT_REQUEST_TO_BE_SIGNED", ( 4 )) -X509_EXTENSIONS = make_flag("X509_EXTENSIONS", ( 5 )) -X509_NAME_VALUE = make_flag("X509_NAME_VALUE", ( 6 )) -X509_NAME = make_flag("X509_NAME", ( 7 )) -X509_PUBLIC_KEY_INFO = make_flag("X509_PUBLIC_KEY_INFO", ( 8 )) -X509_AUTHORITY_KEY_ID = make_flag("X509_AUTHORITY_KEY_ID", ( 9 )) -X509_KEY_ATTRIBUTES = make_flag("X509_KEY_ATTRIBUTES", ( 10 )) -X509_KEY_USAGE_RESTRICTION = make_flag("X509_KEY_USAGE_RESTRICTION", ( 11 )) -X509_ALTERNATE_NAME = make_flag("X509_ALTERNATE_NAME", ( 12 )) -X509_BASIC_CONSTRAINTS = make_flag("X509_BASIC_CONSTRAINTS", ( 13 )) -X509_KEY_USAGE = make_flag("X509_KEY_USAGE", ( 14 )) -X509_BASIC_CONSTRAINTS2 = make_flag("X509_BASIC_CONSTRAINTS2", ( 15 )) -X509_CERT_POLICIES = make_flag("X509_CERT_POLICIES", ( 16 )) -PKCS_UTC_TIME = make_flag("PKCS_UTC_TIME", ( 17 )) -PKCS_TIME_REQUEST = make_flag("PKCS_TIME_REQUEST", ( 18 )) -RSA_CSP_PUBLICKEYBLOB = make_flag("RSA_CSP_PUBLICKEYBLOB", ( 19 )) -X509_UNICODE_NAME = make_flag("X509_UNICODE_NAME", ( 20 )) -X509_KEYGEN_REQUEST_TO_BE_SIGNED = make_flag("X509_KEYGEN_REQUEST_TO_BE_SIGNED", ( 21 )) -PKCS_ATTRIBUTE = make_flag("PKCS_ATTRIBUTE", ( 22 )) -PKCS_CONTENT_INFO_SEQUENCE_OF_ANY = make_flag("PKCS_CONTENT_INFO_SEQUENCE_OF_ANY", ( 23 )) -X509_UNICODE_NAME_VALUE = make_flag("X509_UNICODE_NAME_VALUE", ( 24 )) -X509_ANY_STRING = make_flag("X509_ANY_STRING", X509_NAME_VALUE) -X509_UNICODE_ANY_STRING = make_flag("X509_UNICODE_ANY_STRING", X509_UNICODE_NAME_VALUE) -X509_OCTET_STRING = make_flag("X509_OCTET_STRING", ( 25 )) -X509_BITS = make_flag("X509_BITS", ( 26 )) -X509_INTEGER = make_flag("X509_INTEGER", ( 27 )) -X509_MULTI_BYTE_INTEGER = make_flag("X509_MULTI_BYTE_INTEGER", ( 28 )) -X509_ENUMERATED = make_flag("X509_ENUMERATED", ( 29 )) -X509_CHOICE_OF_TIME = make_flag("X509_CHOICE_OF_TIME", ( 30 )) -CERT_SIMPLE_NAME_STR = make_flag("CERT_SIMPLE_NAME_STR", 1) -CERT_OID_NAME_STR = make_flag("CERT_OID_NAME_STR", 2) -CERT_X500_NAME_STR = make_flag("CERT_X500_NAME_STR", 3) -CERT_XML_NAME_STR = make_flag("CERT_XML_NAME_STR", 4) -AT_KEYEXCHANGE = make_flag("AT_KEYEXCHANGE", 1) -AT_SIGNATURE = make_flag("AT_SIGNATURE", 2) -MS_DEF_PROV_A = make_flag("MS_DEF_PROV_A", "Microsoft Base Cryptographic Provider v1.0") -MS_DEF_PROV_W = make_flag("MS_DEF_PROV_W", u"Microsoft Base Cryptographic Provider v1.0") -MS_DEF_PROV = make_flag("MS_DEF_PROV", MS_DEF_PROV_A) -MS_ENHANCED_PROV_A = make_flag("MS_ENHANCED_PROV_A", "Microsoft Enhanced Cryptographic Provider v1.0") -MS_ENHANCED_PROV_W = make_flag("MS_ENHANCED_PROV_W", u"Microsoft Enhanced Cryptographic Provider v1.0") -MS_ENHANCED_PROV = make_flag("MS_ENHANCED_PROV", MS_ENHANCED_PROV_A) -MS_STRONG_PROV_A = make_flag("MS_STRONG_PROV_A", "Microsoft Strong Cryptographic Provider") -MS_STRONG_PROV_W = make_flag("MS_STRONG_PROV_W", u"Microsoft Strong Cryptographic Provider") -MS_STRONG_PROV = make_flag("MS_STRONG_PROV", MS_STRONG_PROV_A) -MS_DEF_RSA_SIG_PROV_A = make_flag("MS_DEF_RSA_SIG_PROV_A", "Microsoft RSA Signature Cryptographic Provider") -MS_DEF_RSA_SIG_PROV_W = make_flag("MS_DEF_RSA_SIG_PROV_W", u"Microsoft RSA Signature Cryptographic Provider") -MS_DEF_RSA_SIG_PROV = make_flag("MS_DEF_RSA_SIG_PROV", MS_DEF_RSA_SIG_PROV_A) -MS_ENH_RSA_AES_PROV_A = make_flag("MS_ENH_RSA_AES_PROV_A", "Microsoft Enhanced RSA and AES Cryptographic Provider") -MS_ENH_RSA_AES_PROV_W = make_flag("MS_ENH_RSA_AES_PROV_W", u"Microsoft Enhanced RSA and AES Cryptographic Provider") -MS_ENH_RSA_AES_PROV_XP_A = make_flag("MS_ENH_RSA_AES_PROV_XP_A", "Microsoft Enhanced RSA and AES Cryptographic Provider ( Prototype ) ") -MS_ENH_RSA_AES_PROV_XP_W = make_flag("MS_ENH_RSA_AES_PROV_XP_W", u"Microsoft Enhanced RSA and AES Cryptographic Provider ( Prototype ) ") -CERT_STORE_ADD_NEW = make_flag("CERT_STORE_ADD_NEW", 1) -CERT_STORE_ADD_USE_EXISTING = make_flag("CERT_STORE_ADD_USE_EXISTING", 2) -CERT_STORE_ADD_REPLACE_EXISTING = make_flag("CERT_STORE_ADD_REPLACE_EXISTING", 3) -CERT_STORE_ADD_ALWAYS = make_flag("CERT_STORE_ADD_ALWAYS", 4) -CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES = make_flag("CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES", 5) -CERT_STORE_ADD_NEWER = make_flag("CERT_STORE_ADD_NEWER", 6) -CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES = make_flag("CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES", 7) -PROV_RSA_FULL = make_flag("PROV_RSA_FULL", 1) -PROV_RSA_SIG = make_flag("PROV_RSA_SIG", 2) -PROV_DSS = make_flag("PROV_DSS", 3) -PROV_FORTEZZA = make_flag("PROV_FORTEZZA", 4) -PROV_MS_EXCHANGE = make_flag("PROV_MS_EXCHANGE", 5) -PROV_SSL = make_flag("PROV_SSL", 6) -PROV_RSA_SCHANNEL = make_flag("PROV_RSA_SCHANNEL", 12) -PROV_DSS_DH = make_flag("PROV_DSS_DH", 13) -PROV_EC_ECDSA_SIG = make_flag("PROV_EC_ECDSA_SIG", 14) -PROV_EC_ECNRA_SIG = make_flag("PROV_EC_ECNRA_SIG", 15) -PROV_EC_ECDSA_FULL = make_flag("PROV_EC_ECDSA_FULL", 16) -PROV_EC_ECNRA_FULL = make_flag("PROV_EC_ECNRA_FULL", 17) -PROV_DH_SCHANNEL = make_flag("PROV_DH_SCHANNEL", 18) -PROV_SPYRUS_LYNKS = make_flag("PROV_SPYRUS_LYNKS", 20) -PROV_RNG = make_flag("PROV_RNG", 21) -PROV_INTEL_SEC = make_flag("PROV_INTEL_SEC", 22) -PROV_REPLACE_OWF = make_flag("PROV_REPLACE_OWF", 23) -PROV_RSA_AES = make_flag("PROV_RSA_AES", 24) -REPORT_NO_PRIVATE_KEY = make_flag("REPORT_NO_PRIVATE_KEY", 0x0001) -REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY = make_flag("REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY", 0x0002) -EXPORT_PRIVATE_KEYS = make_flag("EXPORT_PRIVATE_KEYS", 0x0004) -PKCS12_INCLUDE_EXTENDED_PROPERTIES = make_flag("PKCS12_INCLUDE_EXTENDED_PROPERTIES", 0x0010) -PKCS12_EXPORT_RESERVED_MASK = make_flag("PKCS12_EXPORT_RESERVED_MASK", 0xffff0000) -CERT_SYSTEM_STORE_UNPROTECTED_FLAG = make_flag("CERT_SYSTEM_STORE_UNPROTECTED_FLAG", 0x40000000) -CERT_SYSTEM_STORE_LOCATION_MASK = make_flag("CERT_SYSTEM_STORE_LOCATION_MASK", 0x00FF0000) -CERT_SYSTEM_STORE_LOCATION_SHIFT = make_flag("CERT_SYSTEM_STORE_LOCATION_SHIFT", 16) -CERT_SYSTEM_STORE_CURRENT_USER_ID = make_flag("CERT_SYSTEM_STORE_CURRENT_USER_ID", 1) -CERT_SYSTEM_STORE_LOCAL_MACHINE_ID = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE_ID", 2) -CERT_SYSTEM_STORE_CURRENT_SERVICE_ID = make_flag("CERT_SYSTEM_STORE_CURRENT_SERVICE_ID", 4) -CERT_SYSTEM_STORE_SERVICES_ID = make_flag("CERT_SYSTEM_STORE_SERVICES_ID", 5) -CERT_SYSTEM_STORE_USERS_ID = make_flag("CERT_SYSTEM_STORE_USERS_ID", 6) -CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID = make_flag("CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID", 7) -CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID", 8) -CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID", 9) -CERT_SYSTEM_STORE_CURRENT_USER = make_flag("CERT_SYSTEM_STORE_CURRENT_USER", ( CERT_SYSTEM_STORE_CURRENT_USER_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) -CERT_SYSTEM_STORE_LOCAL_MACHINE = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE", ( CERT_SYSTEM_STORE_LOCAL_MACHINE_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) -CERT_SYSTEM_STORE_CURRENT_SERVICE = make_flag("CERT_SYSTEM_STORE_CURRENT_SERVICE", ( CERT_SYSTEM_STORE_CURRENT_SERVICE_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) -CERT_SYSTEM_STORE_SERVICES = make_flag("CERT_SYSTEM_STORE_SERVICES", ( CERT_SYSTEM_STORE_SERVICES_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) -CERT_SYSTEM_STORE_USERS = make_flag("CERT_SYSTEM_STORE_USERS", ( CERT_SYSTEM_STORE_USERS_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) -CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY = make_flag("CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY", ( CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) -CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY", ( CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) -CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE = make_flag("CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE", ( CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT )) -CMSG_DATA = make_flag("CMSG_DATA", 1) -CMSG_SIGNED = make_flag("CMSG_SIGNED", 2) -CMSG_ENVELOPED = make_flag("CMSG_ENVELOPED", 3) -CMSG_SIGNED_AND_ENVELOPED = make_flag("CMSG_SIGNED_AND_ENVELOPED", 4) -CMSG_HASHED = make_flag("CMSG_HASHED", 5) -CMSG_ENCRYPTED = make_flag("CMSG_ENCRYPTED", 6) -CMSG_BARE_CONTENT_FLAG = make_flag("CMSG_BARE_CONTENT_FLAG", 0x00000001) -CMSG_LENGTH_ONLY_FLAG = make_flag("CMSG_LENGTH_ONLY_FLAG", 0x00000002) -CMSG_DETACHED_FLAG = make_flag("CMSG_DETACHED_FLAG", 0x00000004) -CMSG_AUTHENTICATED_ATTRIBUTES_FLAG = make_flag("CMSG_AUTHENTICATED_ATTRIBUTES_FLAG", 0x00000008) -CMSG_CONTENTS_OCTETS_FLAG = make_flag("CMSG_CONTENTS_OCTETS_FLAG", 0x00000010) -CMSG_MAX_LENGTH_FLAG = make_flag("CMSG_MAX_LENGTH_FLAG", 0x00000020) -CMSG_CMS_ENCAPSULATED_CONTENT_FLAG = make_flag("CMSG_CMS_ENCAPSULATED_CONTENT_FLAG", 0x00000040) -CMSG_CRYPT_RELEASE_CONTEXT_FLAG = make_flag("CMSG_CRYPT_RELEASE_CONTEXT_FLAG", 0x00008000) -CMSG_INDEFINITE_LENGTH = make_flag("CMSG_INDEFINITE_LENGTH", ( 0xFFFFFFFF )) -CMSG_CTRL_VERIFY_SIGNATURE = make_flag("CMSG_CTRL_VERIFY_SIGNATURE", 1) -CMSG_CTRL_DECRYPT = make_flag("CMSG_CTRL_DECRYPT", 2) -CMSG_CTRL_VERIFY_HASH = make_flag("CMSG_CTRL_VERIFY_HASH", 5) -CMSG_CTRL_ADD_SIGNER = make_flag("CMSG_CTRL_ADD_SIGNER", 6) -CMSG_CTRL_DEL_SIGNER = make_flag("CMSG_CTRL_DEL_SIGNER", 7) -CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR = make_flag("CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR", 8) -CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR = make_flag("CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR", 9) -CMSG_CTRL_ADD_CERT = make_flag("CMSG_CTRL_ADD_CERT", 10) -CMSG_CTRL_DEL_CERT = make_flag("CMSG_CTRL_DEL_CERT", 11) -CMSG_CTRL_ADD_CRL = make_flag("CMSG_CTRL_ADD_CRL", 12) -CMSG_CTRL_DEL_CRL = make_flag("CMSG_CTRL_DEL_CRL", 13) -CMSG_CTRL_ADD_ATTR_CERT = make_flag("CMSG_CTRL_ADD_ATTR_CERT", 14) -CMSG_CTRL_DEL_ATTR_CERT = make_flag("CMSG_CTRL_DEL_ATTR_CERT", 15) -CMSG_CTRL_KEY_TRANS_DECRYPT = make_flag("CMSG_CTRL_KEY_TRANS_DECRYPT", 16) -CMSG_CTRL_KEY_AGREE_DECRYPT = make_flag("CMSG_CTRL_KEY_AGREE_DECRYPT", 17) -CMSG_CTRL_MAIL_LIST_DECRYPT = make_flag("CMSG_CTRL_MAIL_LIST_DECRYPT", 18) -CMSG_CTRL_VERIFY_SIGNATURE_EX = make_flag("CMSG_CTRL_VERIFY_SIGNATURE_EX", 19) -CMSG_CTRL_ADD_CMS_SIGNER_INFO = make_flag("CMSG_CTRL_ADD_CMS_SIGNER_INFO", 20) -CMSG_CTRL_ENABLE_STRONG_SIGNATURE = make_flag("CMSG_CTRL_ENABLE_STRONG_SIGNATURE", 21) -OS_WINDOWS = make_flag("OS_WINDOWS", 0) -OS_NT = make_flag("OS_NT", 1) -OS_WIN95ORGREATER = make_flag("OS_WIN95ORGREATER", 2) -OS_NT4ORGREATER = make_flag("OS_NT4ORGREATER", 3) -OS_WIN98ORGREATER = make_flag("OS_WIN98ORGREATER", 5) -OS_WIN98_GOLD = make_flag("OS_WIN98_GOLD", 6) -OS_WIN2000ORGREATER = make_flag("OS_WIN2000ORGREATER", 7) -OS_WIN2000PRO = make_flag("OS_WIN2000PRO", 8) -OS_WIN2000SERVER = make_flag("OS_WIN2000SERVER", 9) -OS_WIN2000ADVSERVER = make_flag("OS_WIN2000ADVSERVER", 10) -OS_WIN2000DATACENTER = make_flag("OS_WIN2000DATACENTER", 11) -OS_WIN2000TERMINAL = make_flag("OS_WIN2000TERMINAL", 12) -OS_EMBEDDED = make_flag("OS_EMBEDDED", 13) -OS_TERMINALCLIENT = make_flag("OS_TERMINALCLIENT", 14) -OS_TERMINALREMOTEADMIN = make_flag("OS_TERMINALREMOTEADMIN", 15) -OS_WIN95_GOLD = make_flag("OS_WIN95_GOLD", 16) -OS_MEORGREATER = make_flag("OS_MEORGREATER", 17) -OS_XPORGREATER = make_flag("OS_XPORGREATER", 18) -OS_HOME = make_flag("OS_HOME", 19) -OS_PROFESSIONAL = make_flag("OS_PROFESSIONAL", 20) -OS_DATACENTER = make_flag("OS_DATACENTER", 21) -OS_ADVSERVER = make_flag("OS_ADVSERVER", 22) -OS_SERVER = make_flag("OS_SERVER", 23) -OS_TERMINALSERVER = make_flag("OS_TERMINALSERVER", 24) -OS_PERSONALTERMINALSERVER = make_flag("OS_PERSONALTERMINALSERVER", 25) -OS_FASTUSERSWITCHING = make_flag("OS_FASTUSERSWITCHING", 26) -OS_WELCOMELOGONUI = make_flag("OS_WELCOMELOGONUI", 27) -OS_DOMAINMEMBER = make_flag("OS_DOMAINMEMBER", 28) -OS_ANYSERVER = make_flag("OS_ANYSERVER", 29) -OS_WOW6432 = make_flag("OS_WOW6432", 30) -OS_WEBSERVER = make_flag("OS_WEBSERVER", 31) -OS_SMALLBUSINESSSERVER = make_flag("OS_SMALLBUSINESSSERVER", 32) -OS_TABLETPC = make_flag("OS_TABLETPC", 33) -OS_SERVERADMINUI = make_flag("OS_SERVERADMINUI", 34) -OS_MEDIACENTER = make_flag("OS_MEDIACENTER", 35) -OS_APPLIANCE = make_flag("OS_APPLIANCE", 36) +SPC_PE_IMAGE_PAGE_HASHES_V1_OBJID = make_flag("SPC_PE_IMAGE_PAGE_HASHES_V1_OBJID", "1.3.6.1.4.1.311.2.3.1") +SPC_PE_IMAGE_PAGE_HASHES_V2_OBJID = make_flag("SPC_PE_IMAGE_PAGE_HASHES_V2_OBJID", "1.3.6.1.4.1.311.2.3.2") +szOID_NESTED_SIGNATURE = make_flag("szOID_NESTED_SIGNATURE", "1.3.6.1.4.1.311.2.4.1") +szOID_INTENT_TO_SEAL = make_flag("szOID_INTENT_TO_SEAL", "1.3.6.1.4.1.311.2.4.2") +szOID_SEALING_SIGNATURE = make_flag("szOID_SEALING_SIGNATURE", "1.3.6.1.4.1.311.2.4.3") +szOID_SEALING_TIMESTAMP = make_flag("szOID_SEALING_TIMESTAMP", "1.3.6.1.4.1.311.2.4.4") +szOID_ENHANCED_HASH = make_flag("szOID_ENHANCED_HASH", "1.3.6.1.4.1.311.2.5.1") +szOID_PKCS_9_SEQUENCE_NUMBER = make_flag("szOID_PKCS_9_SEQUENCE_NUMBER", "1.2.840.113549.1.9.25.4") +CAT_NAMEVALUE_OBJID = make_flag("CAT_NAMEVALUE_OBJID", "1.3.6.1.4.1.311.12.2.1") +CAT_MEMBERINFO_OBJID = make_flag("CAT_MEMBERINFO_OBJID", "1.3.6.1.4.1.311.12.2.2") +CAT_MEMBERINFO2_OBJID = make_flag("CAT_MEMBERINFO2_OBJID", "1.3.6.1.4.1.311.12.2.3") +szOID_COMMON_NAME = make_flag("szOID_COMMON_NAME", "2.5.4.3") +SPC_COMMON_NAME_OBJID = make_flag("SPC_COMMON_NAME_OBJID", szOID_COMMON_NAME) +SPC_TIME_STAMP_REQUEST_OBJID = make_flag("SPC_TIME_STAMP_REQUEST_OBJID", "1.3.6.1.4.1.311.3.2.1") +SPC_INDIRECT_DATA_OBJID = make_flag("SPC_INDIRECT_DATA_OBJID", "1.3.6.1.4.1.311.2.1.4") +SPC_SP_AGENCY_INFO_OBJID = make_flag("SPC_SP_AGENCY_INFO_OBJID", "1.3.6.1.4.1.311.2.1.10") +SPC_STATEMENT_TYPE_OBJID = make_flag("SPC_STATEMENT_TYPE_OBJID", "1.3.6.1.4.1.311.2.1.11") +SPC_SP_OPUS_INFO_OBJID = make_flag("SPC_SP_OPUS_INFO_OBJID", "1.3.6.1.4.1.311.2.1.12") +SPC_CERT_EXTENSIONS_OBJID = make_flag("SPC_CERT_EXTENSIONS_OBJID", "1.3.6.1.4.1.311.2.1.14") +SPC_PE_IMAGE_DATA_OBJID = make_flag("SPC_PE_IMAGE_DATA_OBJID", "1.3.6.1.4.1.311.2.1.15") +SPC_RAW_FILE_DATA_OBJID = make_flag("SPC_RAW_FILE_DATA_OBJID", "1.3.6.1.4.1.311.2.1.18") +SPC_STRUCTURED_STORAGE_DATA_OBJID = make_flag("SPC_STRUCTURED_STORAGE_DATA_OBJID", "1.3.6.1.4.1.311.2.1.19") +SPC_JAVA_CLASS_DATA_OBJID = make_flag("SPC_JAVA_CLASS_DATA_OBJID", "1.3.6.1.4.1.311.2.1.20") +SPC_INDIVIDUAL_SP_KEY_PURPOSE_OBJID = make_flag("SPC_INDIVIDUAL_SP_KEY_PURPOSE_OBJID", "1.3.6.1.4.1.311.2.1.21") +SPC_COMMERCIAL_SP_KEY_PURPOSE_OBJID = make_flag("SPC_COMMERCIAL_SP_KEY_PURPOSE_OBJID", "1.3.6.1.4.1.311.2.1.22") +SPC_CAB_DATA_OBJID = make_flag("SPC_CAB_DATA_OBJID", "1.3.6.1.4.1.311.2.1.25") +SPC_GLUE_RDN_OBJID = make_flag("SPC_GLUE_RDN_OBJID", "1.3.6.1.4.1.311.2.1.25") +SPC_MINIMAL_CRITERIA_OBJID = make_flag("SPC_MINIMAL_CRITERIA_OBJID", "1.3.6.1.4.1.311.2.1.26") +SPC_FINANCIAL_CRITERIA_OBJID = make_flag("SPC_FINANCIAL_CRITERIA_OBJID", "1.3.6.1.4.1.311.2.1.27") +SPC_LINK_OBJID = make_flag("SPC_LINK_OBJID", "1.3.6.1.4.1.311.2.1.28") +SPC_SIGINFO_OBJID = make_flag("SPC_SIGINFO_OBJID", "1.3.6.1.4.1.311.2.1.30") +CWCSTORAGENAME = make_flag("CWCSTORAGENAME", 32) +RPC_E_CHANGED_MODE = make_flag("RPC_E_CHANGED_MODE", 0x80010106) +STGM_DIRECT = make_flag("STGM_DIRECT", 0x00000000) +STGM_TRANSACTED = make_flag("STGM_TRANSACTED", 0x00010000) +STGM_SIMPLE = make_flag("STGM_SIMPLE", 0x08000000) +STGM_READ = make_flag("STGM_READ", 0x00000000) +STGM_WRITE = make_flag("STGM_WRITE", 0x00000001) +STGM_READWRITE = make_flag("STGM_READWRITE", 0x00000002) +STGM_SHARE_DENY_NONE = make_flag("STGM_SHARE_DENY_NONE", 0x00000040) +STGM_SHARE_DENY_READ = make_flag("STGM_SHARE_DENY_READ", 0x00000030) +STGM_SHARE_DENY_WRITE = make_flag("STGM_SHARE_DENY_WRITE", 0x00000020) +STGM_SHARE_EXCLUSIVE = make_flag("STGM_SHARE_EXCLUSIVE", 0x00000010) +STGM_PRIORITY = make_flag("STGM_PRIORITY", 0x00040000) +STGM_DELETEONRELEASE = make_flag("STGM_DELETEONRELEASE", 0x04000000) +STGM_NOSCRATCH = make_flag("STGM_NOSCRATCH", 0x00100000) +STGM_CREATE = make_flag("STGM_CREATE", 0x00001000) +STGM_CONVERT = make_flag("STGM_CONVERT", 0x00020000) +STGM_FAILIFTHERE = make_flag("STGM_FAILIFTHERE", 0x00000000) +STGM_NOSNAPSHOT = make_flag("STGM_NOSNAPSHOT", 0x00200000) +STGM_DIRECT_SWMR = make_flag("STGM_DIRECT_SWMR", 0x00400000) +ASYNC_MODE_COMPATIBILITY = make_flag("ASYNC_MODE_COMPATIBILITY", 0x00000001) +ASYNC_MODE_DEFAULT = make_flag("ASYNC_MODE_DEFAULT", 0x00000000) +STGTY_REPEAT = make_flag("STGTY_REPEAT", 0x00000100) +STG_TOEND = make_flag("STG_TOEND", 0xFFFFFFFF) +STG_LAYOUT_SEQUENTIAL = make_flag("STG_LAYOUT_SEQUENTIAL", 0x00000000) +STG_LAYOUT_INTERLEAVED = make_flag("STG_LAYOUT_INTERLEAVED", 0x00000001) +STGFMT_STORAGE = make_flag("STGFMT_STORAGE", 0) +STGFMT_NATIVE = make_flag("STGFMT_NATIVE", 1) +STGFMT_FILE = make_flag("STGFMT_FILE", 3) +STGFMT_ANY = make_flag("STGFMT_ANY", 4) +STGFMT_DOCFILE = make_flag("STGFMT_DOCFILE", 5) +STGFMT_DOCUMENT = make_flag("STGFMT_DOCUMENT", 0) +EVENT_TRACE_FLAG_DISPATCHER = make_flag("EVENT_TRACE_FLAG_DISPATCHER", 0x00000800) +EVENT_TRACE_FLAG_VIRTUAL_ALLOC = make_flag("EVENT_TRACE_FLAG_VIRTUAL_ALLOC", 0x00004000) +EVENT_TRACE_FLAG_VAMAP = make_flag("EVENT_TRACE_FLAG_VAMAP", 0x00008000) +EVENT_TRACE_FLAG_NO_SYSCONFIG = make_flag("EVENT_TRACE_FLAG_NO_SYSCONFIG", 0x10000000) +EVENT_TRACE_FLAG_EXTENSION = make_flag("EVENT_TRACE_FLAG_EXTENSION", 0x80000000) +EVENT_TRACE_FLAG_FORWARD_WMI = make_flag("EVENT_TRACE_FLAG_FORWARD_WMI", 0x40000000) +EVENT_TRACE_FLAG_ENABLE_RESERVE = make_flag("EVENT_TRACE_FLAG_ENABLE_RESERVE", 0x20000000) +EVENT_TRACE_FILE_MODE_NONE = make_flag("EVENT_TRACE_FILE_MODE_NONE", 0x00000000) +EVENT_TRACE_FILE_MODE_SEQUENTIAL = make_flag("EVENT_TRACE_FILE_MODE_SEQUENTIAL", 0x00000001) +EVENT_TRACE_FILE_MODE_CIRCULAR = make_flag("EVENT_TRACE_FILE_MODE_CIRCULAR", 0x00000002) +EVENT_TRACE_FILE_MODE_APPEND = make_flag("EVENT_TRACE_FILE_MODE_APPEND", 0x00000004) +EVENT_TRACE_REAL_TIME_MODE = make_flag("EVENT_TRACE_REAL_TIME_MODE", 0x00000100) +EVENT_TRACE_DELAY_OPEN_FILE_MODE = make_flag("EVENT_TRACE_DELAY_OPEN_FILE_MODE", 0x00000200) +EVENT_TRACE_BUFFERING_MODE = make_flag("EVENT_TRACE_BUFFERING_MODE", 0x00000400) +EVENT_TRACE_PRIVATE_LOGGER_MODE = make_flag("EVENT_TRACE_PRIVATE_LOGGER_MODE", 0x00000800) +EVENT_TRACE_ADD_HEADER_MODE = make_flag("EVENT_TRACE_ADD_HEADER_MODE", 0x00001000) +EVENT_TRACE_USE_GLOBAL_SEQUENCE = make_flag("EVENT_TRACE_USE_GLOBAL_SEQUENCE", 0x00004000) +EVENT_TRACE_USE_LOCAL_SEQUENCE = make_flag("EVENT_TRACE_USE_LOCAL_SEQUENCE", 0x00008000) +EVENT_TRACE_RELOG_MODE = make_flag("EVENT_TRACE_RELOG_MODE", 0x00010000) +EVENT_TRACE_USE_PAGED_MEMORY = make_flag("EVENT_TRACE_USE_PAGED_MEMORY", 0x01000000) +EVENT_TRACE_FILE_MODE_NEWFILE = make_flag("EVENT_TRACE_FILE_MODE_NEWFILE", 0x00000008) +EVENT_TRACE_FILE_MODE_PREALLOCATE = make_flag("EVENT_TRACE_FILE_MODE_PREALLOCATE", 0x00000020) +EVENT_TRACE_CONTROL_QUERY = make_flag("EVENT_TRACE_CONTROL_QUERY", 0) +EVENT_TRACE_CONTROL_STOP = make_flag("EVENT_TRACE_CONTROL_STOP", 1) +EVENT_TRACE_CONTROL_UPDATE = make_flag("EVENT_TRACE_CONTROL_UPDATE", 2) +EVENT_TRACE_CONTROL_FLUSH = make_flag("EVENT_TRACE_CONTROL_FLUSH", 3) +PROCESS_TRACE_MODE_REAL_TIME = make_flag("PROCESS_TRACE_MODE_REAL_TIME", 0x00000100) +PROCESS_TRACE_MODE_RAW_TIMESTAMP = make_flag("PROCESS_TRACE_MODE_RAW_TIMESTAMP", 0x00001000) +PROCESS_TRACE_MODE_EVENT_RECORD = make_flag("PROCESS_TRACE_MODE_EVENT_RECORD", 0x10000000) +EVENT_HEADER_PROPERTY_XML = make_flag("EVENT_HEADER_PROPERTY_XML", 0x0001) +EVENT_HEADER_PROPERTY_FORWARDED_XML = make_flag("EVENT_HEADER_PROPERTY_FORWARDED_XML", 0x0002) +EVENT_HEADER_PROPERTY_LEGACY_EVENTLOG = make_flag("EVENT_HEADER_PROPERTY_LEGACY_EVENTLOG", 0x0004) +EVENT_HEADER_FLAG_EXTENDED_INFO = make_flag("EVENT_HEADER_FLAG_EXTENDED_INFO", 0x0001) +EVENT_HEADER_FLAG_PRIVATE_SESSION = make_flag("EVENT_HEADER_FLAG_PRIVATE_SESSION", 0x0002) +EVENT_HEADER_FLAG_STRING_ONLY = make_flag("EVENT_HEADER_FLAG_STRING_ONLY", 0x0004) +EVENT_HEADER_FLAG_TRACE_MESSAGE = make_flag("EVENT_HEADER_FLAG_TRACE_MESSAGE", 0x0008) +EVENT_HEADER_FLAG_NO_CPUTIME = make_flag("EVENT_HEADER_FLAG_NO_CPUTIME", 0x0010) +EVENT_HEADER_FLAG_32_BIT_HEADER = make_flag("EVENT_HEADER_FLAG_32_BIT_HEADER", 0x0020) +EVENT_HEADER_FLAG_64_BIT_HEADER = make_flag("EVENT_HEADER_FLAG_64_BIT_HEADER", 0x0040) +EVENT_HEADER_FLAG_CLASSIC_HEADER = make_flag("EVENT_HEADER_FLAG_CLASSIC_HEADER", 0x0100) +EVENT_HEADER_FLAG_PROCESSOR_INDEX = make_flag("EVENT_HEADER_FLAG_PROCESSOR_INDEX", 0x0200) +EVENT_TRACE_TYPE_CONFIG_CPU = make_flag("EVENT_TRACE_TYPE_CONFIG_CPU", 0x0A) +EVENT_TRACE_TYPE_CONFIG_PHYSICALDISK = make_flag("EVENT_TRACE_TYPE_CONFIG_PHYSICALDISK", 0x0B) +EVENT_TRACE_TYPE_CONFIG_LOGICALDISK = make_flag("EVENT_TRACE_TYPE_CONFIG_LOGICALDISK", 0x0C) +EVENT_TRACE_TYPE_CONFIG_NIC = make_flag("EVENT_TRACE_TYPE_CONFIG_NIC", 0x0D) +EVENT_TRACE_TYPE_CONFIG_VIDEO = make_flag("EVENT_TRACE_TYPE_CONFIG_VIDEO", 0x0E) +EVENT_TRACE_TYPE_CONFIG_SERVICES = make_flag("EVENT_TRACE_TYPE_CONFIG_SERVICES", 0x0F) +EVENT_TRACE_TYPE_CONFIG_POWER = make_flag("EVENT_TRACE_TYPE_CONFIG_POWER", 0x10) +EVENT_TRACE_TYPE_CONFIG_NETINFO = make_flag("EVENT_TRACE_TYPE_CONFIG_NETINFO", 0x11) +EVENT_TRACE_FLAG_PROCESS = make_flag("EVENT_TRACE_FLAG_PROCESS", 0x00000001) +EVENT_TRACE_FLAG_THREAD = make_flag("EVENT_TRACE_FLAG_THREAD", 0x00000002) +EVENT_TRACE_FLAG_IMAGE_LOAD = make_flag("EVENT_TRACE_FLAG_IMAGE_LOAD", 0x00000004) +EVENT_TRACE_FLAG_DISK_IO = make_flag("EVENT_TRACE_FLAG_DISK_IO", 0x00000100) +EVENT_TRACE_FLAG_DISK_FILE_IO = make_flag("EVENT_TRACE_FLAG_DISK_FILE_IO", 0x00000200) +EVENT_TRACE_FLAG_MEMORY_PAGE_FAULTS = make_flag("EVENT_TRACE_FLAG_MEMORY_PAGE_FAULTS", 0x00001000) +EVENT_TRACE_FLAG_MEMORY_HARD_FAULTS = make_flag("EVENT_TRACE_FLAG_MEMORY_HARD_FAULTS", 0x00002000) +EVENT_TRACE_FLAG_NETWORK_TCPIP = make_flag("EVENT_TRACE_FLAG_NETWORK_TCPIP", 0x00010000) +EVENT_TRACE_FLAG_REGISTRY = make_flag("EVENT_TRACE_FLAG_REGISTRY", 0x00020000) +EVENT_TRACE_FLAG_DBGPRINT = make_flag("EVENT_TRACE_FLAG_DBGPRINT", 0x00040000) +EVENT_TRACE_FLAG_VOLMGR = make_flag("EVENT_TRACE_FLAG_VOLMGR", 0x00200000) PRODUCT_UNDEFINED = make_flag("PRODUCT_UNDEFINED", 0x00000000) PRODUCT_ULTIMATE = make_flag("PRODUCT_ULTIMATE", 0x00000001) PRODUCT_HOME_BASIC = make_flag("PRODUCT_HOME_BASIC", 0x00000002) @@ -1489,1042 +2749,3 @@ PRODUCT_CORE_LANGUAGESPECIFIC = make_flag("PRODUCT_CORE_LANGUAGESPECIFIC", 0x000 PRODUCT_CORE = make_flag("PRODUCT_CORE", 0x00000065) PRODUCT_PROFESSIONAL_WMC = make_flag("PRODUCT_PROFESSIONAL_WMC", 0x00000067) PRODUCT_UNLICENSED = make_flag("PRODUCT_UNLICENSED", 0xABCDABCD) -EVENTLOG_SUCCESS = make_flag("EVENTLOG_SUCCESS", 0x0000) -EVENTLOG_ERROR_TYPE = make_flag("EVENTLOG_ERROR_TYPE", 0x0001) -EVENTLOG_WARNING_TYPE = make_flag("EVENTLOG_WARNING_TYPE", 0x0002) -EVENTLOG_INFORMATION_TYPE = make_flag("EVENTLOG_INFORMATION_TYPE", 0x0004) -EVENTLOG_AUDIT_SUCCESS = make_flag("EVENTLOG_AUDIT_SUCCESS", 0x0008) -EVENTLOG_AUDIT_FAILURE = make_flag("EVENTLOG_AUDIT_FAILURE", 0x0010) -EVENTLOG_SEQUENTIAL_READ = make_flag("EVENTLOG_SEQUENTIAL_READ", 0x0001) -EVENTLOG_SEEK_READ = make_flag("EVENTLOG_SEEK_READ", 0x0002) -EVENTLOG_FORWARDS_READ = make_flag("EVENTLOG_FORWARDS_READ", 0x0004) -EVENTLOG_BACKWARDS_READ = make_flag("EVENTLOG_BACKWARDS_READ", 0x0008) -EVT_VARIANT_TYPE_MASK = make_flag("EVT_VARIANT_TYPE_MASK", 0x7f) -EVT_VARIANT_TYPE_ARRAY = make_flag("EVT_VARIANT_TYPE_ARRAY", 128) -ERROR_EVT_INVALID_CHANNEL_PATH = make_flag("ERROR_EVT_INVALID_CHANNEL_PATH", 15000L) -ERROR_EVT_INVALID_QUERY = make_flag("ERROR_EVT_INVALID_QUERY", 15001L) -ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND = make_flag("ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND", 15002L) -ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND = make_flag("ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND", 15003L) -ERROR_EVT_INVALID_PUBLISHER_NAME = make_flag("ERROR_EVT_INVALID_PUBLISHER_NAME", 15004L) -ERROR_EVT_INVALID_EVENT_DATA = make_flag("ERROR_EVT_INVALID_EVENT_DATA", 15005L) -ERROR_EVT_CHANNEL_NOT_FOUND = make_flag("ERROR_EVT_CHANNEL_NOT_FOUND", 15007L) -ERROR_EVT_MALFORMED_XML_TEXT = make_flag("ERROR_EVT_MALFORMED_XML_TEXT", 15008L) -ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL = make_flag("ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL", 15009L) -ERROR_EVT_CONFIGURATION_ERROR = make_flag("ERROR_EVT_CONFIGURATION_ERROR", 15010L) -ERROR_EVT_QUERY_RESULT_STALE = make_flag("ERROR_EVT_QUERY_RESULT_STALE", 15011L) -ERROR_EVT_QUERY_RESULT_INVALID_POSITION = make_flag("ERROR_EVT_QUERY_RESULT_INVALID_POSITION", 15012L) -ERROR_EVT_NON_VALIDATING_MSXML = make_flag("ERROR_EVT_NON_VALIDATING_MSXML", 15013L) -ERROR_EVT_FILTER_ALREADYSCOPED = make_flag("ERROR_EVT_FILTER_ALREADYSCOPED", 15014L) -ERROR_EVT_FILTER_NOTELTSET = make_flag("ERROR_EVT_FILTER_NOTELTSET", 15015L) -ERROR_EVT_FILTER_INVARG = make_flag("ERROR_EVT_FILTER_INVARG", 15016L) -ERROR_EVT_FILTER_INVTEST = make_flag("ERROR_EVT_FILTER_INVTEST", 15017L) -ERROR_EVT_FILTER_INVTYPE = make_flag("ERROR_EVT_FILTER_INVTYPE", 15018L) -ERROR_EVT_FILTER_PARSEERR = make_flag("ERROR_EVT_FILTER_PARSEERR", 15019L) -ERROR_EVT_FILTER_UNSUPPORTEDOP = make_flag("ERROR_EVT_FILTER_UNSUPPORTEDOP", 15020L) -ERROR_EVT_FILTER_UNEXPECTEDTOKEN = make_flag("ERROR_EVT_FILTER_UNEXPECTEDTOKEN", 15021L) -ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL = make_flag("ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL", 15022L) -ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE = make_flag("ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE", 15023L) -ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE = make_flag("ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE", 15024L) -ERROR_EVT_CHANNEL_CANNOT_ACTIVATE = make_flag("ERROR_EVT_CHANNEL_CANNOT_ACTIVATE", 15025L) -ERROR_EVT_FILTER_TOO_COMPLEX = make_flag("ERROR_EVT_FILTER_TOO_COMPLEX", 15026L) -ERROR_EVT_MESSAGE_NOT_FOUND = make_flag("ERROR_EVT_MESSAGE_NOT_FOUND", 15027L) -ERROR_EVT_MESSAGE_ID_NOT_FOUND = make_flag("ERROR_EVT_MESSAGE_ID_NOT_FOUND", 15028L) -ERROR_EVT_UNRESOLVED_VALUE_INSERT = make_flag("ERROR_EVT_UNRESOLVED_VALUE_INSERT", 15029L) -ERROR_EVT_UNRESOLVED_PARAMETER_INSERT = make_flag("ERROR_EVT_UNRESOLVED_PARAMETER_INSERT", 15030L) -ERROR_EVT_MAX_INSERTS_REACHED = make_flag("ERROR_EVT_MAX_INSERTS_REACHED", 15031L) -ERROR_EVT_EVENT_DEFINITION_NOT_FOUND = make_flag("ERROR_EVT_EVENT_DEFINITION_NOT_FOUND", 15032L) -ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND = make_flag("ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND", 15033L) -ERROR_EVT_VERSION_TOO_OLD = make_flag("ERROR_EVT_VERSION_TOO_OLD", 15034L) -ERROR_EVT_VERSION_TOO_NEW = make_flag("ERROR_EVT_VERSION_TOO_NEW", 15035L) -ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY = make_flag("ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY", 15036L) -ERROR_EVT_PUBLISHER_DISABLED = make_flag("ERROR_EVT_PUBLISHER_DISABLED", 15037L) -ERROR_EVT_FILTER_OUT_OF_RANGE = make_flag("ERROR_EVT_FILTER_OUT_OF_RANGE", 15038L) -INVALID_HANDLE_VALUE = make_flag("INVALID_HANDLE_VALUE", ( ( -1 ) & NATIVE_WORD_MAX_VALUE )) -NULL = make_flag("NULL", 0) -MAX_PATH = make_flag("MAX_PATH", 260) -ANYSIZE_ARRAY = make_flag("ANYSIZE_ARRAY", 1) -ANY_SIZE = make_flag("ANY_SIZE", 1) -IMAGE_SIZEOF_SHORT_NAME = make_flag("IMAGE_SIZEOF_SHORT_NAME", 8) -IMAGE_NUMBEROF_DIRECTORY_ENTRIES = make_flag("IMAGE_NUMBEROF_DIRECTORY_ENTRIES", 16) -INFINITE = make_flag("INFINITE", 0xFFFFFFFF) -STD_INPUT_HANDLE = make_flag("STD_INPUT_HANDLE", -10) -STD_OUTPUT_HANDLE = make_flag("STD_OUTPUT_HANDLE", -11) -STD_ERROR_HANDLE = make_flag("STD_ERROR_HANDLE", -12) -WARMING_NOT_SAME_FLAG_FOR_WINXP = make_flag("WARMING_NOT_SAME_FLAG_FOR_WINXP", 0) -STARTF_USESHOWWINDOW = make_flag("STARTF_USESHOWWINDOW", 0x00000001) -STARTF_USESIZE = make_flag("STARTF_USESIZE", 0x00000002) -STARTF_USEPOSITION = make_flag("STARTF_USEPOSITION", 0x00000004) -STARTF_USECOUNTCHARS = make_flag("STARTF_USECOUNTCHARS", 0x00000008) -STARTF_USEFILLATTRIBUTE = make_flag("STARTF_USEFILLATTRIBUTE", 0x00000010) -STARTF_RUNFULLSCREEN = make_flag("STARTF_RUNFULLSCREEN", 0x00000020) -STARTF_FORCEONFEEDBACK = make_flag("STARTF_FORCEONFEEDBACK", 0x00000040) -STARTF_FORCEOFFFEEDBACK = make_flag("STARTF_FORCEOFFFEEDBACK", 0x00000080) -STARTF_USESTDHANDLES = make_flag("STARTF_USESTDHANDLES", 0x00000100) -SW_HIDE = make_flag("SW_HIDE", 0) -SW_SHOWNORMAL = make_flag("SW_SHOWNORMAL", 1) -SW_NORMAL = make_flag("SW_NORMAL", 1) -SW_SHOWMINIMIZED = make_flag("SW_SHOWMINIMIZED", 2) -SW_SHOWMAXIMIZED = make_flag("SW_SHOWMAXIMIZED", 3) -SW_MAXIMIZE = make_flag("SW_MAXIMIZE", 3) -SW_SHOWNOACTIVATE = make_flag("SW_SHOWNOACTIVATE", 4) -SW_SHOW = make_flag("SW_SHOW", 5) -SW_MINIMIZE = make_flag("SW_MINIMIZE", 6) -SW_SHOWMINNOACTIVE = make_flag("SW_SHOWMINNOACTIVE", 7) -SW_SHOWNA = make_flag("SW_SHOWNA", 8) -SW_RESTORE = make_flag("SW_RESTORE", 9) -SW_SHOWDEFAULT = make_flag("SW_SHOWDEFAULT", 10) -SW_FORCEMINIMIZE = make_flag("SW_FORCEMINIMIZE", 11) -SW_MAX = make_flag("SW_MAX", 11) -DEBUG_PROCESS = make_flag("DEBUG_PROCESS", 0x00000001) -DEBUG_ONLY_THIS_PROCESS = make_flag("DEBUG_ONLY_THIS_PROCESS", 0x00000002) -CREATE_SUSPENDED = make_flag("CREATE_SUSPENDED", 0x00000004) -DETACHED_PROCESS = make_flag("DETACHED_PROCESS", 0x00000008) -CREATE_NEW_CONSOLE = make_flag("CREATE_NEW_CONSOLE", 0x00000010) -NORMAL_PRIORITY_CLASS = make_flag("NORMAL_PRIORITY_CLASS", 0x00000020) -IDLE_PRIORITY_CLASS = make_flag("IDLE_PRIORITY_CLASS", 0x00000040) -HIGH_PRIORITY_CLASS = make_flag("HIGH_PRIORITY_CLASS", 0x00000080) -REALTIME_PRIORITY_CLASS = make_flag("REALTIME_PRIORITY_CLASS", 0x00000100) -CREATE_NEW_PROCESS_GROUP = make_flag("CREATE_NEW_PROCESS_GROUP", 0x00000200) -CREATE_UNICODE_ENVIRONMENT = make_flag("CREATE_UNICODE_ENVIRONMENT", 0x00000400) -CREATE_SEPARATE_WOW_VDM = make_flag("CREATE_SEPARATE_WOW_VDM", 0x00000800) -CREATE_SHARED_WOW_VDM = make_flag("CREATE_SHARED_WOW_VDM", 0x00001000) -CREATE_FORCEDOS = make_flag("CREATE_FORCEDOS", 0x00002000) -BELOW_NORMAL_PRIORITY_CLASS = make_flag("BELOW_NORMAL_PRIORITY_CLASS", 0x00004000) -ABOVE_NORMAL_PRIORITY_CLASS = make_flag("ABOVE_NORMAL_PRIORITY_CLASS", 0x00008000) -INHERIT_PARENT_AFFINITY = make_flag("INHERIT_PARENT_AFFINITY", 0x00010000) -INHERIT_CALLER_PRIORITY = make_flag("INHERIT_CALLER_PRIORITY", 0x00020000) -CREATE_PROTECTED_PROCESS = make_flag("CREATE_PROTECTED_PROCESS", 0x00040000) -EXTENDED_STARTUPINFO_PRESENT = make_flag("EXTENDED_STARTUPINFO_PRESENT", 0x00080000) -PROCESS_MODE_BACKGROUND_BEGIN = make_flag("PROCESS_MODE_BACKGROUND_BEGIN", 0x00100000) -PROCESS_MODE_BACKGROUND_END = make_flag("PROCESS_MODE_BACKGROUND_END", 0x00200000) -CREATE_BREAKAWAY_FROM_JOB = make_flag("CREATE_BREAKAWAY_FROM_JOB", 0x01000000) -CREATE_PRESERVE_CODE_AUTHZ_LEVEL = make_flag("CREATE_PRESERVE_CODE_AUTHZ_LEVEL", 0x02000000) -CREATE_DEFAULT_ERROR_MODE = make_flag("CREATE_DEFAULT_ERROR_MODE", 0x04000000) -CREATE_NO_WINDOW = make_flag("CREATE_NO_WINDOW", 0x08000000) -PROFILE_USER = make_flag("PROFILE_USER", 0x10000000) -PROFILE_KERNEL = make_flag("PROFILE_KERNEL", 0x20000000) -PROFILE_SERVER = make_flag("PROFILE_SERVER", 0x40000000) -CREATE_IGNORE_SYSTEM_DEFAULT = make_flag("CREATE_IGNORE_SYSTEM_DEFAULT", 0x80000000) -WAIT_IO_COMPLETION = make_flag("WAIT_IO_COMPLETION", STATUS_USER_APC) -STILL_ACTIVE = make_flag("STILL_ACTIVE", STATUS_PENDING) -EXCEPTION_ACCESS_VIOLATION = make_flag("EXCEPTION_ACCESS_VIOLATION", STATUS_ACCESS_VIOLATION) -EXCEPTION_DATATYPE_MISALIGNMENT = make_flag("EXCEPTION_DATATYPE_MISALIGNMENT", STATUS_DATATYPE_MISALIGNMENT) -EXCEPTION_BREAKPOINT = make_flag("EXCEPTION_BREAKPOINT", STATUS_BREAKPOINT) -EXCEPTION_SINGLE_STEP = make_flag("EXCEPTION_SINGLE_STEP", STATUS_SINGLE_STEP) -EXCEPTION_ARRAY_BOUNDS_EXCEEDED = make_flag("EXCEPTION_ARRAY_BOUNDS_EXCEEDED", STATUS_ARRAY_BOUNDS_EXCEEDED) -EXCEPTION_FLT_DENORMAL_OPERAND = make_flag("EXCEPTION_FLT_DENORMAL_OPERAND", STATUS_FLOAT_DENORMAL_OPERAND) -EXCEPTION_FLT_DIVIDE_BY_ZERO = make_flag("EXCEPTION_FLT_DIVIDE_BY_ZERO", STATUS_FLOAT_DIVIDE_BY_ZERO) -EXCEPTION_FLT_INEXACT_RESULT = make_flag("EXCEPTION_FLT_INEXACT_RESULT", STATUS_FLOAT_INEXACT_RESULT) -EXCEPTION_FLT_INVALID_OPERATION = make_flag("EXCEPTION_FLT_INVALID_OPERATION", STATUS_FLOAT_INVALID_OPERATION) -EXCEPTION_FLT_OVERFLOW = make_flag("EXCEPTION_FLT_OVERFLOW", STATUS_FLOAT_OVERFLOW) -EXCEPTION_FLT_STACK_CHECK = make_flag("EXCEPTION_FLT_STACK_CHECK", STATUS_FLOAT_STACK_CHECK) -EXCEPTION_FLT_UNDERFLOW = make_flag("EXCEPTION_FLT_UNDERFLOW", STATUS_FLOAT_UNDERFLOW) -EXCEPTION_INT_DIVIDE_BY_ZERO = make_flag("EXCEPTION_INT_DIVIDE_BY_ZERO", STATUS_INTEGER_DIVIDE_BY_ZERO) -EXCEPTION_INT_OVERFLOW = make_flag("EXCEPTION_INT_OVERFLOW", STATUS_INTEGER_OVERFLOW) -EXCEPTION_PRIV_INSTRUCTION = make_flag("EXCEPTION_PRIV_INSTRUCTION", STATUS_PRIVILEGED_INSTRUCTION) -EXCEPTION_IN_PAGE_ERROR = make_flag("EXCEPTION_IN_PAGE_ERROR", STATUS_IN_PAGE_ERROR) -EXCEPTION_ILLEGAL_INSTRUCTION = make_flag("EXCEPTION_ILLEGAL_INSTRUCTION", STATUS_ILLEGAL_INSTRUCTION) -EXCEPTION_NONCONTINUABLE_EXCEPTION = make_flag("EXCEPTION_NONCONTINUABLE_EXCEPTION", STATUS_NONCONTINUABLE_EXCEPTION) -EXCEPTION_STACK_OVERFLOW = make_flag("EXCEPTION_STACK_OVERFLOW", STATUS_STACK_OVERFLOW) -EXCEPTION_INVALID_DISPOSITION = make_flag("EXCEPTION_INVALID_DISPOSITION", STATUS_INVALID_DISPOSITION) -EXCEPTION_GUARD_PAGE = make_flag("EXCEPTION_GUARD_PAGE", STATUS_GUARD_PAGE_VIOLATION) -EXCEPTION_INVALID_HANDLE = make_flag("EXCEPTION_INVALID_HANDLE", STATUS_INVALID_HANDLE) -EXCEPTION_POSSIBLE_DEADLOCK = make_flag("EXCEPTION_POSSIBLE_DEADLOCK", STATUS_POSSIBLE_DEADLOCK) -CONTROL_C_EXIT = make_flag("CONTROL_C_EXIT", STATUS_CONTROL_C_EXIT) -EXCEPTION_DEBUG_EVENT = make_flag("EXCEPTION_DEBUG_EVENT", 1) -CREATE_THREAD_DEBUG_EVENT = make_flag("CREATE_THREAD_DEBUG_EVENT", 2) -CREATE_PROCESS_DEBUG_EVENT = make_flag("CREATE_PROCESS_DEBUG_EVENT", 3) -EXIT_THREAD_DEBUG_EVENT = make_flag("EXIT_THREAD_DEBUG_EVENT", 4) -EXIT_PROCESS_DEBUG_EVENT = make_flag("EXIT_PROCESS_DEBUG_EVENT", 5) -LOAD_DLL_DEBUG_EVENT = make_flag("LOAD_DLL_DEBUG_EVENT", 6) -UNLOAD_DLL_DEBUG_EVENT = make_flag("UNLOAD_DLL_DEBUG_EVENT", 7) -OUTPUT_DEBUG_STRING_EVENT = make_flag("OUTPUT_DEBUG_STRING_EVENT", 8) -RIP_EVENT = make_flag("RIP_EVENT", 9) -TH32CS_SNAPHEAPLIST = make_flag("TH32CS_SNAPHEAPLIST", 0x00000001) -TH32CS_SNAPPROCESS = make_flag("TH32CS_SNAPPROCESS", 0x00000002) -TH32CS_SNAPTHREAD = make_flag("TH32CS_SNAPTHREAD", 0x00000004) -TH32CS_SNAPMODULE = make_flag("TH32CS_SNAPMODULE", 0x00000008) -TH32CS_SNAPMODULE32 = make_flag("TH32CS_SNAPMODULE32", 0x00000010) -TH32CS_SNAPALL = make_flag("TH32CS_SNAPALL", ( TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE )) -TH32CS_INHERIT = make_flag("TH32CS_INHERIT", 0x80000000) -CONTEXT_I386 = make_flag("CONTEXT_I386", 0x00010000) -CONTEXT_CONTROL = make_flag("CONTEXT_CONTROL", 0x00000001) -CONTEXT_INTEGER = make_flag("CONTEXT_INTEGER", 0x00000002) -CONTEXT_SEGMENTS = make_flag("CONTEXT_SEGMENTS", 0x00000004) -CONTEXT_FLOATING_POINT = make_flag("CONTEXT_FLOATING_POINT", 0x00000008) -CONTEXT_DEBUG_REGISTERS = make_flag("CONTEXT_DEBUG_REGISTERS", 0x00000010) -CONTEXT_EXTENDED_REGISTERS = make_flag("CONTEXT_EXTENDED_REGISTERS", 0x00000020) -CONTEXT_FULL = make_flag("CONTEXT_FULL", ( CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS )) -CONTEXT_ALL = make_flag("CONTEXT_ALL", ( CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS | CONTEXT_EXTENDED_REGISTERS )) -CONTEXT_FULL = make_flag("CONTEXT_FULL", CONTEXT_I386 | CONTEXT_FULL) -CONTEXT_ALL = make_flag("CONTEXT_ALL", CONTEXT_I386 | CONTEXT_ALL) -CONTEXT_XSTATE = make_flag("CONTEXT_XSTATE", ( CONTEXT_I386 | 0x00000040 )) -PAGE_NOACCESS = make_flag("PAGE_NOACCESS", 0x01) -PAGE_READONLY = make_flag("PAGE_READONLY", 0x02) -PAGE_READWRITE = make_flag("PAGE_READWRITE", 0x04) -PAGE_WRITECOPY = make_flag("PAGE_WRITECOPY", 0x08) -PAGE_EXECUTE = make_flag("PAGE_EXECUTE", 0x10) -PAGE_EXECUTE_READ = make_flag("PAGE_EXECUTE_READ", 0x20) -PAGE_EXECUTE_READWRITE = make_flag("PAGE_EXECUTE_READWRITE", 0x40) -PAGE_EXECUTE_WRITECOPY = make_flag("PAGE_EXECUTE_WRITECOPY", 0x80) -PAGE_GUARD = make_flag("PAGE_GUARD", 0x100) -PAGE_NOCACHE = make_flag("PAGE_NOCACHE", 0x200) -PAGE_WRITECOMBINE = make_flag("PAGE_WRITECOMBINE", 0x400) -MEM_COMMIT = make_flag("MEM_COMMIT", 0x1000) -MEM_RESERVE = make_flag("MEM_RESERVE", 0x2000) -MEM_DECOMMIT = make_flag("MEM_DECOMMIT", 0x4000) -MEM_RELEASE = make_flag("MEM_RELEASE", 0x8000) -MEM_FREE = make_flag("MEM_FREE", 0x10000) -MEM_PRIVATE = make_flag("MEM_PRIVATE", 0x20000) -MEM_MAPPED = make_flag("MEM_MAPPED", 0x40000) -MEM_RESET = make_flag("MEM_RESET", 0x80000) -MEM_TOP_DOWN = make_flag("MEM_TOP_DOWN", 0x100000) -MEM_WRITE_WATCH = make_flag("MEM_WRITE_WATCH", 0x200000) -MEM_PHYSICAL = make_flag("MEM_PHYSICAL", 0x400000) -MEM_ROTATE = make_flag("MEM_ROTATE", 0x800000) -MEM_LARGE_PAGES = make_flag("MEM_LARGE_PAGES", 0x20000000) -MEM_4MB_PAGES = make_flag("MEM_4MB_PAGES", 0x80000000) -SEC_FILE = make_flag("SEC_FILE", 0x800000) -SEC_IMAGE = make_flag("SEC_IMAGE", 0x1000000) -SEC_PROTECTED_IMAGE = make_flag("SEC_PROTECTED_IMAGE", 0x2000000) -SEC_RESERVE = make_flag("SEC_RESERVE", 0x4000000) -SEC_COMMIT = make_flag("SEC_COMMIT", 0x8000000) -SEC_NOCACHE = make_flag("SEC_NOCACHE", 0x10000000) -SEC_WRITECOMBINE = make_flag("SEC_WRITECOMBINE", 0x40000000) -SEC_LARGE_PAGES = make_flag("SEC_LARGE_PAGES", 0x80000000) -MEM_IMAGE = make_flag("MEM_IMAGE", SEC_IMAGE) -WRITE_WATCH_FLAG_RESET = make_flag("WRITE_WATCH_FLAG_RESET", 0x01) -DELETE = make_flag("DELETE", ( 0x00010000 )) -READ_CONTROL = make_flag("READ_CONTROL", ( 0x00020000 )) -WRITE_DAC = make_flag("WRITE_DAC", ( 0x00040000 )) -WRITE_OWNER = make_flag("WRITE_OWNER", ( 0x00080000 )) -SYNCHRONIZE = make_flag("SYNCHRONIZE", ( 0x00100000 )) -STANDARD_RIGHTS_REQUIRED = make_flag("STANDARD_RIGHTS_REQUIRED", ( 0x000F0000 )) -STANDARD_RIGHTS_READ = make_flag("STANDARD_RIGHTS_READ", ( READ_CONTROL )) -STANDARD_RIGHTS_WRITE = make_flag("STANDARD_RIGHTS_WRITE", ( READ_CONTROL )) -STANDARD_RIGHTS_EXECUTE = make_flag("STANDARD_RIGHTS_EXECUTE", ( READ_CONTROL )) -STANDARD_RIGHTS_ALL = make_flag("STANDARD_RIGHTS_ALL", ( 0x001F0000 )) -SPECIFIC_RIGHTS_ALL = make_flag("SPECIFIC_RIGHTS_ALL", ( 0x0000FFFF )) -AF_UNSPEC = make_flag("AF_UNSPEC", 0) -AF_UNIX = make_flag("AF_UNIX", 1) -AF_INET = make_flag("AF_INET", 2) -AF_IMPLINK = make_flag("AF_IMPLINK", 3) -AF_PUP = make_flag("AF_PUP", 4) -AF_CHAOS = make_flag("AF_CHAOS", 5) -AF_NS = make_flag("AF_NS", 6) -AF_IPX = make_flag("AF_IPX", AF_NS) -AF_ISO = make_flag("AF_ISO", 7) -AF_OSI = make_flag("AF_OSI", AF_ISO) -AF_ECMA = make_flag("AF_ECMA", 8) -AF_DATAKIT = make_flag("AF_DATAKIT", 9) -AF_CCITT = make_flag("AF_CCITT", 10) -AF_SNA = make_flag("AF_SNA", 11) -AF_DECnet = make_flag("AF_DECnet", 12) -AF_DLI = make_flag("AF_DLI", 13) -AF_LAT = make_flag("AF_LAT", 14) -AF_HYLINK = make_flag("AF_HYLINK", 15) -AF_APPLETALK = make_flag("AF_APPLETALK", 16) -AF_NETBIOS = make_flag("AF_NETBIOS", 17) -AF_VOICEVIEW = make_flag("AF_VOICEVIEW", 18) -AF_FIREFOX = make_flag("AF_FIREFOX", 19) -AF_UNKNOWN1 = make_flag("AF_UNKNOWN1", 20) -AF_BAN = make_flag("AF_BAN", 21) -AF_ATM = make_flag("AF_ATM", 22) -AF_INET6 = make_flag("AF_INET6", 23) -AF_CLUSTER = make_flag("AF_CLUSTER", 24) -AF_12844 = make_flag("AF_12844", 25) -AF_IRDA = make_flag("AF_IRDA", 26) -AF_NETDES = make_flag("AF_NETDES", 28) -EXCEPTION_NONCONTINUABLE = make_flag("EXCEPTION_NONCONTINUABLE", 0x1) -EXCEPTION_MAXIMUM_PARAMETERS = make_flag("EXCEPTION_MAXIMUM_PARAMETERS", 15) -EXCEPTION_EXECUTE_HANDLER = make_flag("EXCEPTION_EXECUTE_HANDLER", 1) -EXCEPTION_CONTINUE_SEARCH = make_flag("EXCEPTION_CONTINUE_SEARCH", 0) -EXCEPTION_CONTINUE_EXECUTION = make_flag("EXCEPTION_CONTINUE_EXECUTION", -1) -GENERIC_READ = make_flag("GENERIC_READ", ( 0x80000000 )) -GENERIC_WRITE = make_flag("GENERIC_WRITE", ( 0x40000000 )) -GENERIC_EXECUTE = make_flag("GENERIC_EXECUTE", ( 0x20000000 )) -GENERIC_ALL = make_flag("GENERIC_ALL", ( 0x10000000 )) -FILE_FLAG_WRITE_THROUGH = make_flag("FILE_FLAG_WRITE_THROUGH", 0x80000000) -FILE_FLAG_OVERLAPPED = make_flag("FILE_FLAG_OVERLAPPED", 0x40000000) -FILE_FLAG_NO_BUFFERING = make_flag("FILE_FLAG_NO_BUFFERING", 0x20000000) -FILE_FLAG_RANDOM_ACCESS = make_flag("FILE_FLAG_RANDOM_ACCESS", 0x10000000) -FILE_FLAG_SEQUENTIAL_SCAN = make_flag("FILE_FLAG_SEQUENTIAL_SCAN", 0x08000000) -FILE_FLAG_DELETE_ON_CLOSE = make_flag("FILE_FLAG_DELETE_ON_CLOSE", 0x04000000) -FILE_FLAG_BACKUP_SEMANTICS = make_flag("FILE_FLAG_BACKUP_SEMANTICS", 0x02000000) -FILE_FLAG_POSIX_SEMANTICS = make_flag("FILE_FLAG_POSIX_SEMANTICS", 0x01000000) -FILE_FLAG_OPEN_REPARSE_POINT = make_flag("FILE_FLAG_OPEN_REPARSE_POINT", 0x00200000) -FILE_FLAG_OPEN_NO_RECALL = make_flag("FILE_FLAG_OPEN_NO_RECALL", 0x00100000) -FILE_FLAG_FIRST_PIPE_INSTANCE = make_flag("FILE_FLAG_FIRST_PIPE_INSTANCE", 0x00080000) -CREATE_NEW = make_flag("CREATE_NEW", 1) -CREATE_ALWAYS = make_flag("CREATE_ALWAYS", 2) -OPEN_EXISTING = make_flag("OPEN_EXISTING", 3) -OPEN_ALWAYS = make_flag("OPEN_ALWAYS", 4) -TRUNCATE_EXISTING = make_flag("TRUNCATE_EXISTING", 5) -FILE_SHARE_READ = make_flag("FILE_SHARE_READ", 0x00000001) -FILE_SHARE_WRITE = make_flag("FILE_SHARE_WRITE", 0x00000002) -FILE_SHARE_DELETE = make_flag("FILE_SHARE_DELETE", 0x00000004) -FILE_ATTRIBUTE_READONLY = make_flag("FILE_ATTRIBUTE_READONLY", 0x00000001) -FILE_ATTRIBUTE_HIDDEN = make_flag("FILE_ATTRIBUTE_HIDDEN", 0x00000002) -FILE_ATTRIBUTE_SYSTEM = make_flag("FILE_ATTRIBUTE_SYSTEM", 0x00000004) -FILE_ATTRIBUTE_DIRECTORY = make_flag("FILE_ATTRIBUTE_DIRECTORY", 0x00000010) -FILE_ATTRIBUTE_ARCHIVE = make_flag("FILE_ATTRIBUTE_ARCHIVE", 0x00000020) -FILE_ATTRIBUTE_DEVICE = make_flag("FILE_ATTRIBUTE_DEVICE", 0x00000040) -FILE_ATTRIBUTE_NORMAL = make_flag("FILE_ATTRIBUTE_NORMAL", 0x00000080) -FILE_ATTRIBUTE_TEMPORARY = make_flag("FILE_ATTRIBUTE_TEMPORARY", 0x00000100) -FILE_ATTRIBUTE_SPARSE_FILE = make_flag("FILE_ATTRIBUTE_SPARSE_FILE", 0x00000200) -FILE_ATTRIBUTE_REPARSE_POINT = make_flag("FILE_ATTRIBUTE_REPARSE_POINT", 0x00000400) -FILE_ATTRIBUTE_COMPRESSED = make_flag("FILE_ATTRIBUTE_COMPRESSED", 0x00000800) -FILE_ATTRIBUTE_OFFLINE = make_flag("FILE_ATTRIBUTE_OFFLINE", 0x00001000) -FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = make_flag("FILE_ATTRIBUTE_NOT_CONTENT_INDEXED", 0x00002000) -FILE_ATTRIBUTE_ENCRYPTED = make_flag("FILE_ATTRIBUTE_ENCRYPTED", 0x00004000) -FILE_ATTRIBUTE_VIRTUAL = make_flag("FILE_ATTRIBUTE_VIRTUAL", 0x00010000) -FILE_NOTIFY_CHANGE_FILE_NAME = make_flag("FILE_NOTIFY_CHANGE_FILE_NAME", 0x00000001) -FILE_NOTIFY_CHANGE_DIR_NAME = make_flag("FILE_NOTIFY_CHANGE_DIR_NAME", 0x00000002) -FILE_NOTIFY_CHANGE_ATTRIBUTES = make_flag("FILE_NOTIFY_CHANGE_ATTRIBUTES", 0x00000004) -FILE_NOTIFY_CHANGE_SIZE = make_flag("FILE_NOTIFY_CHANGE_SIZE", 0x00000008) -FILE_NOTIFY_CHANGE_LAST_WRITE = make_flag("FILE_NOTIFY_CHANGE_LAST_WRITE", 0x00000010) -FILE_NOTIFY_CHANGE_LAST_ACCESS = make_flag("FILE_NOTIFY_CHANGE_LAST_ACCESS", 0x00000020) -FILE_NOTIFY_CHANGE_CREATION = make_flag("FILE_NOTIFY_CHANGE_CREATION", 0x00000040) -FILE_NOTIFY_CHANGE_SECURITY = make_flag("FILE_NOTIFY_CHANGE_SECURITY", 0x00000100) -FILE_ACTION_ADDED = make_flag("FILE_ACTION_ADDED", 0x00000001) -FILE_ACTION_REMOVED = make_flag("FILE_ACTION_REMOVED", 0x00000002) -FILE_ACTION_MODIFIED = make_flag("FILE_ACTION_MODIFIED", 0x00000003) -FILE_ACTION_RENAMED_OLD_NAME = make_flag("FILE_ACTION_RENAMED_OLD_NAME", 0x00000004) -FILE_ACTION_RENAMED_NEW_NAME = make_flag("FILE_ACTION_RENAMED_NEW_NAME", 0x00000005) -MAILSLOT_NO_MESSAGE = make_flag("MAILSLOT_NO_MESSAGE", ( -1 )) -MAILSLOT_WAIT_FOREVER = make_flag("MAILSLOT_WAIT_FOREVER", ( -1 )) -FILE_CASE_SENSITIVE_SEARCH = make_flag("FILE_CASE_SENSITIVE_SEARCH", 0x00000001) -FILE_CASE_PRESERVED_NAMES = make_flag("FILE_CASE_PRESERVED_NAMES", 0x00000002) -FILE_UNICODE_ON_DISK = make_flag("FILE_UNICODE_ON_DISK", 0x00000004) -FILE_PERSISTENT_ACLS = make_flag("FILE_PERSISTENT_ACLS", 0x00000008) -FILE_FILE_COMPRESSION = make_flag("FILE_FILE_COMPRESSION", 0x00000010) -FILE_VOLUME_QUOTAS = make_flag("FILE_VOLUME_QUOTAS", 0x00000020) -FILE_SUPPORTS_SPARSE_FILES = make_flag("FILE_SUPPORTS_SPARSE_FILES", 0x00000040) -FILE_SUPPORTS_REPARSE_POINTS = make_flag("FILE_SUPPORTS_REPARSE_POINTS", 0x00000080) -FILE_SUPPORTS_REMOTE_STORAGE = make_flag("FILE_SUPPORTS_REMOTE_STORAGE", 0x00000100) -FILE_VOLUME_IS_COMPRESSED = make_flag("FILE_VOLUME_IS_COMPRESSED", 0x00008000) -FILE_SUPPORTS_OBJECT_IDS = make_flag("FILE_SUPPORTS_OBJECT_IDS", 0x00010000) -FILE_SUPPORTS_ENCRYPTION = make_flag("FILE_SUPPORTS_ENCRYPTION", 0x00020000) -FILE_NAMED_STREAMS = make_flag("FILE_NAMED_STREAMS", 0x00040000) -FILE_READ_ONLY_VOLUME = make_flag("FILE_READ_ONLY_VOLUME", 0x00080000) -FILE_SEQUENTIAL_WRITE_ONCE = make_flag("FILE_SEQUENTIAL_WRITE_ONCE", 0x00100000) -FILE_SUPPORTS_TRANSACTIONS = make_flag("FILE_SUPPORTS_TRANSACTIONS", 0x00200000) -FILE_SUPPORTS_HARD_LINKS = make_flag("FILE_SUPPORTS_HARD_LINKS", 0x00400000) -FILE_SUPPORTS_EXTENDED_ATTRIBUTES = make_flag("FILE_SUPPORTS_EXTENDED_ATTRIBUTES", 0x00800000) -FILE_SUPPORTS_OPEN_BY_FILE_ID = make_flag("FILE_SUPPORTS_OPEN_BY_FILE_ID", 0x01000000) -FILE_SUPPORTS_USN_JOURNAL = make_flag("FILE_SUPPORTS_USN_JOURNAL", 0x02000000) -HKEY_CLASSES_ROOT = make_flag("HKEY_CLASSES_ROOT", ( 0x80000000 )) -HKEY_CURRENT_USER = make_flag("HKEY_CURRENT_USER", ( 0x80000001 )) -HKEY_LOCAL_MACHINE = make_flag("HKEY_LOCAL_MACHINE", ( 0x80000002 )) -HKEY_USERS = make_flag("HKEY_USERS", ( 0x80000003 )) -HKEY_PERFORMANCE_DATA = make_flag("HKEY_PERFORMANCE_DATA", ( 0x80000004 )) -HKEY_PERFORMANCE_TEXT = make_flag("HKEY_PERFORMANCE_TEXT", ( 0x80000050 )) -HKEY_PERFORMANCE_NLSTEXT = make_flag("HKEY_PERFORMANCE_NLSTEXT", ( 0x80000060 )) -RRF_RT_REG_NONE = make_flag("RRF_RT_REG_NONE", 0x00000001) -RRF_RT_REG_SZ = make_flag("RRF_RT_REG_SZ", 0x00000002) -RRF_RT_REG_EXPAND_SZ = make_flag("RRF_RT_REG_EXPAND_SZ", 0x00000004) -RRF_RT_REG_BINARY = make_flag("RRF_RT_REG_BINARY", 0x00000008) -RRF_RT_REG_DWORD = make_flag("RRF_RT_REG_DWORD", 0x00000010) -RRF_RT_REG_MULTI_SZ = make_flag("RRF_RT_REG_MULTI_SZ", 0x00000020) -RRF_RT_REG_QWORD = make_flag("RRF_RT_REG_QWORD", 0x00000040) -RRF_RT_DWORD = make_flag("RRF_RT_DWORD", ( RRF_RT_REG_BINARY | RRF_RT_REG_DWORD )) -RRF_RT_QWORD = make_flag("RRF_RT_QWORD", ( RRF_RT_REG_BINARY | RRF_RT_REG_QWORD )) -RRF_RT_ANY = make_flag("RRF_RT_ANY", 0x0000ffff) -RRF_NOEXPAND = make_flag("RRF_NOEXPAND", 0x10000000) -RRF_ZEROONFAILURE = make_flag("RRF_ZEROONFAILURE", 0x20000000) -ERROR_NOT_ALL_ASSIGNED = make_flag("ERROR_NOT_ALL_ASSIGNED", 1300) -S_OK = make_flag("S_OK", 0) -S_FALSE = make_flag("S_FALSE", 1) -E_NOINTERFACE = make_flag("E_NOINTERFACE", 0x80004002) -E_FAIL = make_flag("E_FAIL", 0x80004005) -DEBUG_EVENT_BREAKPOINT = make_flag("DEBUG_EVENT_BREAKPOINT", 0x00000001) -DEBUG_EVENT_EXCEPTION = make_flag("DEBUG_EVENT_EXCEPTION", 0x00000002) -DEBUG_EVENT_CREATE_THREAD = make_flag("DEBUG_EVENT_CREATE_THREAD", 0x00000004) -DEBUG_EVENT_EXIT_THREAD = make_flag("DEBUG_EVENT_EXIT_THREAD", 0x00000008) -DEBUG_EVENT_CREATE_PROCESS = make_flag("DEBUG_EVENT_CREATE_PROCESS", 0x00000010) -DEBUG_EVENT_EXIT_PROCESS = make_flag("DEBUG_EVENT_EXIT_PROCESS", 0x00000020) -DEBUG_EVENT_LOAD_MODULE = make_flag("DEBUG_EVENT_LOAD_MODULE", 0x00000040) -DEBUG_EVENT_UNLOAD_MODULE = make_flag("DEBUG_EVENT_UNLOAD_MODULE", 0x00000080) -DEBUG_EVENT_SYSTEM_ERROR = make_flag("DEBUG_EVENT_SYSTEM_ERROR", 0x00000100) -DEBUG_EVENT_SESSION_STATUS = make_flag("DEBUG_EVENT_SESSION_STATUS", 0x00000200) -DEBUG_EVENT_CHANGE_DEBUGGEE_STATE = make_flag("DEBUG_EVENT_CHANGE_DEBUGGEE_STATE", 0x00000400) -DEBUG_EVENT_CHANGE_ENGINE_STATE = make_flag("DEBUG_EVENT_CHANGE_ENGINE_STATE", 0x00000800) -DEBUG_EVENT_CHANGE_SYMBOL_STATE = make_flag("DEBUG_EVENT_CHANGE_SYMBOL_STATE", 0x00001000) -WOW64_MAXIMUM_SUPPORTED_EXTENSION = make_flag("WOW64_MAXIMUM_SUPPORTED_EXTENSION", 512) -WOW64_SIZE_OF_80387_REGISTERS = make_flag("WOW64_SIZE_OF_80387_REGISTERS", 80) -REG_NONE = make_flag("REG_NONE", ( 0 )) -REG_SZ = make_flag("REG_SZ", ( 1 )) -REG_EXPAND_SZ = make_flag("REG_EXPAND_SZ", ( 2 )) -REG_BINARY = make_flag("REG_BINARY", ( 3 )) -REG_DWORD = make_flag("REG_DWORD", ( 4 )) -REG_DWORD_LITTLE_ENDIAN = make_flag("REG_DWORD_LITTLE_ENDIAN", ( 4 )) -REG_DWORD_BIG_ENDIAN = make_flag("REG_DWORD_BIG_ENDIAN", ( 5 )) -REG_LINK = make_flag("REG_LINK", ( 6 )) -REG_MULTI_SZ = make_flag("REG_MULTI_SZ", ( 7 )) -REG_RESOURCE_LIST = make_flag("REG_RESOURCE_LIST", ( 8 )) -REG_FULL_RESOURCE_DESCRIPTOR = make_flag("REG_FULL_RESOURCE_DESCRIPTOR", ( 9 )) -REG_RESOURCE_REQUIREMENTS_LIST = make_flag("REG_RESOURCE_REQUIREMENTS_LIST", ( 10 )) -REG_QWORD = make_flag("REG_QWORD", ( 11 )) -REG_QWORD_LITTLE_ENDIAN = make_flag("REG_QWORD_LITTLE_ENDIAN", ( 11 )) -IMAGE_FILE_RELOCS_STRIPPED = make_flag("IMAGE_FILE_RELOCS_STRIPPED", 0x0001) -IMAGE_FILE_EXECUTABLE_IMAGE = make_flag("IMAGE_FILE_EXECUTABLE_IMAGE", 0x0002) -IMAGE_FILE_LINE_NUMS_STRIPPED = make_flag("IMAGE_FILE_LINE_NUMS_STRIPPED", 0x0004) -IMAGE_FILE_LOCAL_SYMS_STRIPPED = make_flag("IMAGE_FILE_LOCAL_SYMS_STRIPPED", 0x0008) -IMAGE_FILE_AGGRESIVE_WS_TRIM = make_flag("IMAGE_FILE_AGGRESIVE_WS_TRIM", 0x0010) -IMAGE_FILE_LARGE_ADDRESS_AWARE = make_flag("IMAGE_FILE_LARGE_ADDRESS_AWARE", 0x0020) -IMAGE_FILE_BYTES_REVERSED_LO = make_flag("IMAGE_FILE_BYTES_REVERSED_LO", 0x0080) -IMAGE_FILE_32BIT_MACHINE = make_flag("IMAGE_FILE_32BIT_MACHINE", 0x0100) -IMAGE_FILE_DEBUG_STRIPPED = make_flag("IMAGE_FILE_DEBUG_STRIPPED", 0x0200) -IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP = make_flag("IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP", 0x0400) -IMAGE_FILE_NET_RUN_FROM_SWAP = make_flag("IMAGE_FILE_NET_RUN_FROM_SWAP", 0x0800) -IMAGE_FILE_SYSTEM = make_flag("IMAGE_FILE_SYSTEM", 0x1000) -IMAGE_FILE_DLL = make_flag("IMAGE_FILE_DLL", 0x2000) -IMAGE_FILE_UP_SYSTEM_ONLY = make_flag("IMAGE_FILE_UP_SYSTEM_ONLY", 0x4000) -IMAGE_FILE_BYTES_REVERSED_HI = make_flag("IMAGE_FILE_BYTES_REVERSED_HI", 0x8000) -IMAGE_FILE_MACHINE_UNKNOWN = make_flag("IMAGE_FILE_MACHINE_UNKNOWN", 0) -IMAGE_FILE_MACHINE_I386 = make_flag("IMAGE_FILE_MACHINE_I386", 0x014c) -IMAGE_FILE_MACHINE_R3000 = make_flag("IMAGE_FILE_MACHINE_R3000", 0x0162) -IMAGE_FILE_MACHINE_R4000 = make_flag("IMAGE_FILE_MACHINE_R4000", 0x0166) -IMAGE_FILE_MACHINE_R10000 = make_flag("IMAGE_FILE_MACHINE_R10000", 0x0168) -IMAGE_FILE_MACHINE_WCEMIPSV2 = make_flag("IMAGE_FILE_MACHINE_WCEMIPSV2", 0x0169) -IMAGE_FILE_MACHINE_ALPHA = make_flag("IMAGE_FILE_MACHINE_ALPHA", 0x0184) -IMAGE_FILE_MACHINE_SH3 = make_flag("IMAGE_FILE_MACHINE_SH3", 0x01a2) -IMAGE_FILE_MACHINE_SH3DSP = make_flag("IMAGE_FILE_MACHINE_SH3DSP", 0x01a3) -IMAGE_FILE_MACHINE_SH3E = make_flag("IMAGE_FILE_MACHINE_SH3E", 0x01a4) -IMAGE_FILE_MACHINE_SH4 = make_flag("IMAGE_FILE_MACHINE_SH4", 0x01a6) -IMAGE_FILE_MACHINE_SH5 = make_flag("IMAGE_FILE_MACHINE_SH5", 0x01a8) -IMAGE_FILE_MACHINE_ARM = make_flag("IMAGE_FILE_MACHINE_ARM", 0x01c0) -IMAGE_FILE_MACHINE_THUMB = make_flag("IMAGE_FILE_MACHINE_THUMB", 0x01c2) -IMAGE_FILE_MACHINE_ARMNT = make_flag("IMAGE_FILE_MACHINE_ARMNT", 0x01c4) -IMAGE_FILE_MACHINE_AM33 = make_flag("IMAGE_FILE_MACHINE_AM33", 0x01d3) -IMAGE_FILE_MACHINE_POWERPC = make_flag("IMAGE_FILE_MACHINE_POWERPC", 0x01F0) -IMAGE_FILE_MACHINE_POWERPCFP = make_flag("IMAGE_FILE_MACHINE_POWERPCFP", 0x01f1) -IMAGE_FILE_MACHINE_IA64 = make_flag("IMAGE_FILE_MACHINE_IA64", 0x0200) -IMAGE_FILE_MACHINE_MIPS16 = make_flag("IMAGE_FILE_MACHINE_MIPS16", 0x0266) -IMAGE_FILE_MACHINE_ALPHA64 = make_flag("IMAGE_FILE_MACHINE_ALPHA64", 0x0284) -IMAGE_FILE_MACHINE_MIPSFPU = make_flag("IMAGE_FILE_MACHINE_MIPSFPU", 0x0366) -IMAGE_FILE_MACHINE_MIPSFPU16 = make_flag("IMAGE_FILE_MACHINE_MIPSFPU16", 0x0466) -IMAGE_FILE_MACHINE_AXP64 = make_flag("IMAGE_FILE_MACHINE_AXP64", IMAGE_FILE_MACHINE_ALPHA64) -IMAGE_FILE_MACHINE_TRICORE = make_flag("IMAGE_FILE_MACHINE_TRICORE", 0x0520) -IMAGE_FILE_MACHINE_CEF = make_flag("IMAGE_FILE_MACHINE_CEF", 0x0CEF) -IMAGE_FILE_MACHINE_EBC = make_flag("IMAGE_FILE_MACHINE_EBC", 0x0EBC) -IMAGE_FILE_MACHINE_AMD64 = make_flag("IMAGE_FILE_MACHINE_AMD64", 0x8664) -IMAGE_FILE_MACHINE_M32R = make_flag("IMAGE_FILE_MACHINE_M32R", 0x9041) -IMAGE_FILE_MACHINE_CEE = make_flag("IMAGE_FILE_MACHINE_CEE", 0xC0EE) -SECURITY_MANDATORY_UNTRUSTED_RID = make_flag("SECURITY_MANDATORY_UNTRUSTED_RID", ( 0x00000000 )) -SECURITY_MANDATORY_LOW_RID = make_flag("SECURITY_MANDATORY_LOW_RID", ( 0x00001000 )) -SECURITY_MANDATORY_MEDIUM_RID = make_flag("SECURITY_MANDATORY_MEDIUM_RID", ( 0x00002000 )) -SECURITY_MANDATORY_MEDIUM_PLUS_RID = make_flag("SECURITY_MANDATORY_MEDIUM_PLUS_RID", ( SECURITY_MANDATORY_MEDIUM_RID + 0x100 )) -SECURITY_MANDATORY_HIGH_RID = make_flag("SECURITY_MANDATORY_HIGH_RID", ( 0x00003000 )) -SECURITY_MANDATORY_SYSTEM_RID = make_flag("SECURITY_MANDATORY_SYSTEM_RID", ( 0x00004000 )) -SECURITY_MANDATORY_PROTECTED_PROCESS_RID = make_flag("SECURITY_MANDATORY_PROTECTED_PROCESS_RID", ( 0x00005000 )) -SECTION_QUERY = make_flag("SECTION_QUERY", 0x0001) -SECTION_MAP_WRITE = make_flag("SECTION_MAP_WRITE", 0x0002) -SECTION_MAP_READ = make_flag("SECTION_MAP_READ", 0x0004) -SECTION_MAP_EXECUTE = make_flag("SECTION_MAP_EXECUTE", 0x0008) -SECTION_EXTEND_SIZE = make_flag("SECTION_EXTEND_SIZE", 0x0010) -SECTION_MAP_EXECUTE_EXPLICIT = make_flag("SECTION_MAP_EXECUTE_EXPLICIT", 0x0020) -SECTION_ALL_ACCESS = make_flag("SECTION_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SECTION_QUERY| SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE )) -FILE_MAP_COPY = make_flag("FILE_MAP_COPY", SECTION_QUERY) -FILE_MAP_WRITE = make_flag("FILE_MAP_WRITE", SECTION_MAP_WRITE) -FILE_MAP_READ = make_flag("FILE_MAP_READ", SECTION_MAP_READ) -FILE_MAP_ALL_ACCESS = make_flag("FILE_MAP_ALL_ACCESS", SECTION_ALL_ACCESS) -FILE_MAP_EXECUTE = make_flag("FILE_MAP_EXECUTE", SECTION_MAP_EXECUTE_EXPLICIT) -SC_MANAGER_CONNECT = make_flag("SC_MANAGER_CONNECT", 0x0001) -SC_MANAGER_CREATE_SERVICE = make_flag("SC_MANAGER_CREATE_SERVICE", 0x0002) -SC_MANAGER_ENUMERATE_SERVICE = make_flag("SC_MANAGER_ENUMERATE_SERVICE", 0x0004) -SC_MANAGER_LOCK = make_flag("SC_MANAGER_LOCK", 0x0008) -SC_MANAGER_QUERY_LOCK_STATUS = make_flag("SC_MANAGER_QUERY_LOCK_STATUS", 0x0010) -SC_MANAGER_MODIFY_BOOT_CONFIG = make_flag("SC_MANAGER_MODIFY_BOOT_CONFIG", 0x0020) -SC_MANAGER_ALL_ACCESS = make_flag("SC_MANAGER_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_LOCK | SC_MANAGER_QUERY_LOCK_STATUS | SC_MANAGER_MODIFY_BOOT_CONFIG )) -SERVICE_QUERY_CONFIG = make_flag("SERVICE_QUERY_CONFIG", 0x0001) -SERVICE_CHANGE_CONFIG = make_flag("SERVICE_CHANGE_CONFIG", 0x0002) -SERVICE_QUERY_STATUS = make_flag("SERVICE_QUERY_STATUS", 0x0004) -SERVICE_ENUMERATE_DEPENDENTS = make_flag("SERVICE_ENUMERATE_DEPENDENTS", 0x0008) -SERVICE_START = make_flag("SERVICE_START", 0x0010) -SERVICE_STOP = make_flag("SERVICE_STOP", 0x0020) -SERVICE_PAUSE_CONTINUE = make_flag("SERVICE_PAUSE_CONTINUE", 0x0040) -SERVICE_INTERROGATE = make_flag("SERVICE_INTERROGATE", 0x0080) -SERVICE_USER_DEFINED_CONTROL = make_flag("SERVICE_USER_DEFINED_CONTROL", 0x0100) -SERVICE_ALL_ACCESS = make_flag("SERVICE_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_INTERROGATE | SERVICE_USER_DEFINED_CONTROL )) -SERVICE_RUNS_IN_SYSTEM_PROCESS = make_flag("SERVICE_RUNS_IN_SYSTEM_PROCESS", 0x00000001) -SERVICE_KERNEL_DRIVER = make_flag("SERVICE_KERNEL_DRIVER", 0x00000001) -SERVICE_FILE_SYSTEM_DRIVER = make_flag("SERVICE_FILE_SYSTEM_DRIVER", 0x00000002) -SERVICE_ADAPTER = make_flag("SERVICE_ADAPTER", 0x00000004) -SERVICE_RECOGNIZER_DRIVER = make_flag("SERVICE_RECOGNIZER_DRIVER", 0x00000008) -SERVICE_DRIVER = make_flag("SERVICE_DRIVER", ( SERVICE_KERNEL_DRIVER | SERVICE_FILE_SYSTEM_DRIVER | SERVICE_RECOGNIZER_DRIVER )) -SERVICE_WIN32_OWN_PROCESS = make_flag("SERVICE_WIN32_OWN_PROCESS", 0x00000010) -SERVICE_WIN32_SHARE_PROCESS = make_flag("SERVICE_WIN32_SHARE_PROCESS", 0x00000020) -SERVICE_WIN32 = make_flag("SERVICE_WIN32", ( SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS )) -SERVICE_INTERACTIVE_PROCESS = make_flag("SERVICE_INTERACTIVE_PROCESS", 0x00000100) -SERVICE_TYPE_ALL = make_flag("SERVICE_TYPE_ALL", ( SERVICE_WIN32 | SERVICE_ADAPTER | SERVICE_DRIVER | SERVICE_INTERACTIVE_PROCESS )) -SERVICE_BOOT_START = make_flag("SERVICE_BOOT_START", 0x00000000) -SERVICE_SYSTEM_START = make_flag("SERVICE_SYSTEM_START", 0x00000001) -SERVICE_AUTO_START = make_flag("SERVICE_AUTO_START", 0x00000002) -SERVICE_DEMAND_START = make_flag("SERVICE_DEMAND_START", 0x00000003) -SERVICE_DISABLED = make_flag("SERVICE_DISABLED", 0x00000004) -SERVICE_ERROR_IGNORE = make_flag("SERVICE_ERROR_IGNORE", 0x00000000) -SERVICE_ERROR_NORMAL = make_flag("SERVICE_ERROR_NORMAL", 0x00000001) -SERVICE_ERROR_SEVERE = make_flag("SERVICE_ERROR_SEVERE", 0x00000002) -SERVICE_ERROR_CRITICAL = make_flag("SERVICE_ERROR_CRITICAL", 0x00000003) -SERVICE_ACTIVE = make_flag("SERVICE_ACTIVE", 0x00000001) -SERVICE_INACTIVE = make_flag("SERVICE_INACTIVE", 0x00000002) -SERVICE_STATE_ALL = make_flag("SERVICE_STATE_ALL", ( SERVICE_ACTIVE | SERVICE_INACTIVE )) -SERVICE_CONTROL_STOP = make_flag("SERVICE_CONTROL_STOP", 0x00000001) -SERVICE_CONTROL_PAUSE = make_flag("SERVICE_CONTROL_PAUSE", 0x00000002) -SERVICE_CONTROL_CONTINUE = make_flag("SERVICE_CONTROL_CONTINUE", 0x00000003) -SERVICE_CONTROL_INTERROGATE = make_flag("SERVICE_CONTROL_INTERROGATE", 0x00000004) -SERVICE_CONTROL_SHUTDOWN = make_flag("SERVICE_CONTROL_SHUTDOWN", 0x00000005) -SERVICE_CONTROL_PARAMCHANGE = make_flag("SERVICE_CONTROL_PARAMCHANGE", 0x00000006) -SERVICE_CONTROL_NETBINDADD = make_flag("SERVICE_CONTROL_NETBINDADD", 0x00000007) -SERVICE_CONTROL_NETBINDREMOVE = make_flag("SERVICE_CONTROL_NETBINDREMOVE", 0x00000008) -SERVICE_CONTROL_NETBINDENABLE = make_flag("SERVICE_CONTROL_NETBINDENABLE", 0x00000009) -SERVICE_CONTROL_NETBINDDISABLE = make_flag("SERVICE_CONTROL_NETBINDDISABLE", 0x0000000A) -SERVICE_CONTROL_DEVICEEVENT = make_flag("SERVICE_CONTROL_DEVICEEVENT", 0x0000000B) -SERVICE_CONTROL_HARDWAREPROFILECHANGE = make_flag("SERVICE_CONTROL_HARDWAREPROFILECHANGE", 0x0000000C) -SERVICE_CONTROL_POWEREVENT = make_flag("SERVICE_CONTROL_POWEREVENT", 0x0000000D) -SERVICE_CONTROL_SESSIONCHANGE = make_flag("SERVICE_CONTROL_SESSIONCHANGE", 0x0000000E) -SERVICE_CONTROL_PRESHUTDOWN = make_flag("SERVICE_CONTROL_PRESHUTDOWN", 0x0000000F) -SERVICE_CONTROL_TIMECHANGE = make_flag("SERVICE_CONTROL_TIMECHANGE", 0x00000010) -SERVICE_CONTROL_TRIGGEREVENT = make_flag("SERVICE_CONTROL_TRIGGEREVENT", 0x00000020) -SERVICE_STOPPED = make_flag("SERVICE_STOPPED", 0x00000001) -SERVICE_START_PENDING = make_flag("SERVICE_START_PENDING", 0x00000002) -SERVICE_STOP_PENDING = make_flag("SERVICE_STOP_PENDING", 0x00000003) -SERVICE_RUNNING = make_flag("SERVICE_RUNNING", 0x00000004) -SERVICE_CONTINUE_PENDING = make_flag("SERVICE_CONTINUE_PENDING", 0x00000005) -SERVICE_PAUSE_PENDING = make_flag("SERVICE_PAUSE_PENDING", 0x00000006) -SERVICE_PAUSED = make_flag("SERVICE_PAUSED", 0x00000007) -SERVICE_ACCEPT_STOP = make_flag("SERVICE_ACCEPT_STOP", 0x00000001) -SERVICE_ACCEPT_PAUSE_CONTINUE = make_flag("SERVICE_ACCEPT_PAUSE_CONTINUE", 0x00000002) -SERVICE_ACCEPT_SHUTDOWN = make_flag("SERVICE_ACCEPT_SHUTDOWN", 0x00000004) -SERVICE_ACCEPT_PARAMCHANGE = make_flag("SERVICE_ACCEPT_PARAMCHANGE", 0x00000008) -SERVICE_ACCEPT_NETBINDCHANGE = make_flag("SERVICE_ACCEPT_NETBINDCHANGE", 0x00000010) -SERVICE_ACCEPT_HARDWAREPROFILECHANGE = make_flag("SERVICE_ACCEPT_HARDWAREPROFILECHANGE", 0x00000020) -SERVICE_ACCEPT_POWEREVENT = make_flag("SERVICE_ACCEPT_POWEREVENT", 0x00000040) -SERVICE_ACCEPT_SESSIONCHANGE = make_flag("SERVICE_ACCEPT_SESSIONCHANGE", 0x00000080) -SERVICE_ACCEPT_PRESHUTDOWN = make_flag("SERVICE_ACCEPT_PRESHUTDOWN", 0x00000100) -SERVICE_ACCEPT_TIMECHANGE = make_flag("SERVICE_ACCEPT_TIMECHANGE", 0x00000200) -SERVICE_ACCEPT_TRIGGEREVENT = make_flag("SERVICE_ACCEPT_TRIGGEREVENT", 0x00000400) -DRIVE_UNKNOWN = make_flag("DRIVE_UNKNOWN", 0) -DRIVE_NO_ROOT_DIR = make_flag("DRIVE_NO_ROOT_DIR", 1) -DRIVE_REMOVABLE = make_flag("DRIVE_REMOVABLE", 2) -DRIVE_FIXED = make_flag("DRIVE_FIXED", 3) -DRIVE_REMOTE = make_flag("DRIVE_REMOTE", 4) -DRIVE_CDROM = make_flag("DRIVE_CDROM", 5) -DRIVE_RAMDISK = make_flag("DRIVE_RAMDISK", 6) -DUPLICATE_CLOSE_SOURCE = make_flag("DUPLICATE_CLOSE_SOURCE", 0x00000001) -DUPLICATE_SAME_ACCESS = make_flag("DUPLICATE_SAME_ACCESS", 0x00000002) -VER_NT_WORKSTATION = make_flag("VER_NT_WORKSTATION", 0x0000001) -VER_NT_DOMAIN_CONTROLLER = make_flag("VER_NT_DOMAIN_CONTROLLER", 0x0000002) -VER_NT_SERVER = make_flag("VER_NT_SERVER", 0x0000003) -SM_CXSCREEN = make_flag("SM_CXSCREEN", 0) -SM_CYSCREEN = make_flag("SM_CYSCREEN", 1) -SM_CXVSCROLL = make_flag("SM_CXVSCROLL", 2) -SM_CYHSCROLL = make_flag("SM_CYHSCROLL", 3) -SM_CYCAPTION = make_flag("SM_CYCAPTION", 4) -SM_CXBORDER = make_flag("SM_CXBORDER", 5) -SM_CYBORDER = make_flag("SM_CYBORDER", 6) -SM_CXDLGFRAME = make_flag("SM_CXDLGFRAME", 7) -SM_CYDLGFRAME = make_flag("SM_CYDLGFRAME", 8) -SM_CYVTHUMB = make_flag("SM_CYVTHUMB", 9) -SM_CXHTHUMB = make_flag("SM_CXHTHUMB", 10) -SM_CXICON = make_flag("SM_CXICON", 11) -SM_CYICON = make_flag("SM_CYICON", 12) -SM_CXCURSOR = make_flag("SM_CXCURSOR", 13) -SM_CYCURSOR = make_flag("SM_CYCURSOR", 14) -SM_CYMENU = make_flag("SM_CYMENU", 15) -SM_CXFULLSCREEN = make_flag("SM_CXFULLSCREEN", 16) -SM_CYFULLSCREEN = make_flag("SM_CYFULLSCREEN", 17) -SM_CYKANJIWINDOW = make_flag("SM_CYKANJIWINDOW", 18) -SM_MOUSEPRESENT = make_flag("SM_MOUSEPRESENT", 19) -SM_CYVSCROLL = make_flag("SM_CYVSCROLL", 20) -SM_CXHSCROLL = make_flag("SM_CXHSCROLL", 21) -SM_DEBUG = make_flag("SM_DEBUG", 22) -SM_SWAPBUTTON = make_flag("SM_SWAPBUTTON", 23) -SM_RESERVED1 = make_flag("SM_RESERVED1", 24) -SM_RESERVED2 = make_flag("SM_RESERVED2", 25) -SM_RESERVED3 = make_flag("SM_RESERVED3", 26) -SM_RESERVED4 = make_flag("SM_RESERVED4", 27) -SM_CXMIN = make_flag("SM_CXMIN", 28) -SM_CYMIN = make_flag("SM_CYMIN", 29) -SM_CXSIZE = make_flag("SM_CXSIZE", 30) -SM_CYSIZE = make_flag("SM_CYSIZE", 31) -SM_CXFRAME = make_flag("SM_CXFRAME", 32) -SM_CYFRAME = make_flag("SM_CYFRAME", 33) -SM_CXMINTRACK = make_flag("SM_CXMINTRACK", 34) -SM_CYMINTRACK = make_flag("SM_CYMINTRACK", 35) -SM_CXDOUBLECLK = make_flag("SM_CXDOUBLECLK", 36) -SM_CYDOUBLECLK = make_flag("SM_CYDOUBLECLK", 37) -SM_CXICONSPACING = make_flag("SM_CXICONSPACING", 38) -SM_CYICONSPACING = make_flag("SM_CYICONSPACING", 39) -SM_MENUDROPALIGNMENT = make_flag("SM_MENUDROPALIGNMENT", 40) -SM_PENWINDOWS = make_flag("SM_PENWINDOWS", 41) -SM_DBCSENABLED = make_flag("SM_DBCSENABLED", 42) -SM_CMOUSEBUTTONS = make_flag("SM_CMOUSEBUTTONS", 43) -SM_CXFIXEDFRAME = make_flag("SM_CXFIXEDFRAME", SM_CXDLGFRAME) -SM_CYFIXEDFRAME = make_flag("SM_CYFIXEDFRAME", SM_CYDLGFRAME) -SM_CXSIZEFRAME = make_flag("SM_CXSIZEFRAME", SM_CXFRAME) -SM_CYSIZEFRAME = make_flag("SM_CYSIZEFRAME", SM_CYFRAME) -SM_SECURE = make_flag("SM_SECURE", 44) -SM_CXEDGE = make_flag("SM_CXEDGE", 45) -SM_CYEDGE = make_flag("SM_CYEDGE", 46) -SM_CXMINSPACING = make_flag("SM_CXMINSPACING", 47) -SM_CYMINSPACING = make_flag("SM_CYMINSPACING", 48) -SM_CXSMICON = make_flag("SM_CXSMICON", 49) -SM_CYSMICON = make_flag("SM_CYSMICON", 50) -SM_CYSMCAPTION = make_flag("SM_CYSMCAPTION", 51) -SM_CXSMSIZE = make_flag("SM_CXSMSIZE", 52) -SM_CYSMSIZE = make_flag("SM_CYSMSIZE", 53) -SM_CXMENUSIZE = make_flag("SM_CXMENUSIZE", 54) -SM_CYMENUSIZE = make_flag("SM_CYMENUSIZE", 55) -SM_ARRANGE = make_flag("SM_ARRANGE", 56) -SM_CXMINIMIZED = make_flag("SM_CXMINIMIZED", 57) -SM_CYMINIMIZED = make_flag("SM_CYMINIMIZED", 58) -SM_CXMAXTRACK = make_flag("SM_CXMAXTRACK", 59) -SM_CYMAXTRACK = make_flag("SM_CYMAXTRACK", 60) -SM_CXMAXIMIZED = make_flag("SM_CXMAXIMIZED", 61) -SM_CYMAXIMIZED = make_flag("SM_CYMAXIMIZED", 62) -SM_NETWORK = make_flag("SM_NETWORK", 63) -SM_CLEANBOOT = make_flag("SM_CLEANBOOT", 67) -SM_CXDRAG = make_flag("SM_CXDRAG", 68) -SM_CYDRAG = make_flag("SM_CYDRAG", 69) -SM_SHOWSOUNDS = make_flag("SM_SHOWSOUNDS", 70) -SM_CXMENUCHECK = make_flag("SM_CXMENUCHECK", 71) -SM_CYMENUCHECK = make_flag("SM_CYMENUCHECK", 72) -SM_SLOWMACHINE = make_flag("SM_SLOWMACHINE", 73) -SM_MIDEASTENABLED = make_flag("SM_MIDEASTENABLED", 74) -SM_MOUSEWHEELPRESENT = make_flag("SM_MOUSEWHEELPRESENT", 75) -SM_XVIRTUALSCREEN = make_flag("SM_XVIRTUALSCREEN", 76) -SM_YVIRTUALSCREEN = make_flag("SM_YVIRTUALSCREEN", 77) -SM_CXVIRTUALSCREEN = make_flag("SM_CXVIRTUALSCREEN", 78) -SM_CYVIRTUALSCREEN = make_flag("SM_CYVIRTUALSCREEN", 79) -SM_CMONITORS = make_flag("SM_CMONITORS", 80) -SM_SAMEDISPLAYFORMAT = make_flag("SM_SAMEDISPLAYFORMAT", 81) -SM_IMMENABLED = make_flag("SM_IMMENABLED", 82) -SM_CXFOCUSBORDER = make_flag("SM_CXFOCUSBORDER", 83) -SM_CYFOCUSBORDER = make_flag("SM_CYFOCUSBORDER", 84) -SM_TABLETPC = make_flag("SM_TABLETPC", 86) -SM_MEDIACENTER = make_flag("SM_MEDIACENTER", 87) -SM_STARTER = make_flag("SM_STARTER", 88) -SM_SERVERR2 = make_flag("SM_SERVERR2", 89) -SM_MOUSEHORIZONTALWHEELPRESENT = make_flag("SM_MOUSEHORIZONTALWHEELPRESENT", 91) -SM_CXPADDEDBORDER = make_flag("SM_CXPADDEDBORDER", 92) -SM_DIGITIZER = make_flag("SM_DIGITIZER", 94) -SM_MAXIMUMTOUCHES = make_flag("SM_MAXIMUMTOUCHES", 95) -SM_REMOTESESSION = make_flag("SM_REMOTESESSION", 0x1000) -SM_SHUTTINGDOWN = make_flag("SM_SHUTTINGDOWN", 0x2000) -SM_REMOTECONTROL = make_flag("SM_REMOTECONTROL", 0x2001) -SM_CARETBLINKINGENABLED = make_flag("SM_CARETBLINKINGENABLED", 0x2002) -RPC_C_AUTHN_LEVEL_DEFAULT = make_flag("RPC_C_AUTHN_LEVEL_DEFAULT", 0) -RPC_C_AUTHN_LEVEL_NONE = make_flag("RPC_C_AUTHN_LEVEL_NONE", 1) -RPC_C_AUTHN_LEVEL_CONNECT = make_flag("RPC_C_AUTHN_LEVEL_CONNECT", 2) -RPC_C_AUTHN_LEVEL_CALL = make_flag("RPC_C_AUTHN_LEVEL_CALL", 3) -RPC_C_AUTHN_LEVEL_PKT = make_flag("RPC_C_AUTHN_LEVEL_PKT", 4) -RPC_C_AUTHN_LEVEL_PKT_INTEGRITY = make_flag("RPC_C_AUTHN_LEVEL_PKT_INTEGRITY", 5) -RPC_C_AUTHN_LEVEL_PKT_PRIVACY = make_flag("RPC_C_AUTHN_LEVEL_PKT_PRIVACY", 6) -RPC_C_IMP_LEVEL_DEFAULT = make_flag("RPC_C_IMP_LEVEL_DEFAULT", 0) -RPC_C_IMP_LEVEL_ANONYMOUS = make_flag("RPC_C_IMP_LEVEL_ANONYMOUS", 1) -RPC_C_IMP_LEVEL_IDENTIFY = make_flag("RPC_C_IMP_LEVEL_IDENTIFY", 2) -RPC_C_IMP_LEVEL_IMPERSONATE = make_flag("RPC_C_IMP_LEVEL_IMPERSONATE", 3) -RPC_C_IMP_LEVEL_DELEGATE = make_flag("RPC_C_IMP_LEVEL_DELEGATE", 4) -RPC_C_QOS_IDENTITY_STATIC = make_flag("RPC_C_QOS_IDENTITY_STATIC", 0) -RPC_C_QOS_IDENTITY_DYNAMIC = make_flag("RPC_C_QOS_IDENTITY_DYNAMIC", 1) -RPC_C_QOS_CAPABILITIES_DEFAULT = make_flag("RPC_C_QOS_CAPABILITIES_DEFAULT", 0x0) -RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH = make_flag("RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH", 0x1) -RPC_C_QOS_CAPABILITIES_MAKE_FULLSIC = make_flag("RPC_C_QOS_CAPABILITIES_MAKE_FULLSIC", 0x2) -RPC_C_QOS_CAPABILITIES_ANY_AUTHORITY = make_flag("RPC_C_QOS_CAPABILITIES_ANY_AUTHORITY", 0x4) -MAX_ADAPTER_NAME = make_flag("MAX_ADAPTER_NAME", 128) -MAXLEN_PHYSADDR = make_flag("MAXLEN_PHYSADDR", 8) -MAXLEN_IFDESCR = make_flag("MAXLEN_IFDESCR", 256) -MAX_INTERFACE_NAME_LEN = make_flag("MAX_INTERFACE_NAME_LEN", 256) -OBJ_INHERIT = make_flag("OBJ_INHERIT", 0x00000002) -OBJ_PERMANENT = make_flag("OBJ_PERMANENT", 0x00000010) -OBJ_EXCLUSIVE = make_flag("OBJ_EXCLUSIVE", 0x00000020) -OBJ_CASE_INSENSITIVE = make_flag("OBJ_CASE_INSENSITIVE", 0x00000040) -OBJ_OPENIF = make_flag("OBJ_OPENIF", 0x00000080) -OBJ_OPENLINK = make_flag("OBJ_OPENLINK", 0x00000100) -OBJ_KERNEL_HANDLE = make_flag("OBJ_KERNEL_HANDLE", 0x00000200) -OBJ_FORCE_ACCESS_CHECK = make_flag("OBJ_FORCE_ACCESS_CHECK", 0x00000400) -OBJ_VALID_ATTRIBUTES = make_flag("OBJ_VALID_ATTRIBUTES", 0x000007F2) -FILE_SUPERSEDE = make_flag("FILE_SUPERSEDE", 0x00000000) -FILE_OPEN = make_flag("FILE_OPEN", 0x00000001) -FILE_CREATE = make_flag("FILE_CREATE", 0x00000002) -FILE_OPEN_IF = make_flag("FILE_OPEN_IF", 0x00000003) -FILE_OVERWRITE = make_flag("FILE_OVERWRITE", 0x00000004) -FILE_OVERWRITE_IF = make_flag("FILE_OVERWRITE_IF", 0x00000005) -FILE_MAXIMUM_DISPOSITION = make_flag("FILE_MAXIMUM_DISPOSITION", 0x00000005) -TRUST_E_PROVIDER_UNKNOWN = make_flag("TRUST_E_PROVIDER_UNKNOWN", ( 0x800B0001 )) -TRUST_E_ACTION_UNKNOWN = make_flag("TRUST_E_ACTION_UNKNOWN", ( 0x800B0002 )) -TRUST_E_SUBJECT_FORM_UNKNOWN = make_flag("TRUST_E_SUBJECT_FORM_UNKNOWN", ( 0x800B0003 )) -DIGSIG_E_ENCODE = make_flag("DIGSIG_E_ENCODE", ( 0x800B0005 )) -TRUST_E_SUBJECT_NOT_TRUSTED = make_flag("TRUST_E_SUBJECT_NOT_TRUSTED", ( 0x800B0004 )) -DIGSIG_E_DECODE = make_flag("DIGSIG_E_DECODE", ( 0x800B0006 )) -DIGSIG_E_EXTENSIBILITY = make_flag("DIGSIG_E_EXTENSIBILITY", ( 0x800B0007 )) -PERSIST_E_SIZEDEFINITE = make_flag("PERSIST_E_SIZEDEFINITE", ( 0x800B0009 )) -DIGSIG_E_CRYPTO = make_flag("DIGSIG_E_CRYPTO", ( 0x800B0008 )) -PERSIST_E_SIZEINDEFINITE = make_flag("PERSIST_E_SIZEINDEFINITE", ( 0x800B000A )) -PERSIST_E_NOTSELFSIZING = make_flag("PERSIST_E_NOTSELFSIZING", ( 0x800B000B )) -TRUST_E_NOSIGNATURE = make_flag("TRUST_E_NOSIGNATURE", ( 0x800B0100 )) -TRUST_E_BAD_DIGEST = make_flag("TRUST_E_BAD_DIGEST", ( 0x80096010 )) -CERT_E_EXPIRED = make_flag("CERT_E_EXPIRED", ( 0x800B0101 )) -CERT_E_VALIDITYPERIODNESTING = make_flag("CERT_E_VALIDITYPERIODNESTING", ( 0x800B0102 )) -CERT_E_PURPOSE = make_flag("CERT_E_PURPOSE", ( 0x800B0106 )) -CERT_E_ISSUERCHAINING = make_flag("CERT_E_ISSUERCHAINING", ( 0x800B0107 )) -CERT_E_MALFORMED = make_flag("CERT_E_MALFORMED", ( 0x800B0108 )) -CERT_E_UNTRUSTEDROOT = make_flag("CERT_E_UNTRUSTEDROOT", ( 0x800B0109 )) -CERT_E_CHAINING = make_flag("CERT_E_CHAINING", ( 0x800B010A )) -TRUST_E_FAIL = make_flag("TRUST_E_FAIL", ( 0x800B010B )) -CERT_E_REVOKED = make_flag("CERT_E_REVOKED", ( 0x800B010C )) -CERT_E_UNTRUSTEDTESTROOT = make_flag("CERT_E_UNTRUSTEDTESTROOT", ( 0x800B010D )) -CERT_E_REVOCATION_FAILURE = make_flag("CERT_E_REVOCATION_FAILURE", ( 0x800B010E )) -CERT_E_CN_NO_MATCH = make_flag("CERT_E_CN_NO_MATCH", ( 0x800B010F )) -CERT_E_WRONG_USAGE = make_flag("CERT_E_WRONG_USAGE", ( 0x800B0110 )) -TRUST_E_EXPLICIT_DISTRUST = make_flag("TRUST_E_EXPLICIT_DISTRUST", ( 0x800B0111 )) -CERT_E_UNTRUSTEDCA = make_flag("CERT_E_UNTRUSTEDCA", ( 0x800B0112 )) -CERT_E_INVALID_POLICY = make_flag("CERT_E_INVALID_POLICY", ( 0x800B0113 )) -CERT_E_INVALID_NAME = make_flag("CERT_E_INVALID_NAME", ( 0x800B0114 )) -CRYPT_E_FILE_ERROR = make_flag("CRYPT_E_FILE_ERROR", ( 0x80092003 )) -CRYPT_E_MSG_ERROR = make_flag("CRYPT_E_MSG_ERROR", ( 0x80091001 )) -CRYPT_E_UNKNOWN_ALGO = make_flag("CRYPT_E_UNKNOWN_ALGO", ( 0x80091002 )) -CRYPT_E_OID_FORMAT = make_flag("CRYPT_E_OID_FORMAT", ( 0x80091003 )) -CRYPT_E_INVALID_MSG_TYPE = make_flag("CRYPT_E_INVALID_MSG_TYPE", ( 0x80091004 )) -CRYPT_E_UNEXPECTED_ENCODING = make_flag("CRYPT_E_UNEXPECTED_ENCODING", ( 0x80091005 )) -CRYPT_E_AUTH_ATTR_MISSING = make_flag("CRYPT_E_AUTH_ATTR_MISSING", ( 0x80091006 )) -CRYPT_E_HASH_VALUE = make_flag("CRYPT_E_HASH_VALUE", ( 0x80091007 )) -E_INVALIDARG = make_flag("E_INVALIDARG", ( 0x80070057 )) -CRYPT_E_NOT_DECRYPTED = make_flag("CRYPT_E_NOT_DECRYPTED", ( 0x8009100A )) -CRYPT_E_INVALID_INDEX = make_flag("CRYPT_E_INVALID_INDEX", ( 0x80091008 )) -CRYPT_E_ATTRIBUTES_MISSING = make_flag("CRYPT_E_ATTRIBUTES_MISSING", ( 0x8009100F )) -IMAGE_SCN_TYPE_REG = make_flag("IMAGE_SCN_TYPE_REG", 0x00000000) -IMAGE_SCN_TYPE_DSECT = make_flag("IMAGE_SCN_TYPE_DSECT", 0x00000001) -IMAGE_SCN_TYPE_NOLOAD = make_flag("IMAGE_SCN_TYPE_NOLOAD", 0x00000002) -IMAGE_SCN_TYPE_GROUP = make_flag("IMAGE_SCN_TYPE_GROUP", 0x00000004) -IMAGE_SCN_TYPE_NO_PAD = make_flag("IMAGE_SCN_TYPE_NO_PAD", 0x00000008) -IMAGE_SCN_TYPE_COPY = make_flag("IMAGE_SCN_TYPE_COPY", 0x00000010) -IMAGE_SCN_CNT_CODE = make_flag("IMAGE_SCN_CNT_CODE", 0x00000020) -IMAGE_SCN_CNT_INITIALIZED_DATA = make_flag("IMAGE_SCN_CNT_INITIALIZED_DATA", 0x00000040) -IMAGE_SCN_CNT_UNINITIALIZED_DATA = make_flag("IMAGE_SCN_CNT_UNINITIALIZED_DATA", 0x00000080) -IMAGE_SCN_LNK_OTHER = make_flag("IMAGE_SCN_LNK_OTHER", 0x00000100) -IMAGE_SCN_LNK_INFO = make_flag("IMAGE_SCN_LNK_INFO", 0x00000200) -IMAGE_SCN_TYPE_OVER = make_flag("IMAGE_SCN_TYPE_OVER", 0x00000400) -IMAGE_SCN_LNK_REMOVE = make_flag("IMAGE_SCN_LNK_REMOVE", 0x00000800) -IMAGE_SCN_LNK_COMDAT = make_flag("IMAGE_SCN_LNK_COMDAT", 0x00001000) -IMAGE_SCN_NO_DEFER_SPEC_EXC = make_flag("IMAGE_SCN_NO_DEFER_SPEC_EXC", 0x00004000) -IMAGE_SCN_GPREL = make_flag("IMAGE_SCN_GPREL", 0x00008000) -IMAGE_SCN_MEM_FARDATA = make_flag("IMAGE_SCN_MEM_FARDATA", 0x00008000) -IMAGE_SCN_MEM_PURGEABLE = make_flag("IMAGE_SCN_MEM_PURGEABLE", 0x00020000) -IMAGE_SCN_MEM_16BIT = make_flag("IMAGE_SCN_MEM_16BIT", 0x00020000) -IMAGE_SCN_MEM_LOCKED = make_flag("IMAGE_SCN_MEM_LOCKED", 0x00040000) -IMAGE_SCN_MEM_PRELOAD = make_flag("IMAGE_SCN_MEM_PRELOAD", 0x00080000) -IMAGE_SCN_ALIGN_1BYTES = make_flag("IMAGE_SCN_ALIGN_1BYTES", 0x00100000) -IMAGE_SCN_ALIGN_2BYTES = make_flag("IMAGE_SCN_ALIGN_2BYTES", 0x00200000) -IMAGE_SCN_ALIGN_4BYTES = make_flag("IMAGE_SCN_ALIGN_4BYTES", 0x00300000) -IMAGE_SCN_ALIGN_8BYTES = make_flag("IMAGE_SCN_ALIGN_8BYTES", 0x00400000) -IMAGE_SCN_ALIGN_16BYTES = make_flag("IMAGE_SCN_ALIGN_16BYTES", 0x00500000) -IMAGE_SCN_ALIGN_32BYTES = make_flag("IMAGE_SCN_ALIGN_32BYTES", 0x00600000) -IMAGE_SCN_ALIGN_64BYTES = make_flag("IMAGE_SCN_ALIGN_64BYTES", 0x00700000) -IMAGE_SCN_ALIGN_128BYTES = make_flag("IMAGE_SCN_ALIGN_128BYTES", 0x00800000) -IMAGE_SCN_ALIGN_256BYTES = make_flag("IMAGE_SCN_ALIGN_256BYTES", 0x00900000) -IMAGE_SCN_ALIGN_512BYTES = make_flag("IMAGE_SCN_ALIGN_512BYTES", 0x00A00000) -IMAGE_SCN_ALIGN_1024BYTES = make_flag("IMAGE_SCN_ALIGN_1024BYTES", 0x00B00000) -IMAGE_SCN_ALIGN_2048BYTES = make_flag("IMAGE_SCN_ALIGN_2048BYTES", 0x00C00000) -IMAGE_SCN_ALIGN_4096BYTES = make_flag("IMAGE_SCN_ALIGN_4096BYTES", 0x00D00000) -IMAGE_SCN_ALIGN_8192BYTES = make_flag("IMAGE_SCN_ALIGN_8192BYTES", 0x00E00000) -IMAGE_SCN_ALIGN_MASK = make_flag("IMAGE_SCN_ALIGN_MASK", 0x00F00000) -IMAGE_SCN_LNK_NRELOC_OVFL = make_flag("IMAGE_SCN_LNK_NRELOC_OVFL", 0x01000000) -IMAGE_SCN_MEM_DISCARDABLE = make_flag("IMAGE_SCN_MEM_DISCARDABLE", 0x02000000) -IMAGE_SCN_MEM_NOT_CACHED = make_flag("IMAGE_SCN_MEM_NOT_CACHED", 0x04000000) -IMAGE_SCN_MEM_NOT_PAGED = make_flag("IMAGE_SCN_MEM_NOT_PAGED", 0x08000000) -IMAGE_SCN_MEM_SHARED = make_flag("IMAGE_SCN_MEM_SHARED", 0x10000000) -IMAGE_SCN_MEM_EXECUTE = make_flag("IMAGE_SCN_MEM_EXECUTE", 0x20000000) -IMAGE_SCN_MEM_READ = make_flag("IMAGE_SCN_MEM_READ", 0x40000000) -IMAGE_SCN_MEM_WRITE = make_flag("IMAGE_SCN_MEM_WRITE", 0x80000000) -LPC_REQUEST = make_flag("LPC_REQUEST", 1) -LPC_REPLY = make_flag("LPC_REPLY", 2) -LPC_DATAGRAM = make_flag("LPC_DATAGRAM", 3) -LPC_LOST_REPLY = make_flag("LPC_LOST_REPLY", 4) -LPC_PORT_CLOSED = make_flag("LPC_PORT_CLOSED", 5) -LPC_CLIENT_DIED = make_flag("LPC_CLIENT_DIED", 6) -LPC_EXCEPTION = make_flag("LPC_EXCEPTION", 7) -LPC_DEBUG_EVENT = make_flag("LPC_DEBUG_EVENT", 8) -LPC_ERROR_EVENT = make_flag("LPC_ERROR_EVENT", 9) -LPC_CONNECTION_REQUEST = make_flag("LPC_CONNECTION_REQUEST", 10) -ALPC_MESSAGE_SECURITY_ATTRIBUTE = make_flag("ALPC_MESSAGE_SECURITY_ATTRIBUTE", 0x80000000) -ALPC_MESSAGE_VIEW_ATTRIBUTE = make_flag("ALPC_MESSAGE_VIEW_ATTRIBUTE", 0x40000000) -ALPC_MESSAGE_CONTEXT_ATTRIBUTE = make_flag("ALPC_MESSAGE_CONTEXT_ATTRIBUTE", 0x20000000) -ALPC_MESSAGE_HANDLE_ATTRIBUTE = make_flag("ALPC_MESSAGE_HANDLE_ATTRIBUTE", 0x10000000) -ALPC_MESSAGE_TOKEN_ATTRIBUTE = make_flag("ALPC_MESSAGE_TOKEN_ATTRIBUTE", 0x8000000) -ALPC_MESSAGE_DIRECT_ATTRIBUTE = make_flag("ALPC_MESSAGE_DIRECT_ATTRIBUTE", 0x4000000) -ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE = make_flag("ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE", 0x2000000) -ALPC_MSGFLG_REPLY_MESSAGE = make_flag("ALPC_MSGFLG_REPLY_MESSAGE", 0x1) -ALPC_MSGFLG_LPC_MODE = make_flag("ALPC_MSGFLG_LPC_MODE", 0x2) -ALPC_MSGFLG_RELEASE_MESSAGE = make_flag("ALPC_MSGFLG_RELEASE_MESSAGE", 0x10000) -ALPC_MSGFLG_SYNC_REQUEST = make_flag("ALPC_MSGFLG_SYNC_REQUEST", 0x20000) -ALPC_MSGFLG_WAIT_USER_MODE = make_flag("ALPC_MSGFLG_WAIT_USER_MODE", 0x100000) -ALPC_MSGFLG_WAIT_ALERTABLE = make_flag("ALPC_MSGFLG_WAIT_ALERTABLE", 0x200000) -ALPC_MSGFLG_WOW64_CALL = make_flag("ALPC_MSGFLG_WOW64_CALL", 0x80000000) -ALPC_PORFLG_ALLOW_LPC_REQUESTS = make_flag("ALPC_PORFLG_ALLOW_LPC_REQUESTS", 0x20000) -ALPC_PORFLG_WAITABLE_PORT = make_flag("ALPC_PORFLG_WAITABLE_PORT", 0x40000) -ALPC_PORFLG_SYSTEM_PROCESS = make_flag("ALPC_PORFLG_SYSTEM_PROCESS", 0x100000) -ALPC_CANCELFLG_TRY_CANCEL = make_flag("ALPC_CANCELFLG_TRY_CANCEL", 0x1) -ALPC_CANCELFLG_NO_CONTEXT_CHECK = make_flag("ALPC_CANCELFLG_NO_CONTEXT_CHECK", 0x8) -ALPC_CANCELFLGP_FLUSH = make_flag("ALPC_CANCELFLGP_FLUSH", 0x10000) -ALPC_HANDLEFLG_DUPLICATE_SAME_ACCESS = make_flag("ALPC_HANDLEFLG_DUPLICATE_SAME_ACCESS", 0x10000) -ALPC_HANDLEFLG_DUPLICATE_SAME_ATTRIBUTES = make_flag("ALPC_HANDLEFLG_DUPLICATE_SAME_ATTRIBUTES", 0x20000) -ALPC_HANDLEFLG_DUPLICATE_INHERIT = make_flag("ALPC_HANDLEFLG_DUPLICATE_INHERIT", 0x80000) -ALPC_SECFLG_CREATE_HANDLE = make_flag("ALPC_SECFLG_CREATE_HANDLE", 0x20000) -ALPC_VIEWFLG_NOT_SECURE = make_flag("ALPC_VIEWFLG_NOT_SECURE", 0x40000) -CERT_STORE_CERTIFICATE_CONTEXT = make_flag("CERT_STORE_CERTIFICATE_CONTEXT", 1) -CERT_STORE_CRL_CONTEXT = make_flag("CERT_STORE_CRL_CONTEXT", 2) -CERT_STORE_CTL_CONTEXT = make_flag("CERT_STORE_CTL_CONTEXT", 3) -WTD_UI_ALL = make_flag("WTD_UI_ALL", 1) -WTD_UI_NONE = make_flag("WTD_UI_NONE", 2) -WTD_UI_NOBAD = make_flag("WTD_UI_NOBAD", 3) -WTD_UI_NOGOOD = make_flag("WTD_UI_NOGOOD", 4) -WTD_REVOKE_NONE = make_flag("WTD_REVOKE_NONE", 0x00000000) -WTD_REVOKE_WHOLECHAIN = make_flag("WTD_REVOKE_WHOLECHAIN", 0x00000001) -WTD_CHOICE_FILE = make_flag("WTD_CHOICE_FILE", 1) -WTD_CHOICE_CATALOG = make_flag("WTD_CHOICE_CATALOG", 2) -WTD_CHOICE_BLOB = make_flag("WTD_CHOICE_BLOB", 3) -WTD_CHOICE_SIGNER = make_flag("WTD_CHOICE_SIGNER", 4) -WTD_CHOICE_CERT = make_flag("WTD_CHOICE_CERT", 5) -WTD_STATEACTION_IGNORE = make_flag("WTD_STATEACTION_IGNORE", 0x00000000) -WTD_STATEACTION_VERIFY = make_flag("WTD_STATEACTION_VERIFY", 0x00000001) -WTD_STATEACTION_CLOSE = make_flag("WTD_STATEACTION_CLOSE", 0x00000002) -WTD_STATEACTION_AUTO_CACHE = make_flag("WTD_STATEACTION_AUTO_CACHE", 0x00000003) -WTD_STATEACTION_AUTO_CACHE_FLUSH = make_flag("WTD_STATEACTION_AUTO_CACHE_FLUSH", 0x00000004) -COMPRESSION_FORMAT_NONE = make_flag("COMPRESSION_FORMAT_NONE", ( 0x0000 )) -COMPRESSION_FORMAT_DEFAULT = make_flag("COMPRESSION_FORMAT_DEFAULT", ( 0x0001 )) -COMPRESSION_FORMAT_LZNT1 = make_flag("COMPRESSION_FORMAT_LZNT1", ( 0x0002 )) -COMPRESSION_FORMAT_XPRESS = make_flag("COMPRESSION_FORMAT_XPRESS", ( 0x0003 )) -COMPRESSION_FORMAT_XPRESS_HUFF = make_flag("COMPRESSION_FORMAT_XPRESS_HUFF", ( 0x0004 )) -COMPRESSION_ENGINE_STANDARD = make_flag("COMPRESSION_ENGINE_STANDARD", ( 0x0000 )) -COMPRESSION_ENGINE_MAXIMUM = make_flag("COMPRESSION_ENGINE_MAXIMUM", ( 0x0100 )) -COMPRESSION_ENGINE_HIBER = make_flag("COMPRESSION_ENGINE_HIBER", ( 0x0200 )) -FILE_DIRECTORY_FILE = make_flag("FILE_DIRECTORY_FILE", 0x00000001) -FILE_WRITE_THROUGH = make_flag("FILE_WRITE_THROUGH", 0x00000002) -FILE_SEQUENTIAL_ONLY = make_flag("FILE_SEQUENTIAL_ONLY", 0x00000004) -FILE_NO_INTERMEDIATE_BUFFERING = make_flag("FILE_NO_INTERMEDIATE_BUFFERING", 0x00000008) -FILE_SYNCHRONOUS_IO_ALERT = make_flag("FILE_SYNCHRONOUS_IO_ALERT", 0x00000010) -FILE_SYNCHRONOUS_IO_NONALERT = make_flag("FILE_SYNCHRONOUS_IO_NONALERT", 0x00000020) -FILE_NON_DIRECTORY_FILE = make_flag("FILE_NON_DIRECTORY_FILE", 0x00000040) -FILE_CREATE_TREE_CONNECTION = make_flag("FILE_CREATE_TREE_CONNECTION", 0x00000080) -FILE_COMPLETE_IF_OPLOCKED = make_flag("FILE_COMPLETE_IF_OPLOCKED", 0x00000100) -FILE_NO_EA_KNOWLEDGE = make_flag("FILE_NO_EA_KNOWLEDGE", 0x00000200) -FILE_OPEN_REMOTE_INSTANCE = make_flag("FILE_OPEN_REMOTE_INSTANCE", 0x00000400) -FILE_RANDOM_ACCESS = make_flag("FILE_RANDOM_ACCESS", 0x00000800) -FILE_DELETE_ON_CLOSE = make_flag("FILE_DELETE_ON_CLOSE", 0x00001000) -FILE_OPEN_BY_FILE_ID = make_flag("FILE_OPEN_BY_FILE_ID", 0x00002000) -FILE_OPEN_FOR_BACKUP_INTENT = make_flag("FILE_OPEN_FOR_BACKUP_INTENT", 0x00004000) -FILE_NO_COMPRESSION = make_flag("FILE_NO_COMPRESSION", 0x00008000) -FILE_OPEN_REQUIRING_OPLOCK = make_flag("FILE_OPEN_REQUIRING_OPLOCK", 0x00010000) -FILE_RESERVE_OPFILTER = make_flag("FILE_RESERVE_OPFILTER", 0x00100000) -FILE_OPEN_REPARSE_POINT = make_flag("FILE_OPEN_REPARSE_POINT", 0x00200000) -FILE_OPEN_NO_RECALL = make_flag("FILE_OPEN_NO_RECALL", 0x00400000) -FILE_OPEN_FOR_FREE_SPACE_QUERY = make_flag("FILE_OPEN_FOR_FREE_SPACE_QUERY", 0x00800000) -FILE_VALID_OPTION_FLAGS = make_flag("FILE_VALID_OPTION_FLAGS", 0x00ffffff) -FILE_VALID_PIPE_OPTION_FLAGS = make_flag("FILE_VALID_PIPE_OPTION_FLAGS", 0x00000032) -FILE_VALID_MAILSLOT_OPTION_FLAGS = make_flag("FILE_VALID_MAILSLOT_OPTION_FLAGS", 0x00000032) -FILE_VALID_SET_FLAGS = make_flag("FILE_VALID_SET_FLAGS", 0x00000036) -FILE_SUPERSEDED = make_flag("FILE_SUPERSEDED", 0x00000000) -FILE_OPENED = make_flag("FILE_OPENED", 0x00000001) -FILE_CREATED = make_flag("FILE_CREATED", 0x00000002) -FILE_OVERWRITTEN = make_flag("FILE_OVERWRITTEN", 0x00000003) -FILE_EXISTS = make_flag("FILE_EXISTS", 0x00000004) -FILE_DOES_NOT_EXIST = make_flag("FILE_DOES_NOT_EXIST", 0x00000005) -API_SET_SCHEMA_VERSION_V2 = make_flag("API_SET_SCHEMA_VERSION_V2", 0x00000002) -API_SET_SCHEMA_VERSION_V3 = make_flag("API_SET_SCHEMA_VERSION_V3", 0x00000003) -API_SET_SCHEMA_VERSION_V4 = make_flag("API_SET_SCHEMA_VERSION_V4", 0x00000004) -API_SET_LOAD_SCHEMA_ORDINAL = make_flag("API_SET_LOAD_SCHEMA_ORDINAL", 1) -API_SET_LOOKUP_ORDINAL = make_flag("API_SET_LOOKUP_ORDINAL", 2) -API_SET_RELEASE_SCHEMA_ORDINAL = make_flag("API_SET_RELEASE_SCHEMA_ORDINAL", 3) -API_SET_SCHEMA_FLAGS_SEALED = make_flag("API_SET_SCHEMA_FLAGS_SEALED", 0x00000001) -API_SET_SCHEMA_FLAGS_HOST_EXTENSION = make_flag("API_SET_SCHEMA_FLAGS_HOST_EXTENSION", 0x00000002) -API_SET_SCHEMA_ENTRY_FLAGS_SEALED = make_flag("API_SET_SCHEMA_ENTRY_FLAGS_SEALED", 0x00000001) -API_SET_SCHEMA_ENTRY_FLAGS_EXTENSION = make_flag("API_SET_SCHEMA_ENTRY_FLAGS_EXTENSION", 0x00000002) -CMSG_VERIFY_SIGNER_PUBKEY = make_flag("CMSG_VERIFY_SIGNER_PUBKEY", 1) -CMSG_VERIFY_SIGNER_CERT = make_flag("CMSG_VERIFY_SIGNER_CERT", 2) -CMSG_VERIFY_SIGNER_CHAIN = make_flag("CMSG_VERIFY_SIGNER_CHAIN", 3) -CMSG_VERIFY_SIGNER_NULL = make_flag("CMSG_VERIFY_SIGNER_NULL", 4) -TXFS_MINIVERSION_COMMITTED_VIEW = make_flag("TXFS_MINIVERSION_COMMITTED_VIEW", ( 0x0000 )) -TXFS_MINIVERSION_DIRTY_VIEW = make_flag("TXFS_MINIVERSION_DIRTY_VIEW", ( 0xFFFF )) -TXFS_MINIVERSION_DEFAULT_VIEW = make_flag("TXFS_MINIVERSION_DEFAULT_VIEW", ( 0xFFFE )) -TOKEN_SOURCE_LENGTH = make_flag("TOKEN_SOURCE_LENGTH", 8) -SID_HASH_SIZE = make_flag("SID_HASH_SIZE", 32) -TOKEN_MANDATORY_POLICY_OFF = make_flag("TOKEN_MANDATORY_POLICY_OFF", 0x0) -TOKEN_MANDATORY_POLICY_NO_WRITE_UP = make_flag("TOKEN_MANDATORY_POLICY_NO_WRITE_UP", 0x1) -TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN = make_flag("TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN", 0x2) -TOKEN_MANDATORY_POLICY_VALID_MASK = make_flag("TOKEN_MANDATORY_POLICY_VALID_MASK", ( TOKEN_MANDATORY_POLICY_NO_WRITE_UP | TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN )) -TOKEN_SECURITY_ATTRIBUTE_TYPE_INVALID = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_INVALID", 0x00) -TOKEN_SECURITY_ATTRIBUTE_TYPE_INT64 = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_INT64", 0x01) -TOKEN_SECURITY_ATTRIBUTE_TYPE_UINT64 = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_UINT64", 0x02) -TOKEN_SECURITY_ATTRIBUTE_TYPE_STRING = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_STRING", 0x03) -TOKEN_SECURITY_ATTRIBUTE_TYPE_FQBN = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_FQBN", 0x04) -TOKEN_SECURITY_ATTRIBUTE_TYPE_SID = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_SID", 0x05) -TOKEN_SECURITY_ATTRIBUTE_TYPE_BOOLEAN = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_BOOLEAN", 0x06) -TOKEN_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING = make_flag("TOKEN_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING", 0x10) -TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE = make_flag("TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE", 0x0001) -TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE = make_flag("TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE", 0x0002) -TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY = make_flag("TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY", 0x0004) -TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT = make_flag("TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT", 0x0008) -TOKEN_SECURITY_ATTRIBUTE_DISABLED = make_flag("TOKEN_SECURITY_ATTRIBUTE_DISABLED", 0x0010) -TOKEN_SECURITY_ATTRIBUTE_MANDATORY = make_flag("TOKEN_SECURITY_ATTRIBUTE_MANDATORY", 0x0020) -TOKEN_SECURITY_ATTRIBUTE_VALID_FLAGS = make_flag("TOKEN_SECURITY_ATTRIBUTE_VALID_FLAGS", ( TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE | TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE | TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY | TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT | TOKEN_SECURITY_ATTRIBUTE_DISABLED | TOKEN_SECURITY_ATTRIBUTE_MANDATORY )) -TOKEN_SECURITY_ATTRIBUTE_CUSTOM_FLAGS = make_flag("TOKEN_SECURITY_ATTRIBUTE_CUSTOM_FLAGS", 0xffff0000) -TOKEN_ASSIGN_PRIMARY = make_flag("TOKEN_ASSIGN_PRIMARY", ( 0x0001 )) -TOKEN_DUPLICATE = make_flag("TOKEN_DUPLICATE", ( 0x0002 )) -TOKEN_IMPERSONATE = make_flag("TOKEN_IMPERSONATE", ( 0x0004 )) -TOKEN_QUERY = make_flag("TOKEN_QUERY", ( 0x0008 )) -TOKEN_QUERY_SOURCE = make_flag("TOKEN_QUERY_SOURCE", ( 0x0010 )) -TOKEN_ADJUST_PRIVILEGES = make_flag("TOKEN_ADJUST_PRIVILEGES", ( 0x0020 )) -TOKEN_ADJUST_GROUPS = make_flag("TOKEN_ADJUST_GROUPS", ( 0x0040 )) -TOKEN_ADJUST_DEFAULT = make_flag("TOKEN_ADJUST_DEFAULT", ( 0x0080 )) -TOKEN_ADJUST_SESSIONID = make_flag("TOKEN_ADJUST_SESSIONID", ( 0x0100 )) -TOKEN_ALL_ACCESS_P = make_flag("TOKEN_ALL_ACCESS_P", ( STANDARD_RIGHTS_REQUIRED | TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_QUERY_SOURCE | TOKEN_ADJUST_PRIVILEGES | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT )) -TOKEN_ALL_ACCESS = make_flag("TOKEN_ALL_ACCESS", ( TOKEN_ALL_ACCESS_P | TOKEN_ADJUST_SESSIONID )) -SE_PRIVILEGE_ENABLED_BY_DEFAULT = make_flag("SE_PRIVILEGE_ENABLED_BY_DEFAULT", ( 0x00000001 )) -SE_PRIVILEGE_ENABLED = make_flag("SE_PRIVILEGE_ENABLED", ( 0x00000002 )) -SE_PRIVILEGE_REMOVED = make_flag("SE_PRIVILEGE_REMOVED", ( 0X00000004 )) -SE_PRIVILEGE_USED_FOR_ACCESS = make_flag("SE_PRIVILEGE_USED_FOR_ACCESS", ( 0x80000000 )) -SE_CREATE_TOKEN_NAME = make_flag("SE_CREATE_TOKEN_NAME", ( "SeCreateTokenPrivilege" )) -SE_ASSIGNPRIMARYTOKEN_NAME = make_flag("SE_ASSIGNPRIMARYTOKEN_NAME", ( "SeAssignPrimaryTokenPrivilege" )) -SE_LOCK_MEMORY_NAME = make_flag("SE_LOCK_MEMORY_NAME", ( "SeLockMemoryPrivilege" )) -SE_INCREASE_QUOTA_NAME = make_flag("SE_INCREASE_QUOTA_NAME", ( "SeIncreaseQuotaPrivilege" )) -SE_UNSOLICITED_INPUT_NAME = make_flag("SE_UNSOLICITED_INPUT_NAME", ( "SeUnsolicitedInputPrivilege" )) -SE_MACHINE_ACCOUNT_NAME = make_flag("SE_MACHINE_ACCOUNT_NAME", ( "SeMachineAccountPrivilege" )) -SE_TCB_NAME = make_flag("SE_TCB_NAME", ( "SeTcbPrivilege" )) -SE_SECURITY_NAME = make_flag("SE_SECURITY_NAME", ( "SeSecurityPrivilege" )) -SE_TAKE_OWNERSHIP_NAME = make_flag("SE_TAKE_OWNERSHIP_NAME", ( "SeTakeOwnershipPrivilege" )) -SE_LOAD_DRIVER_NAME = make_flag("SE_LOAD_DRIVER_NAME", ( "SeLoadDriverPrivilege" )) -SE_SYSTEM_PROFILE_NAME = make_flag("SE_SYSTEM_PROFILE_NAME", ( "SeSystemProfilePrivilege" )) -SE_SYSTEMTIME_NAME = make_flag("SE_SYSTEMTIME_NAME", ( "SeSystemtimePrivilege" )) -SE_PROF_SINGLE_PROCESS_NAME = make_flag("SE_PROF_SINGLE_PROCESS_NAME", ( "SeProfileSingleProcessPrivilege" )) -SE_INC_BASE_PRIORITY_NAME = make_flag("SE_INC_BASE_PRIORITY_NAME", ( "SeIncreaseBasePriorityPrivilege" )) -SE_CREATE_PAGEFILE_NAME = make_flag("SE_CREATE_PAGEFILE_NAME", ( "SeCreatePagefilePrivilege" )) -SE_CREATE_PERMANENT_NAME = make_flag("SE_CREATE_PERMANENT_NAME", ( "SeCreatePermanentPrivilege" )) -SE_BACKUP_NAME = make_flag("SE_BACKUP_NAME", ( "SeBackupPrivilege" )) -SE_RESTORE_NAME = make_flag("SE_RESTORE_NAME", ( "SeRestorePrivilege" )) -SE_SHUTDOWN_NAME = make_flag("SE_SHUTDOWN_NAME", ( "SeShutdownPrivilege" )) -SE_DEBUG_NAME = make_flag("SE_DEBUG_NAME", ( "SeDebugPrivilege" )) -SE_AUDIT_NAME = make_flag("SE_AUDIT_NAME", ( "SeAuditPrivilege" )) -SE_SYSTEM_ENVIRONMENT_NAME = make_flag("SE_SYSTEM_ENVIRONMENT_NAME", ( "SeSystemEnvironmentPrivilege" )) -SE_CHANGE_NOTIFY_NAME = make_flag("SE_CHANGE_NOTIFY_NAME", ( "SeChangeNotifyPrivilege" )) -SE_REMOTE_SHUTDOWN_NAME = make_flag("SE_REMOTE_SHUTDOWN_NAME", ( "SeRemoteShutdownPrivilege" )) -SE_UNDOCK_NAME = make_flag("SE_UNDOCK_NAME", ( "SeUndockPrivilege" )) -SE_SYNC_AGENT_NAME = make_flag("SE_SYNC_AGENT_NAME", ( "SeSyncAgentPrivilege" )) -SE_ENABLE_DELEGATION_NAME = make_flag("SE_ENABLE_DELEGATION_NAME", ( "SeEnableDelegationPrivilege" )) -SE_MANAGE_VOLUME_NAME = make_flag("SE_MANAGE_VOLUME_NAME", ( "SeManageVolumePrivilege" )) -SE_IMPERSONATE_NAME = make_flag("SE_IMPERSONATE_NAME", ( "SeImpersonatePrivilege" )) -SE_CREATE_GLOBAL_NAME = make_flag("SE_CREATE_GLOBAL_NAME", ( "SeCreateGlobalPrivilege" )) -SE_TRUSTED_CREDMAN_ACCESS_NAME = make_flag("SE_TRUSTED_CREDMAN_ACCESS_NAME", ( "SeTrustedCredManAccessPrivilege" )) -SE_RELABEL_NAME = make_flag("SE_RELABEL_NAME", ( "SeRelabelPrivilege" )) -SE_INC_WORKING_SET_NAME = make_flag("SE_INC_WORKING_SET_NAME", ( "SeIncreaseWorkingSetPrivilege" )) -SE_TIME_ZONE_NAME = make_flag("SE_TIME_ZONE_NAME", ( "SeTimeZonePrivilege" )) -SE_CREATE_SYMBOLIC_LINK_NAME = make_flag("SE_CREATE_SYMBOLIC_LINK_NAME", ( "SeCreateSymbolicLinkPrivilege" )) -ACCESS_SYSTEM_SECURITY = make_flag("ACCESS_SYSTEM_SECURITY", ( 0x01000000 )) -MAXIMUM_ALLOWED = make_flag("MAXIMUM_ALLOWED", ( 0x02000000 )) -FILE_READ_DATA = make_flag("FILE_READ_DATA", ( 0x0001 )) -FILE_LIST_DIRECTORY = make_flag("FILE_LIST_DIRECTORY", ( 0x0001 )) -FILE_WRITE_DATA = make_flag("FILE_WRITE_DATA", ( 0x0002 )) -FILE_ADD_FILE = make_flag("FILE_ADD_FILE", ( 0x0002 )) -FILE_APPEND_DATA = make_flag("FILE_APPEND_DATA", ( 0x0004 )) -FILE_ADD_SUBDIRECTORY = make_flag("FILE_ADD_SUBDIRECTORY", ( 0x0004 )) -FILE_CREATE_PIPE_INSTANCE = make_flag("FILE_CREATE_PIPE_INSTANCE", ( 0x0004 )) -FILE_READ_EA = make_flag("FILE_READ_EA", ( 0x0008 )) -FILE_WRITE_EA = make_flag("FILE_WRITE_EA", ( 0x0010 )) -FILE_EXECUTE = make_flag("FILE_EXECUTE", ( 0x0020 )) -FILE_TRAVERSE = make_flag("FILE_TRAVERSE", ( 0x0020 )) -FILE_DELETE_CHILD = make_flag("FILE_DELETE_CHILD", ( 0x0040 )) -FILE_READ_ATTRIBUTES = make_flag("FILE_READ_ATTRIBUTES", ( 0x0080 )) -FILE_WRITE_ATTRIBUTES = make_flag("FILE_WRITE_ATTRIBUTES", ( 0x0100 )) -FILE_ALL_ACCESS = make_flag("FILE_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF )) -FILE_GENERIC_READ = make_flag("FILE_GENERIC_READ", ( STANDARD_RIGHTS_READ | FILE_READ_DATA | FILE_READ_ATTRIBUTES | FILE_READ_EA | SYNCHRONIZE )) -FILE_GENERIC_WRITE = make_flag("FILE_GENERIC_WRITE", ( STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE )) -FILE_GENERIC_EXECUTE = make_flag("FILE_GENERIC_EXECUTE", ( STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES | FILE_EXECUTE | SYNCHRONIZE )) -CALLBACK_MODIFY_STATE = make_flag("CALLBACK_MODIFY_STATE", 0x0001) -CALLBACK_ALL_ACCESS = make_flag("CALLBACK_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE| CALLBACK_MODIFY_STATE )) -EVENT_QUERY_STATE = make_flag("EVENT_QUERY_STATE", 0x0001) -EVENT_MODIFY_STATE = make_flag("EVENT_MODIFY_STATE", 0x0002) -EVENT_ALL_ACCESS = make_flag("EVENT_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3 )) -MUTANT_QUERY_STATE = make_flag("MUTANT_QUERY_STATE", 0x0001) -MUTANT_ALL_ACCESS = make_flag("MUTANT_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE| MUTANT_QUERY_STATE )) -SEMAPHORE_QUERY_STATE = make_flag("SEMAPHORE_QUERY_STATE", 0x0001) -SEMAPHORE_MODIFY_STATE = make_flag("SEMAPHORE_MODIFY_STATE", 0x0002) -SEMAPHORE_ALL_ACCESS = make_flag("SEMAPHORE_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3 )) -TIMER_QUERY_STATE = make_flag("TIMER_QUERY_STATE", 0x0001) -TIMER_MODIFY_STATE = make_flag("TIMER_MODIFY_STATE", 0x0002) -TIMER_ALL_ACCESS = make_flag("TIMER_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE| TIMER_QUERY_STATE|TIMER_MODIFY_STATE )) -IO_COMPLETION_QUERY_STATE = make_flag("IO_COMPLETION_QUERY_STATE", 0x0001) -IO_COMPLETION_MODIFY_STATE = make_flag("IO_COMPLETION_MODIFY_STATE", 0x0002) -IO_COMPLETION_ALL_ACCESS = make_flag("IO_COMPLETION_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3 )) -PORT_CONNECT = make_flag("PORT_CONNECT", ( 0x0001 )) -PORT_ALL_ACCESS = make_flag("PORT_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1 )) -OBJECT_TYPE_CREATE = make_flag("OBJECT_TYPE_CREATE", ( 0x0001 )) -OBJECT_TYPE_ALL_ACCESS = make_flag("OBJECT_TYPE_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | 0x1 )) -DIRECTORY_QUERY = make_flag("DIRECTORY_QUERY", ( 0x0001 )) -DIRECTORY_TRAVERSE = make_flag("DIRECTORY_TRAVERSE", ( 0x0002 )) -DIRECTORY_CREATE_OBJECT = make_flag("DIRECTORY_CREATE_OBJECT", ( 0x0004 )) -DIRECTORY_CREATE_SUBDIRECTORY = make_flag("DIRECTORY_CREATE_SUBDIRECTORY", ( 0x0008 )) -DIRECTORY_ALL_ACCESS = make_flag("DIRECTORY_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | 0xF )) -SYMBOLIC_LINK_QUERY = make_flag("SYMBOLIC_LINK_QUERY", ( 0x0001 )) -SYMBOLIC_LINK_ALL_ACCESS = make_flag("SYMBOLIC_LINK_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | 0x1 )) -PROCESS_TERMINATE = make_flag("PROCESS_TERMINATE", ( 0x0001 )) -PROCESS_CREATE_THREAD = make_flag("PROCESS_CREATE_THREAD", ( 0x0002 )) -PROCESS_SET_SESSIONID = make_flag("PROCESS_SET_SESSIONID", ( 0x0004 )) -PROCESS_VM_OPERATION = make_flag("PROCESS_VM_OPERATION", ( 0x0008 )) -PROCESS_VM_READ = make_flag("PROCESS_VM_READ", ( 0x0010 )) -PROCESS_VM_WRITE = make_flag("PROCESS_VM_WRITE", ( 0x0020 )) -PROCESS_DUP_HANDLE = make_flag("PROCESS_DUP_HANDLE", ( 0x0040 )) -PROCESS_CREATE_PROCESS = make_flag("PROCESS_CREATE_PROCESS", ( 0x0080 )) -PROCESS_SET_QUOTA = make_flag("PROCESS_SET_QUOTA", ( 0x0100 )) -PROCESS_SET_INFORMATION = make_flag("PROCESS_SET_INFORMATION", ( 0x0200 )) -PROCESS_QUERY_INFORMATION = make_flag("PROCESS_QUERY_INFORMATION", ( 0x0400 )) -PROCESS_SUSPEND_RESUME = make_flag("PROCESS_SUSPEND_RESUME", ( 0x0800 )) -PROCESS_QUERY_LIMITED_INFORMATION = make_flag("PROCESS_QUERY_LIMITED_INFORMATION", ( 0x1000 )) -PROCESS_SET_LIMITED_INFORMATION = make_flag("PROCESS_SET_LIMITED_INFORMATION", ( 0x2000 )) -PROCESS_ALL_ACCESS = make_flag("PROCESS_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF )) -THREAD_TERMINATE = make_flag("THREAD_TERMINATE", ( 0x0001 )) -THREAD_SUSPEND_RESUME = make_flag("THREAD_SUSPEND_RESUME", ( 0x0002 )) -THREAD_GET_CONTEXT = make_flag("THREAD_GET_CONTEXT", ( 0x0008 )) -THREAD_SET_CONTEXT = make_flag("THREAD_SET_CONTEXT", ( 0x0010 )) -THREAD_QUERY_INFORMATION = make_flag("THREAD_QUERY_INFORMATION", ( 0x0040 )) -THREAD_SET_INFORMATION = make_flag("THREAD_SET_INFORMATION", ( 0x0020 )) -THREAD_SET_THREAD_TOKEN = make_flag("THREAD_SET_THREAD_TOKEN", ( 0x0080 )) -THREAD_IMPERSONATE = make_flag("THREAD_IMPERSONATE", ( 0x0100 )) -THREAD_DIRECT_IMPERSONATION = make_flag("THREAD_DIRECT_IMPERSONATION", ( 0x0200 )) -THREAD_ALL_ACCESS = make_flag("THREAD_ALL_ACCESS", 0x001F03FF) -JOB_OBJECT_ASSIGN_PROCESS = make_flag("JOB_OBJECT_ASSIGN_PROCESS", ( 0x0001 )) -JOB_OBJECT_SET_ATTRIBUTES = make_flag("JOB_OBJECT_SET_ATTRIBUTES", ( 0x0002 )) -JOB_OBJECT_QUERY = make_flag("JOB_OBJECT_QUERY", ( 0x0004 )) -JOB_OBJECT_TERMINATE = make_flag("JOB_OBJECT_TERMINATE", ( 0x0008 )) -JOB_OBJECT_SET_SECURITY_ATTRIBUTES = make_flag("JOB_OBJECT_SET_SECURITY_ATTRIBUTES", ( 0x0010 )) -JOB_OBJECT_ALL_ACCESS = make_flag("JOB_OBJECT_ALL_ACCESS", ( STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1F )) -KEY_QUERY_VALUE = make_flag("KEY_QUERY_VALUE", ( 0x0001 )) -KEY_SET_VALUE = make_flag("KEY_SET_VALUE", ( 0x0002 )) -KEY_CREATE_SUB_KEY = make_flag("KEY_CREATE_SUB_KEY", ( 0x0004 )) -KEY_ENUMERATE_SUB_KEYS = make_flag("KEY_ENUMERATE_SUB_KEYS", ( 0x0008 )) -KEY_NOTIFY = make_flag("KEY_NOTIFY", ( 0x0010 )) -KEY_CREATE_LINK = make_flag("KEY_CREATE_LINK", ( 0x0020 )) -KEY_WOW64_32KEY = make_flag("KEY_WOW64_32KEY", ( 0x0200 )) -KEY_WOW64_64KEY = make_flag("KEY_WOW64_64KEY", ( 0x0100 )) -KEY_WOW64_RES = make_flag("KEY_WOW64_RES", ( 0x0300 )) -KEY_READ = make_flag("KEY_READ", ( ( STANDARD_RIGHTS_READ|KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY ) & ( ~SYNCHRONIZE ) )) -KEY_WRITE = make_flag("KEY_WRITE", ( ( STANDARD_RIGHTS_WRITE|KEY_SET_VALUE|KEY_CREATE_SUB_KEY ) & ( ~SYNCHRONIZE ) )) -KEY_EXECUTE = make_flag("KEY_EXECUTE", ( ( KEY_READ ) & ( ~SYNCHRONIZE ) )) -KEY_ALL_ACCESS = make_flag("KEY_ALL_ACCESS", ( ( STANDARD_RIGHTS_ALL|KEY_QUERY_VALUE|KEY_SET_VALUE|KEY_CREATE_SUB_KEY|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY|KEY_CREATE_LINK ) & ( ~SYNCHRONIZE ) )) -CLUSAPI_READ_ACCESS = make_flag("CLUSAPI_READ_ACCESS", 0x00000001) -CLUSAPI_CHANGE_ACCESS = make_flag("CLUSAPI_CHANGE_ACCESS", 0x00000002) -CLUSAPI_NO_ACCESS = make_flag("CLUSAPI_NO_ACCESS", 0x00000004) -CLUSAPI_ALL_ACCESS = make_flag("CLUSAPI_ALL_ACCESS", ( CLUSAPI_READ_ACCESS | CLUSAPI_CHANGE_ACCESS )) -FAX_JOB_SUBMIT = make_flag("FAX_JOB_SUBMIT", ( 0x0001 )) -FAX_JOB_QUERY = make_flag("FAX_JOB_QUERY", ( 0x0002 )) -FAX_CONFIG_QUERY = make_flag("FAX_CONFIG_QUERY", ( 0x0004 )) -FAX_CONFIG_SET = make_flag("FAX_CONFIG_SET", ( 0x0008 )) -FAX_PORT_QUERY = make_flag("FAX_PORT_QUERY", ( 0x0010 )) -FAX_PORT_SET = make_flag("FAX_PORT_SET", ( 0x0020 )) -FAX_JOB_MANAGE = make_flag("FAX_JOB_MANAGE", ( 0x0040 )) -COM_EXECUTE = make_flag("COM_EXECUTE", ( 0x0001 )) -COM_EXECUTE_LOCAL = make_flag("COM_EXECUTE_LOCAL", ( 0x0002 )) -COM_EXECUTE_REMOTE = make_flag("COM_EXECUTE_REMOTE", ( 0x0004 )) -COM_ACTIVATE_LOCAL = make_flag("COM_ACTIVATE_LOCAL", ( 0x0008 )) -COM_ACTIVATE_REMOTE = make_flag("COM_ACTIVATE_REMOTE", ( 0x0010 )) diff --git a/windows/generated_def/winfuncs.py b/windows/generated_def/winfuncs.py index d5b243c..a47f06c 100644 --- a/windows/generated_def/winfuncs.py +++ b/windows/generated_def/winfuncs.py @@ -5,255 +5,20 @@ from winstructs import * ObjectFromLresultPrototype = WINFUNCTYPE(HRESULT, LRESULT, REFIID, WPARAM, POINTER(PVOID)) ObjectFromLresultParams = ((1, 'lResult'), (1, 'riid'), (1, 'wParam'), (1, 'ppvObject')) -#def CoInitializeEx(pvReserved, dwCoInit): -# return CoInitializeEx.ctypes_function(pvReserved, dwCoInit) -CoInitializeExPrototype = WINFUNCTYPE(HRESULT, LPVOID, DWORD) -CoInitializeExParams = ((1, 'pvReserved'), (1, 'dwCoInit')) +#def StrStrIW(pszFirst, pszSrch): +# return StrStrIW.ctypes_function(pszFirst, pszSrch) +StrStrIWPrototype = WINFUNCTYPE(PWSTR, PWSTR, PWSTR) +StrStrIWParams = ((1, 'pszFirst'), (1, 'pszSrch')) -#def CoInitializeSecurity(pSecDesc, cAuthSvc, asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pAuthList, dwCapabilities, pReserved3): -# return CoInitializeSecurity.ctypes_function(pSecDesc, cAuthSvc, asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pAuthList, dwCapabilities, pReserved3) -CoInitializeSecurityPrototype = WINFUNCTYPE(HRESULT, PSECURITY_DESCRIPTOR, LONG, POINTER(SOLE_AUTHENTICATION_SERVICE), PVOID, DWORD, DWORD, PVOID, DWORD, PVOID) -CoInitializeSecurityParams = ((1, 'pSecDesc'), (1, 'cAuthSvc'), (1, 'asAuthSvc'), (1, 'pReserved1'), (1, 'dwAuthnLevel'), (1, 'dwImpLevel'), (1, 'pAuthList'), (1, 'dwCapabilities'), (1, 'pReserved3')) +#def StrStrIA(pszFirst, pszSrch): +# return StrStrIA.ctypes_function(pszFirst, pszSrch) +StrStrIAPrototype = WINFUNCTYPE(PCSTR, PCSTR, PCSTR) +StrStrIAParams = ((1, 'pszFirst'), (1, 'pszSrch')) -#def CoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv): -# return CoCreateInstance.ctypes_function(rclsid, pUnkOuter, dwClsContext, riid, ppv) -CoCreateInstancePrototype = WINFUNCTYPE(HRESULT, REFCLSID, LPUNKNOWN, DWORD, REFIID, POINTER(LPVOID)) -CoCreateInstanceParams = ((1, 'rclsid'), (1, 'pUnkOuter'), (1, 'dwClsContext'), (1, 'riid'), (1, 'ppv')) - -#def CoCreateInstanceEx(rclsid, punkOuter, dwClsCtx, pServerInfo, dwCount, pResults): -# return CoCreateInstanceEx.ctypes_function(rclsid, punkOuter, dwClsCtx, pServerInfo, dwCount, pResults) -CoCreateInstanceExPrototype = WINFUNCTYPE(HRESULT, REFCLSID, POINTER(IUnknown), DWORD, POINTER(COSERVERINFO), DWORD, POINTER(MULTI_QI)) -CoCreateInstanceExParams = ((1, 'rclsid'), (1, 'punkOuter'), (1, 'dwClsCtx'), (1, 'pServerInfo'), (1, 'dwCount'), (1, 'pResults')) - -#def CoGetInterceptor(iidIntercepted, punkOuter, iid, ppv): -# return CoGetInterceptor.ctypes_function(iidIntercepted, punkOuter, iid, ppv) -CoGetInterceptorPrototype = WINFUNCTYPE(HRESULT, REFIID, POINTER(IUnknown), REFIID, POINTER(PVOID)) -CoGetInterceptorParams = ((1, 'iidIntercepted'), (1, 'punkOuter'), (1, 'iid'), (1, 'ppv')) - -#def CLSIDFromProgID(lpszProgID, lpclsid): -# return CLSIDFromProgID.ctypes_function(lpszProgID, lpclsid) -CLSIDFromProgIDPrototype = WINFUNCTYPE(HRESULT, LPCOLESTR, LPCLSID) -CLSIDFromProgIDParams = ((1, 'lpszProgID'), (1, 'lpclsid')) - -#def GetCursorPos(lpPoint): -# return GetCursorPos.ctypes_function(lpPoint) -GetCursorPosPrototype = WINFUNCTYPE(BOOL, LPPOINT) -GetCursorPosParams = ((1, 'lpPoint'),) - -#def WindowFromPoint(Point): -# return WindowFromPoint.ctypes_function(Point) -WindowFromPointPrototype = WINFUNCTYPE(HWND, POINT) -WindowFromPointParams = ((1, 'Point'),) - -#def GetWindowRect(hWnd, lpRect): -# return GetWindowRect.ctypes_function(hWnd, lpRect) -GetWindowRectPrototype = WINFUNCTYPE(BOOL, HWND, LPRECT) -GetWindowRectParams = ((1, 'hWnd'), (1, 'lpRect')) - -#def EnumWindows(lpEnumFunc, lParam): -# return EnumWindows.ctypes_function(lpEnumFunc, lParam) -EnumWindowsPrototype = WINFUNCTYPE(BOOL, WNDENUMPROC, LPARAM) -EnumWindowsParams = ((1, 'lpEnumFunc'), (1, 'lParam')) - -#def GetWindowTextA(hWnd, lpString, nMaxCount): -# return GetWindowTextA.ctypes_function(hWnd, lpString, nMaxCount) -GetWindowTextAPrototype = WINFUNCTYPE(INT, HWND, LPSTR, INT) -GetWindowTextAParams = ((1, 'hWnd'), (1, 'lpString'), (1, 'nMaxCount')) - -#def GetParent(hWnd): -# return GetParent.ctypes_function(hWnd) -GetParentPrototype = WINFUNCTYPE(HWND, HWND) -GetParentParams = ((1, 'hWnd'),) - -#def GetWindowTextW(hWnd, lpString, nMaxCount): -# return GetWindowTextW.ctypes_function(hWnd, lpString, nMaxCount) -GetWindowTextWPrototype = WINFUNCTYPE(INT, HWND, LPWSTR, INT) -GetWindowTextWParams = ((1, 'hWnd'), (1, 'lpString'), (1, 'nMaxCount')) - -#def GetWindowModuleFileNameA(hwnd, pszFileName, cchFileNameMax): -# return GetWindowModuleFileNameA.ctypes_function(hwnd, pszFileName, cchFileNameMax) -GetWindowModuleFileNameAPrototype = WINFUNCTYPE(UINT, HWND, LPSTR, UINT) -GetWindowModuleFileNameAParams = ((1, 'hwnd'), (1, 'pszFileName'), (1, 'cchFileNameMax')) - -#def GetWindowModuleFileNameW(hwnd, pszFileName, cchFileNameMax): -# return GetWindowModuleFileNameW.ctypes_function(hwnd, pszFileName, cchFileNameMax) -GetWindowModuleFileNameWPrototype = WINFUNCTYPE(UINT, HWND, LPWSTR, UINT) -GetWindowModuleFileNameWParams = ((1, 'hwnd'), (1, 'pszFileName'), (1, 'cchFileNameMax')) - -#def EnumChildWindows(hWndParent, lpEnumFunc, lParam): -# return EnumChildWindows.ctypes_function(hWndParent, lpEnumFunc, lParam) -EnumChildWindowsPrototype = WINFUNCTYPE(BOOL, HWND, WNDENUMPROC, LPARAM) -EnumChildWindowsParams = ((1, 'hWndParent'), (1, 'lpEnumFunc'), (1, 'lParam')) - -#def CloseWindow(hWnd): -# return CloseWindow.ctypes_function(hWnd) -CloseWindowPrototype = WINFUNCTYPE(BOOL, HWND) -CloseWindowParams = ((1, 'hWnd'),) - -#def GetDesktopWindow(): -# return GetDesktopWindow.ctypes_function() -GetDesktopWindowPrototype = WINFUNCTYPE(HWND) -GetDesktopWindowParams = () - -#def GetForegroundWindow(): -# return GetForegroundWindow.ctypes_function() -GetForegroundWindowPrototype = WINFUNCTYPE(HWND) -GetForegroundWindowParams = () - -#def BringWindowToTop(hWnd): -# return BringWindowToTop.ctypes_function(hWnd) -BringWindowToTopPrototype = WINFUNCTYPE(BOOL, HWND) -BringWindowToTopParams = ((1, 'hWnd'),) - -#def MoveWindow(hWnd, X, Y, nWidth, nHeight, bRepaint): -# return MoveWindow.ctypes_function(hWnd, X, Y, nWidth, nHeight, bRepaint) -MoveWindowPrototype = WINFUNCTYPE(BOOL, HWND, INT, INT, INT, INT, BOOL) -MoveWindowParams = ((1, 'hWnd'), (1, 'X'), (1, 'Y'), (1, 'nWidth'), (1, 'nHeight'), (1, 'bRepaint')) - -#def SetWindowPos(hWnd, hWndInsertAfter, X, Y, cx, cy, uFlags): -# return SetWindowPos.ctypes_function(hWnd, hWndInsertAfter, X, Y, cx, cy, uFlags) -SetWindowPosPrototype = WINFUNCTYPE(BOOL, HWND, HWND, INT, INT, INT, INT, UINT) -SetWindowPosParams = ((1, 'hWnd'), (1, 'hWndInsertAfter'), (1, 'X'), (1, 'Y'), (1, 'cx'), (1, 'cy'), (1, 'uFlags')) - -#def SetWindowTextA(hWnd, lpString): -# return SetWindowTextA.ctypes_function(hWnd, lpString) -SetWindowTextAPrototype = WINFUNCTYPE(BOOL, HWND, LPCSTR) -SetWindowTextAParams = ((1, 'hWnd'), (1, 'lpString')) - -#def SetWindowTextW(hWnd, lpString): -# return SetWindowTextW.ctypes_function(hWnd, lpString) -SetWindowTextWPrototype = WINFUNCTYPE(BOOL, HWND, LPWSTR) -SetWindowTextWParams = ((1, 'hWnd'), (1, 'lpString')) - -#def RealGetWindowClassA(hwnd, pszType, cchType): -# return RealGetWindowClassA.ctypes_function(hwnd, pszType, cchType) -RealGetWindowClassAPrototype = WINFUNCTYPE(UINT, HWND, LPCSTR, UINT) -RealGetWindowClassAParams = ((1, 'hwnd'), (1, 'pszType'), (1, 'cchType')) - -#def RealGetWindowClassW(hwnd, pszType, cchType): -# return RealGetWindowClassW.ctypes_function(hwnd, pszType, cchType) -RealGetWindowClassWPrototype = WINFUNCTYPE(UINT, HWND, LPWSTR, UINT) -RealGetWindowClassWParams = ((1, 'hwnd'), (1, 'pszType'), (1, 'cchType')) - -#def GetClassInfoExA(hinst, lpszClass, lpwcx): -# return GetClassInfoExA.ctypes_function(hinst, lpszClass, lpwcx) -GetClassInfoExAPrototype = WINFUNCTYPE(BOOL, HINSTANCE, LPCSTR, LPWNDCLASSEXA) -GetClassInfoExAParams = ((1, 'hinst'), (1, 'lpszClass'), (1, 'lpwcx')) - -#def GetClassInfoExW(hinst, lpszClass, lpwcx): -# return GetClassInfoExW.ctypes_function(hinst, lpszClass, lpwcx) -GetClassInfoExWPrototype = WINFUNCTYPE(BOOL, HINSTANCE, LPCWSTR, LPWNDCLASSEXW) -GetClassInfoExWParams = ((1, 'hinst'), (1, 'lpszClass'), (1, 'lpwcx')) - -#def GetClassNameA(hWnd, lpClassName, nMaxCount): -# return GetClassNameA.ctypes_function(hWnd, lpClassName, nMaxCount) -GetClassNameAPrototype = WINFUNCTYPE(INT, HWND, LPCSTR, INT) -GetClassNameAParams = ((1, 'hWnd'), (1, 'lpClassName'), (1, 'nMaxCount')) - -#def GetClassNameW(hWnd, lpClassName, nMaxCount): -# return GetClassNameW.ctypes_function(hWnd, lpClassName, nMaxCount) -GetClassNameWPrototype = WINFUNCTYPE(INT, HWND, LPWSTR, INT) -GetClassNameWParams = ((1, 'hWnd'), (1, 'lpClassName'), (1, 'nMaxCount')) - -#def GetWindowThreadProcessId(hWnd, lpdwProcessId): -# return GetWindowThreadProcessId.ctypes_function(hWnd, lpdwProcessId) -GetWindowThreadProcessIdPrototype = WINFUNCTYPE(DWORD, HWND, LPDWORD) -GetWindowThreadProcessIdParams = ((1, 'hWnd'), (1, 'lpdwProcessId')) - -#def FindWindowA(lpClassName, lpWindowName): -# return FindWindowA.ctypes_function(lpClassName, lpWindowName) -FindWindowAPrototype = WINFUNCTYPE(HWND, LPCSTR, LPCSTR) -FindWindowAParams = ((1, 'lpClassName'), (1, 'lpWindowName')) - -#def FindWindowW(lpClassName, lpWindowName): -# return FindWindowW.ctypes_function(lpClassName, lpWindowName) -FindWindowWPrototype = WINFUNCTYPE(HWND, LPCWSTR, LPCWSTR) -FindWindowWParams = ((1, 'lpClassName'), (1, 'lpWindowName')) - -#def CreateFileTransactedA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile, hTransaction, pusMiniVersion, pExtendedParameter): -# return CreateFileTransactedA.ctypes_function(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile, hTransaction, pusMiniVersion, pExtendedParameter) -CreateFileTransactedAPrototype = WINFUNCTYPE(HANDLE, LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE, HANDLE, PUSHORT, PVOID) -CreateFileTransactedAParams = ((1, 'lpFileName'), (1, 'dwDesiredAccess'), (1, 'dwShareMode'), (1, 'lpSecurityAttributes'), (1, 'dwCreationDisposition'), (1, 'dwFlagsAndAttributes'), (1, 'hTemplateFile'), (1, 'hTransaction'), (1, 'pusMiniVersion'), (1, 'pExtendedParameter')) - -#def CreateFileTransactedW(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile, hTransaction, pusMiniVersion, pExtendedParameter): -# return CreateFileTransactedW.ctypes_function(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile, hTransaction, pusMiniVersion, pExtendedParameter) -CreateFileTransactedWPrototype = WINFUNCTYPE(HANDLE, LPWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE, HANDLE, PUSHORT, PVOID) -CreateFileTransactedWParams = ((1, 'lpFileName'), (1, 'dwDesiredAccess'), (1, 'dwShareMode'), (1, 'lpSecurityAttributes'), (1, 'dwCreationDisposition'), (1, 'dwFlagsAndAttributes'), (1, 'hTemplateFile'), (1, 'hTransaction'), (1, 'pusMiniVersion'), (1, 'pExtendedParameter')) - -#def CommitTransaction(TransactionHandle): -# return CommitTransaction.ctypes_function(TransactionHandle) -CommitTransactionPrototype = WINFUNCTYPE(BOOL, HANDLE) -CommitTransactionParams = ((1, 'TransactionHandle'),) - -#def CreateTransaction(lpTransactionAttributes, UOW, CreateOptions, IsolationLevel, IsolationFlags, Timeout, Description): -# return CreateTransaction.ctypes_function(lpTransactionAttributes, UOW, CreateOptions, IsolationLevel, IsolationFlags, Timeout, Description) -CreateTransactionPrototype = WINFUNCTYPE(HANDLE, LPSECURITY_ATTRIBUTES, LPGUID, DWORD, DWORD, DWORD, DWORD, LPWSTR) -CreateTransactionParams = ((1, 'lpTransactionAttributes'), (1, 'UOW'), (1, 'CreateOptions'), (1, 'IsolationLevel'), (1, 'IsolationFlags'), (1, 'Timeout'), (1, 'Description')) - -#def RollbackTransaction(TransactionHandle): -# return RollbackTransaction.ctypes_function(TransactionHandle) -RollbackTransactionPrototype = WINFUNCTYPE(BOOL, HANDLE) -RollbackTransactionParams = ((1, 'TransactionHandle'),) - -#def OpenTransaction(dwDesiredAccess, TransactionId): -# return OpenTransaction.ctypes_function(dwDesiredAccess, TransactionId) -OpenTransactionPrototype = WINFUNCTYPE(HANDLE, DWORD, LPGUID) -OpenTransactionParams = ((1, 'dwDesiredAccess'), (1, 'TransactionId')) - -#def CreatePipe(hReadPipe, hWritePipe, lpPipeAttributes, nSize): -# return CreatePipe.ctypes_function(hReadPipe, hWritePipe, lpPipeAttributes, nSize) -CreatePipePrototype = WINFUNCTYPE(BOOL, PHANDLE, PHANDLE, LPSECURITY_ATTRIBUTES, DWORD) -CreatePipeParams = ((1, 'hReadPipe'), (1, 'hWritePipe'), (1, 'lpPipeAttributes'), (1, 'nSize')) - -#def CreateNamedPipeA(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes): -# return CreateNamedPipeA.ctypes_function(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes) -CreateNamedPipeAPrototype = WINFUNCTYPE(HANDLE, LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES) -CreateNamedPipeAParams = ((1, 'lpName'), (1, 'dwOpenMode'), (1, 'dwPipeMode'), (1, 'nMaxInstances'), (1, 'nOutBufferSize'), (1, 'nInBufferSize'), (1, 'nDefaultTimeOut'), (1, 'lpSecurityAttributes')) - -#def CreateNamedPipeW(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes): -# return CreateNamedPipeW.ctypes_function(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes) -CreateNamedPipeWPrototype = WINFUNCTYPE(HANDLE, LPWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES) -CreateNamedPipeWParams = ((1, 'lpName'), (1, 'dwOpenMode'), (1, 'dwPipeMode'), (1, 'nMaxInstances'), (1, 'nOutBufferSize'), (1, 'nInBufferSize'), (1, 'nDefaultTimeOut'), (1, 'lpSecurityAttributes')) - -#def ConnectNamedPipe(hNamedPipe, lpOverlapped): -# return ConnectNamedPipe.ctypes_function(hNamedPipe, lpOverlapped) -ConnectNamedPipePrototype = WINFUNCTYPE(BOOL, HANDLE, LPOVERLAPPED) -ConnectNamedPipeParams = ((1, 'hNamedPipe'), (1, 'lpOverlapped')) - -#def SetNamedPipeHandleState(hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout): -# return SetNamedPipeHandleState.ctypes_function(hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout) -SetNamedPipeHandleStatePrototype = WINFUNCTYPE(BOOL, HANDLE, LPDWORD, LPDWORD, LPDWORD) -SetNamedPipeHandleStateParams = ((1, 'hNamedPipe'), (1, 'lpMode'), (1, 'lpMaxCollectionCount'), (1, 'lpCollectDataTimeout')) - -#def PeekNamedPipe(hNamedPipe, lpBuffer, nBufferSize, lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage): -# return PeekNamedPipe.ctypes_function(hNamedPipe, lpBuffer, nBufferSize, lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage) -PeekNamedPipePrototype = WINFUNCTYPE(BOOL, HANDLE, LPVOID, DWORD, LPDWORD, LPDWORD, LPDWORD) -PeekNamedPipeParams = ((1, 'hNamedPipe'), (1, 'lpBuffer'), (1, 'nBufferSize'), (1, 'lpBytesRead'), (1, 'lpTotalBytesAvail'), (1, 'lpBytesLeftThisMessage')) - -#def ShellExecuteA(hwnd, lpOperation, lpFile, lpParameters, lpDirectory, nShowCmd): -# return ShellExecuteA.ctypes_function(hwnd, lpOperation, lpFile, lpParameters, lpDirectory, nShowCmd) -ShellExecuteAPrototype = WINFUNCTYPE(HINSTANCE, HWND, LPCSTR, LPCSTR, LPCSTR, LPCSTR, INT) -ShellExecuteAParams = ((1, 'hwnd'), (1, 'lpOperation'), (1, 'lpFile'), (1, 'lpParameters'), (1, 'lpDirectory'), (1, 'nShowCmd')) - -#def ShellExecuteW(hwnd, lpOperation, lpFile, lpParameters, lpDirectory, nShowCmd): -# return ShellExecuteW.ctypes_function(hwnd, lpOperation, lpFile, lpParameters, lpDirectory, nShowCmd) -ShellExecuteWPrototype = WINFUNCTYPE(HINSTANCE, HWND, LPWSTR, LPWSTR, LPWSTR, LPWSTR, INT) -ShellExecuteWParams = ((1, 'hwnd'), (1, 'lpOperation'), (1, 'lpFile'), (1, 'lpParameters'), (1, 'lpDirectory'), (1, 'nShowCmd')) - -#def SHGetPathFromIDListA(pidl, pszPath): -# return SHGetPathFromIDListA.ctypes_function(pidl, pszPath) -SHGetPathFromIDListAPrototype = WINFUNCTYPE(BOOL, PCIDLIST_ABSOLUTE, LPCSTR) -SHGetPathFromIDListAParams = ((1, 'pidl'), (1, 'pszPath')) - -#def SHGetPathFromIDListW(pidl, pszPath): -# return SHGetPathFromIDListW.ctypes_function(pidl, pszPath) -SHGetPathFromIDListWPrototype = WINFUNCTYPE(BOOL, PCIDLIST_ABSOLUTE, LPWSTR) -SHGetPathFromIDListWParams = ((1, 'pidl'), (1, 'pszPath')) - -#def TpCallbackSendAlpcMessageOnCompletion(TpHandle, PortHandle, Flags, SendMessage): -# return TpCallbackSendAlpcMessageOnCompletion.ctypes_function(TpHandle, PortHandle, Flags, SendMessage) -TpCallbackSendAlpcMessageOnCompletionPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, HANDLE, ULONG, PPORT_MESSAGE) -TpCallbackSendAlpcMessageOnCompletionParams = ((1, 'TpHandle'), (1, 'PortHandle'), (1, 'Flags'), (1, 'SendMessage')) +#def IsOS(dwOS): +# return IsOS.ctypes_function(dwOS) +IsOSPrototype = WINFUNCTYPE(BOOL, DWORD) +IsOSParams = ((1, 'dwOS'),) #def NtQueryLicenseValue(Name, Type, Buffer, Length, DataLength): # return NtQueryLicenseValue.ctypes_function(Name, Type, Buffer, Length, DataLength) @@ -275,135 +40,315 @@ NtSetEaFileParams = ((1, 'FileHandle'), (1, 'IoStatusBlock'), (1, 'Buffer'), (1, NtCreateProcessExPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, HANDLE, ULONG, HANDLE, HANDLE, HANDLE, BOOLEAN) NtCreateProcessExParams = ((1, 'ProcessHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'ParentProcess'), (1, 'Flags'), (1, 'SectionHandle'), (1, 'DebugPort'), (1, 'ExceptionPort'), (1, 'InJob')) -#def IsValidSecurityDescriptor(pSecurityDescriptor): -# return IsValidSecurityDescriptor.ctypes_function(pSecurityDescriptor) -IsValidSecurityDescriptorPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR) -IsValidSecurityDescriptorParams = ((1, 'pSecurityDescriptor'),) +#def NtCreateNamedPipeFile(NamedPipeFileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, ShareAccess, CreateDisposition, CreateOptions, WriteModeMessage, ReadModeMessage, NonBlocking, MaxInstances, InBufferSize, OutBufferSize, DefaultTimeOut): +# return NtCreateNamedPipeFile.ctypes_function(NamedPipeFileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, ShareAccess, CreateDisposition, CreateOptions, WriteModeMessage, ReadModeMessage, NonBlocking, MaxInstances, InBufferSize, OutBufferSize, DefaultTimeOut) +NtCreateNamedPipeFilePrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, ULONG, ULONG, ULONG, BOOLEAN, BOOLEAN, BOOLEAN, ULONG, ULONG, ULONG, PLARGE_INTEGER) +NtCreateNamedPipeFileParams = ((1, 'NamedPipeFileHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'IoStatusBlock'), (1, 'ShareAccess'), (1, 'CreateDisposition'), (1, 'CreateOptions'), (1, 'WriteModeMessage'), (1, 'ReadModeMessage'), (1, 'NonBlocking'), (1, 'MaxInstances'), (1, 'InBufferSize'), (1, 'OutBufferSize'), (1, 'DefaultTimeOut')) -#def ConvertStringSecurityDescriptorToSecurityDescriptorA(StringSecurityDescriptor, StringSDRevision, SecurityDescriptor, SecurityDescriptorSize): -# return ConvertStringSecurityDescriptorToSecurityDescriptorA.ctypes_function(StringSecurityDescriptor, StringSDRevision, SecurityDescriptor, SecurityDescriptorSize) -ConvertStringSecurityDescriptorToSecurityDescriptorAPrototype = WINFUNCTYPE(BOOL, LPCSTR, DWORD, POINTER(PSECURITY_DESCRIPTOR), PULONG) -ConvertStringSecurityDescriptorToSecurityDescriptorAParams = ((1, 'StringSecurityDescriptor'), (1, 'StringSDRevision'), (1, 'SecurityDescriptor'), (1, 'SecurityDescriptorSize')) +#def NtCreateFile(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, AllocationSize, FileAttributes, ShareAccess, CreateDisposition, CreateOptions, EaBuffer, EaLength): +# return NtCreateFile.ctypes_function(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, AllocationSize, FileAttributes, ShareAccess, CreateDisposition, CreateOptions, EaBuffer, EaLength) +NtCreateFilePrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, PLARGE_INTEGER, ULONG, ULONG, ULONG, ULONG, PVOID, ULONG) +NtCreateFileParams = ((1, 'FileHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'IoStatusBlock'), (1, 'AllocationSize'), (1, 'FileAttributes'), (1, 'ShareAccess'), (1, 'CreateDisposition'), (1, 'CreateOptions'), (1, 'EaBuffer'), (1, 'EaLength')) -#def ConvertStringSecurityDescriptorToSecurityDescriptorW(StringSecurityDescriptor, StringSDRevision, SecurityDescriptor, SecurityDescriptorSize): -# return ConvertStringSecurityDescriptorToSecurityDescriptorW.ctypes_function(StringSecurityDescriptor, StringSDRevision, SecurityDescriptor, SecurityDescriptorSize) -ConvertStringSecurityDescriptorToSecurityDescriptorWPrototype = WINFUNCTYPE(BOOL, LPWSTR, DWORD, POINTER(PSECURITY_DESCRIPTOR), PULONG) -ConvertStringSecurityDescriptorToSecurityDescriptorWParams = ((1, 'StringSecurityDescriptor'), (1, 'StringSDRevision'), (1, 'SecurityDescriptor'), (1, 'SecurityDescriptorSize')) +#def NtOpenFile(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, ShareAccess, OpenOptions): +# return NtOpenFile.ctypes_function(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, ShareAccess, OpenOptions) +NtOpenFilePrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, ULONG, ULONG) +NtOpenFileParams = ((1, 'FileHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'IoStatusBlock'), (1, 'ShareAccess'), (1, 'OpenOptions')) -#def ConvertSecurityDescriptorToStringSecurityDescriptorA(SecurityDescriptor, RequestedStringSDRevision, SecurityInformation, StringSecurityDescriptor, StringSecurityDescriptorLen): -# return ConvertSecurityDescriptorToStringSecurityDescriptorA.ctypes_function(SecurityDescriptor, RequestedStringSDRevision, SecurityInformation, StringSecurityDescriptor, StringSecurityDescriptorLen) -ConvertSecurityDescriptorToStringSecurityDescriptorAPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, DWORD, DWORD, POINTER(LPCSTR), PULONG) -ConvertSecurityDescriptorToStringSecurityDescriptorAParams = ((1, 'SecurityDescriptor'), (1, 'RequestedStringSDRevision'), (1, 'SecurityInformation'), (1, 'StringSecurityDescriptor'), (1, 'StringSecurityDescriptorLen')) +#def NtCreateSymbolicLinkObject(pHandle, DesiredAccess, ObjectAttributes, DestinationName): +# return NtCreateSymbolicLinkObject.ctypes_function(pHandle, DesiredAccess, ObjectAttributes, DestinationName) +NtCreateSymbolicLinkObjectPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PUNICODE_STRING) +NtCreateSymbolicLinkObjectParams = ((1, 'pHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'DestinationName')) -#def ConvertSecurityDescriptorToStringSecurityDescriptorW(SecurityDescriptor, RequestedStringSDRevision, SecurityInformation, StringSecurityDescriptor, StringSecurityDescriptorLen): -# return ConvertSecurityDescriptorToStringSecurityDescriptorW.ctypes_function(SecurityDescriptor, RequestedStringSDRevision, SecurityInformation, StringSecurityDescriptor, StringSecurityDescriptorLen) -ConvertSecurityDescriptorToStringSecurityDescriptorWPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, DWORD, DWORD, POINTER(LPWSTR), PULONG) -ConvertSecurityDescriptorToStringSecurityDescriptorWParams = ((1, 'SecurityDescriptor'), (1, 'RequestedStringSDRevision'), (1, 'SecurityInformation'), (1, 'StringSecurityDescriptor'), (1, 'StringSecurityDescriptorLen')) +#def NtSetInformationProcess(ProcessHandle, ProcessInformationClass, ProcessInformation, ProcessInformationLength): +# return NtSetInformationProcess.ctypes_function(ProcessHandle, ProcessInformationClass, ProcessInformation, ProcessInformationLength) +NtSetInformationProcessPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PROCESS_INFORMATION_CLASS, PVOID, ULONG) +NtSetInformationProcessParams = ((1, 'ProcessHandle'), (1, 'ProcessInformationClass'), (1, 'ProcessInformation'), (1, 'ProcessInformationLength')) -#def GetSecurityDescriptorControl(pSecurityDescriptor, pControl, lpdwRevision): -# return GetSecurityDescriptorControl.ctypes_function(pSecurityDescriptor, pControl, lpdwRevision) -GetSecurityDescriptorControlPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, LPDWORD) -GetSecurityDescriptorControlParams = ((1, 'pSecurityDescriptor'), (1, 'pControl'), (1, 'lpdwRevision')) +#def NtQueryVirtualMemory(ProcessHandle, BaseAddress, MemoryInformationClass, MemoryInformation, MemoryInformationLength, ReturnLength): +# return NtQueryVirtualMemory.ctypes_function(ProcessHandle, BaseAddress, MemoryInformationClass, MemoryInformation, MemoryInformationLength, ReturnLength) +NtQueryVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PVOID, MEMORY_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T) +NtQueryVirtualMemoryParams = ((1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'MemoryInformationClass'), (1, 'MemoryInformation'), (1, 'MemoryInformationLength'), (1, 'ReturnLength')) -#def GetSecurityDescriptorDacl(pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted): -# return GetSecurityDescriptorDacl.ctypes_function(pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted) -GetSecurityDescriptorDaclPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, LPBOOL, POINTER(PACL), LPBOOL) -GetSecurityDescriptorDaclParams = ((1, 'pSecurityDescriptor'), (1, 'lpbDaclPresent'), (1, 'pDacl'), (1, 'lpbDaclDefaulted')) +#def NtQueryVolumeInformationFile(FileHandle, IoStatusBlock, FsInformation, Length, FsInformationClass): +# return NtQueryVolumeInformationFile.ctypes_function(FileHandle, IoStatusBlock, FsInformation, Length, FsInformationClass) +NtQueryVolumeInformationFilePrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FS_INFORMATION_CLASS) +NtQueryVolumeInformationFileParams = ((1, 'FileHandle'), (1, 'IoStatusBlock'), (1, 'FsInformation'), (1, 'Length'), (1, 'FsInformationClass')) -#def GetSecurityDescriptorGroup(pSecurityDescriptor, pGroup, lpbGroupDefaulted): -# return GetSecurityDescriptorGroup.ctypes_function(pSecurityDescriptor, pGroup, lpbGroupDefaulted) -GetSecurityDescriptorGroupPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, POINTER(PSID), LPBOOL) -GetSecurityDescriptorGroupParams = ((1, 'pSecurityDescriptor'), (1, 'pGroup'), (1, 'lpbGroupDefaulted')) +#def NtCreateThreadEx(ThreadHandle, DesiredAccess, ObjectAttributes, ProcessHandle, lpStartAddress, lpParameter, CreateSuspended, dwStackSize, Unknown1, Unknown2, Unknown3): +# return NtCreateThreadEx.ctypes_function(ThreadHandle, DesiredAccess, ObjectAttributes, ProcessHandle, lpStartAddress, lpParameter, CreateSuspended, dwStackSize, Unknown1, Unknown2, Unknown3) +NtCreateThreadExPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, LPVOID, HANDLE, LPTHREAD_START_ROUTINE, LPVOID, BOOL, DWORD, DWORD, DWORD, LPVOID) +NtCreateThreadExParams = ((1, 'ThreadHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'ProcessHandle'), (1, 'lpStartAddress'), (1, 'lpParameter'), (1, 'CreateSuspended'), (1, 'dwStackSize'), (1, 'Unknown1'), (1, 'Unknown2'), (1, 'Unknown3')) -#def GetSecurityDescriptorLength(pSecurityDescriptor): -# return GetSecurityDescriptorLength.ctypes_function(pSecurityDescriptor) -GetSecurityDescriptorLengthPrototype = WINFUNCTYPE(DWORD, PSECURITY_DESCRIPTOR) -GetSecurityDescriptorLengthParams = ((1, 'pSecurityDescriptor'),) +#def NtGetContextThread(hThread, lpContext): +# return NtGetContextThread.ctypes_function(hThread, lpContext) +NtGetContextThreadPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, LPCONTEXT) +NtGetContextThreadParams = ((1, 'hThread'), (1, 'lpContext')) -#def GetSecurityDescriptorOwner(pSecurityDescriptor, pOwner, lpbOwnerDefaulted): -# return GetSecurityDescriptorOwner.ctypes_function(pSecurityDescriptor, pOwner, lpbOwnerDefaulted) -GetSecurityDescriptorOwnerPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, POINTER(PSID), LPBOOL) -GetSecurityDescriptorOwnerParams = ((1, 'pSecurityDescriptor'), (1, 'pOwner'), (1, 'lpbOwnerDefaulted')) +#def NtSetContextThread(hThread, lpContext): +# return NtSetContextThread.ctypes_function(hThread, lpContext) +NtSetContextThreadPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, LPCONTEXT) +NtSetContextThreadParams = ((1, 'hThread'), (1, 'lpContext')) -#def GetSecurityDescriptorRMControl(SecurityDescriptor, RMControl): -# return GetSecurityDescriptorRMControl.ctypes_function(SecurityDescriptor, RMControl) -GetSecurityDescriptorRMControlPrototype = WINFUNCTYPE(DWORD, PSECURITY_DESCRIPTOR, PUCHAR) -GetSecurityDescriptorRMControlParams = ((1, 'SecurityDescriptor'), (1, 'RMControl')) +#def NtQueryInformationThread(ThreadHandle, ThreadInformationClass, ThreadInformation, ThreadInformationLength, ReturnLength): +# return NtQueryInformationThread.ctypes_function(ThreadHandle, ThreadInformationClass, ThreadInformation, ThreadInformationLength, ReturnLength) +NtQueryInformationThreadPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, THREAD_INFORMATION_CLASS, PVOID, ULONG, PULONG) +NtQueryInformationThreadParams = ((1, 'ThreadHandle'), (1, 'ThreadInformationClass'), (1, 'ThreadInformation'), (1, 'ThreadInformationLength'), (1, 'ReturnLength')) -#def GetSecurityDescriptorSacl(pSecurityDescriptor, lpbSaclPresent, pSacl, lpbSaclDefaulted): -# return GetSecurityDescriptorSacl.ctypes_function(pSecurityDescriptor, lpbSaclPresent, pSacl, lpbSaclDefaulted) -GetSecurityDescriptorSaclPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, LPBOOL, POINTER(PACL), LPBOOL) -GetSecurityDescriptorSaclParams = ((1, 'pSecurityDescriptor'), (1, 'lpbSaclPresent'), (1, 'pSacl'), (1, 'lpbSaclDefaulted')) +#def NtAllocateVirtualMemory(ProcessHandle, BaseAddress, ZeroBits, RegionSize, AllocationType, Protect): +# return NtAllocateVirtualMemory.ctypes_function(ProcessHandle, BaseAddress, ZeroBits, RegionSize, AllocationType, Protect) +NtAllocateVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, POINTER(PVOID), ULONG_PTR, PSIZE_T, ULONG, ULONG) +NtAllocateVirtualMemoryParams = ((1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'ZeroBits'), (1, 'RegionSize'), (1, 'AllocationType'), (1, 'Protect')) -#def GetLengthSid(pSid): -# return GetLengthSid.ctypes_function(pSid) -GetLengthSidPrototype = WINFUNCTYPE(DWORD, PSID) -GetLengthSidParams = ((1, 'pSid'),) +#def NtProtectVirtualMemory(ProcessHandle, BaseAddress, NumberOfBytesToProtect, NewAccessProtection, OldAccessProtection): +# return NtProtectVirtualMemory.ctypes_function(ProcessHandle, BaseAddress, NumberOfBytesToProtect, NewAccessProtection, OldAccessProtection) +NtProtectVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, POINTER(PVOID), PULONG, ULONG, PULONG) +NtProtectVirtualMemoryParams = ((1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'NumberOfBytesToProtect'), (1, 'NewAccessProtection'), (1, 'OldAccessProtection')) -#def EqualSid(pSid1, pSid2): -# return EqualSid.ctypes_function(pSid1, pSid2) -EqualSidPrototype = WINFUNCTYPE(BOOL, PSID, PSID) -EqualSidParams = ((1, 'pSid1'), (1, 'pSid2')) +#def NtQuerySystemInformation(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength): +# return NtQuerySystemInformation.ctypes_function(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength) +NtQuerySystemInformationPrototype = WINFUNCTYPE(NTSTATUS, SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG) +NtQuerySystemInformationParams = ((1, 'SystemInformationClass'), (1, 'SystemInformation'), (1, 'SystemInformationLength'), (1, 'ReturnLength')) -#def CopySid(nDestinationSidLength, pDestinationSid, pSourceSid): -# return CopySid.ctypes_function(nDestinationSidLength, pDestinationSid, pSourceSid) -CopySidPrototype = WINFUNCTYPE(BOOL, DWORD, PSID, PSID) -CopySidParams = ((1, 'nDestinationSidLength'), (1, 'pDestinationSid'), (1, 'pSourceSid')) +#def NtQueryInformationProcess(ProcessHandle, ProcessInformationClass, ProcessInformation, ProcessInformationLength, ReturnLength): +# return NtQueryInformationProcess.ctypes_function(ProcessHandle, ProcessInformationClass, ProcessInformation, ProcessInformationLength, ReturnLength) +NtQueryInformationProcessPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG) +NtQueryInformationProcessParams = ((1, 'ProcessHandle'), (1, 'ProcessInformationClass'), (1, 'ProcessInformation'), (1, 'ProcessInformationLength'), (1, 'ReturnLength')) -#def GetSidIdentifierAuthority(pSid): -# return GetSidIdentifierAuthority.ctypes_function(pSid) -GetSidIdentifierAuthorityPrototype = WINFUNCTYPE(PSID_IDENTIFIER_AUTHORITY, PSID) -GetSidIdentifierAuthorityParams = ((1, 'pSid'),) +#def NtReadVirtualMemory(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead): +# return NtReadVirtualMemory.ctypes_function(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead) +NtReadVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PVOID, LPVOID, ULONG, PULONG) +NtReadVirtualMemoryParams = ((1, 'hProcess'), (1, 'lpBaseAddress'), (1, 'lpBuffer'), (1, 'nSize'), (1, 'lpNumberOfBytesRead')) -#def GetSidLengthRequired(nSubAuthorityCount): -# return GetSidLengthRequired.ctypes_function(nSubAuthorityCount) -GetSidLengthRequiredPrototype = WINFUNCTYPE(DWORD, UCHAR) -GetSidLengthRequiredParams = ((1, 'nSubAuthorityCount'),) +#def NtWriteVirtualMemory(ProcessHandle, BaseAddress, Buffer, NumberOfBytesToWrite, NumberOfBytesWritten): +# return NtWriteVirtualMemory.ctypes_function(ProcessHandle, BaseAddress, Buffer, NumberOfBytesToWrite, NumberOfBytesWritten) +NtWriteVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PVOID, PVOID, ULONG, PULONG) +NtWriteVirtualMemoryParams = ((1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'Buffer'), (1, 'NumberOfBytesToWrite'), (1, 'NumberOfBytesWritten')) -#def GetSidSubAuthority(pSid, nSubAuthority): -# return GetSidSubAuthority.ctypes_function(pSid, nSubAuthority) -GetSidSubAuthorityPrototype = WINFUNCTYPE(PDWORD, PSID, DWORD) -GetSidSubAuthorityParams = ((1, 'pSid'), (1, 'nSubAuthority')) +#def NtOpenEvent(EventHandle, DesiredAccess, ObjectAttributes): +# return NtOpenEvent.ctypes_function(EventHandle, DesiredAccess, ObjectAttributes) +NtOpenEventPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES) +NtOpenEventParams = ((1, 'EventHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes')) -#def GetSidSubAuthorityCount(pSid): -# return GetSidSubAuthorityCount.ctypes_function(pSid) -GetSidSubAuthorityCountPrototype = WINFUNCTYPE(LPBYTE, PSID) -GetSidSubAuthorityCountParams = ((1, 'pSid'),) +#def NtQueryObject(Handle, ObjectInformationClass, ObjectInformation, ObjectInformationLength, ReturnLength): +# return NtQueryObject.ctypes_function(Handle, ObjectInformationClass, ObjectInformation, ObjectInformationLength, ReturnLength) +NtQueryObjectPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG, PULONG) +NtQueryObjectParams = ((1, 'Handle'), (1, 'ObjectInformationClass'), (1, 'ObjectInformation'), (1, 'ObjectInformationLength'), (1, 'ReturnLength')) -#def FreeSid(pSid): -# return FreeSid.ctypes_function(pSid) -FreeSidPrototype = WINFUNCTYPE(PVOID, PSID) -FreeSidParams = ((1, 'pSid'),) +#def NtOpenDirectoryObject(DirectoryHandle, DesiredAccess, ObjectAttributes): +# return NtOpenDirectoryObject.ctypes_function(DirectoryHandle, DesiredAccess, ObjectAttributes) +NtOpenDirectoryObjectPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES) +NtOpenDirectoryObjectParams = ((1, 'DirectoryHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes')) -#def GetAce(pAcl, dwAceIndex, pAce): -# return GetAce.ctypes_function(pAcl, dwAceIndex, pAce) -GetAcePrototype = WINFUNCTYPE(BOOL, PACL, DWORD, POINTER(LPVOID)) -GetAceParams = ((1, 'pAcl'), (1, 'dwAceIndex'), (1, 'pAce')) +#def NtQueryDirectoryObject(DirectoryHandle, Buffer, Length, ReturnSingleEntry, RestartScan, Context, ReturnLength): +# return NtQueryDirectoryObject.ctypes_function(DirectoryHandle, Buffer, Length, ReturnSingleEntry, RestartScan, Context, ReturnLength) +NtQueryDirectoryObjectPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PVOID, ULONG, BOOLEAN, BOOLEAN, PULONG, PULONG) +NtQueryDirectoryObjectParams = ((1, 'DirectoryHandle'), (1, 'Buffer'), (1, 'Length'), (1, 'ReturnSingleEntry'), (1, 'RestartScan'), (1, 'Context'), (1, 'ReturnLength')) -#def GetAclInformation(pAcl, pAclInformation, nAclInformationLength, dwAclInformationClass): -# return GetAclInformation.ctypes_function(pAcl, pAclInformation, nAclInformationLength, dwAclInformationClass) -GetAclInformationPrototype = WINFUNCTYPE(BOOL, PACL, LPVOID, DWORD, ACL_INFORMATION_CLASS) -GetAclInformationParams = ((1, 'pAcl'), (1, 'pAclInformation'), (1, 'nAclInformationLength'), (1, 'dwAclInformationClass')) +#def NtQuerySymbolicLinkObject(LinkHandle, LinkTarget, ReturnedLength): +# return NtQuerySymbolicLinkObject.ctypes_function(LinkHandle, LinkTarget, ReturnedLength) +NtQuerySymbolicLinkObjectPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PUNICODE_STRING, PULONG) +NtQuerySymbolicLinkObjectParams = ((1, 'LinkHandle'), (1, 'LinkTarget'), (1, 'ReturnedLength')) -#def SymLoadModuleExA(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags): -# return SymLoadModuleExA.ctypes_function(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags) -SymLoadModuleExAPrototype = WINFUNCTYPE(DWORD64, HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD, PMODLOAD_DATA, DWORD) -SymLoadModuleExAParams = ((1, 'hProcess'), (1, 'hFile'), (1, 'ImageName'), (1, 'ModuleName'), (1, 'BaseOfDll'), (1, 'DllSize'), (1, 'Data'), (1, 'Flags')) +#def NtOpenSymbolicLinkObject(LinkHandle, DesiredAccess, ObjectAttributes): +# return NtOpenSymbolicLinkObject.ctypes_function(LinkHandle, DesiredAccess, ObjectAttributes) +NtOpenSymbolicLinkObjectPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES) +NtOpenSymbolicLinkObjectParams = ((1, 'LinkHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes')) -#def SymLoadModuleExW(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags): -# return SymLoadModuleExW.ctypes_function(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags) -SymLoadModuleExWPrototype = WINFUNCTYPE(DWORD64, HANDLE, HANDLE, PCWSTR, PCWSTR, DWORD64, DWORD, PMODLOAD_DATA, DWORD) -SymLoadModuleExWParams = ((1, 'hProcess'), (1, 'hFile'), (1, 'ImageName'), (1, 'ModuleName'), (1, 'BaseOfDll'), (1, 'DllSize'), (1, 'Data'), (1, 'Flags')) +#def NtQueryInformationFile(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass): +# return NtQueryInformationFile.ctypes_function(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass) +NtQueryInformationFilePrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS) +NtQueryInformationFileParams = ((1, 'FileHandle'), (1, 'IoStatusBlock'), (1, 'FileInformation'), (1, 'Length'), (1, 'FileInformationClass')) -#def SymFromAddr(hProcess, Address, Displacement, Symbol): -# return SymFromAddr.ctypes_function(hProcess, Address, Displacement, Symbol) -SymFromAddrPrototype = WINFUNCTYPE(BOOL, HANDLE, DWORD64, PDWORD64, PSYMBOL_INFO) -SymFromAddrParams = ((1, 'hProcess'), (1, 'Address'), (1, 'Displacement'), (1, 'Symbol')) +#def NtQueryDirectoryFile(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, FileInformation, Length, FileInformationClass, ReturnSingleEntry, FileName, RestartScan): +# return NtQueryDirectoryFile.ctypes_function(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, FileInformation, Length, FileInformationClass, ReturnSingleEntry, FileName, RestartScan) +NtQueryDirectoryFilePrototype = WINFUNCTYPE(NTSTATUS, HANDLE, HANDLE, PIO_APC_ROUTINE, PVOID, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS, BOOLEAN, PUNICODE_STRING, BOOLEAN) +NtQueryDirectoryFileParams = ((1, 'FileHandle'), (1, 'Event'), (1, 'ApcRoutine'), (1, 'ApcContext'), (1, 'IoStatusBlock'), (1, 'FileInformation'), (1, 'Length'), (1, 'FileInformationClass'), (1, 'ReturnSingleEntry'), (1, 'FileName'), (1, 'RestartScan')) -#def SymGetModuleInfo64(hProcess, dwAddr, ModuleInfo): -# return SymGetModuleInfo64.ctypes_function(hProcess, dwAddr, ModuleInfo) -SymGetModuleInfo64Prototype = WINFUNCTYPE(BOOL, HANDLE, DWORD64, PIMAGEHLP_MODULE64) -SymGetModuleInfo64Params = ((1, 'hProcess'), (1, 'dwAddr'), (1, 'ModuleInfo')) +#def NtSetInformationFile(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass): +# return NtSetInformationFile.ctypes_function(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass) +NtSetInformationFilePrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS) +NtSetInformationFileParams = ((1, 'FileHandle'), (1, 'IoStatusBlock'), (1, 'FileInformation'), (1, 'Length'), (1, 'FileInformationClass')) + +#def NtEnumerateSystemEnvironmentValuesEx(InformationClass, Buffer, BufferLength): +# return NtEnumerateSystemEnvironmentValuesEx.ctypes_function(InformationClass, Buffer, BufferLength) +NtEnumerateSystemEnvironmentValuesExPrototype = WINFUNCTYPE(NTSTATUS, ULONG, PVOID, ULONG) +NtEnumerateSystemEnvironmentValuesExParams = ((1, 'InformationClass'), (1, 'Buffer'), (1, 'BufferLength')) + +#def NtFreeVirtualMemory(ProcessHandle, BaseAddress, RegionSize, FreeType): +# return NtFreeVirtualMemory.ctypes_function(ProcessHandle, BaseAddress, RegionSize, FreeType) +NtFreeVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, POINTER(PVOID), PSIZE_T, ULONG) +NtFreeVirtualMemoryParams = ((1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'RegionSize'), (1, 'FreeType')) + +#def NtGetContextThread(hThread, lpContext): +# return NtGetContextThread.ctypes_function(hThread, lpContext) +NtGetContextThreadPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, LPCONTEXT) +NtGetContextThreadParams = ((1, 'hThread'), (1, 'lpContext')) + +#def NtSetContextThread(hThread, lpContext): +# return NtSetContextThread.ctypes_function(hThread, lpContext) +NtSetContextThreadPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, LPCONTEXT) +NtSetContextThreadParams = ((1, 'hThread'), (1, 'lpContext')) + +#def NtCreateSection(SectionHandle, DesiredAccess, ObjectAttributes, MaximumSize, SectionPageProtection, AllocationAttributes, FileHandle): +# return NtCreateSection.ctypes_function(SectionHandle, DesiredAccess, ObjectAttributes, MaximumSize, SectionPageProtection, AllocationAttributes, FileHandle) +NtCreateSectionPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PLARGE_INTEGER, ULONG, ULONG, HANDLE) +NtCreateSectionParams = ((1, 'SectionHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'MaximumSize'), (1, 'SectionPageProtection'), (1, 'AllocationAttributes'), (1, 'FileHandle')) + +#def NtOpenSection(SectionHandle, DesiredAccess, ObjectAttributes): +# return NtOpenSection.ctypes_function(SectionHandle, DesiredAccess, ObjectAttributes) +NtOpenSectionPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES) +NtOpenSectionParams = ((1, 'SectionHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes')) + +#def NtMapViewOfSection(SectionHandle, ProcessHandle, BaseAddress, ZeroBits, CommitSize, SectionOffset, ViewSize, InheritDisposition, AllocationType, Win32Protect): +# return NtMapViewOfSection.ctypes_function(SectionHandle, ProcessHandle, BaseAddress, ZeroBits, CommitSize, SectionOffset, ViewSize, InheritDisposition, AllocationType, Win32Protect) +NtMapViewOfSectionPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, HANDLE, POINTER(PVOID), ULONG_PTR, SIZE_T, PLARGE_INTEGER, PSIZE_T, SECTION_INHERIT, ULONG, ULONG) +NtMapViewOfSectionParams = ((1, 'SectionHandle'), (1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'ZeroBits'), (1, 'CommitSize'), (1, 'SectionOffset'), (1, 'ViewSize'), (1, 'InheritDisposition'), (1, 'AllocationType'), (1, 'Win32Protect')) + +#def NtUnmapViewOfSection(ProcessHandle, BaseAddress): +# return NtUnmapViewOfSection.ctypes_function(ProcessHandle, BaseAddress) +NtUnmapViewOfSectionPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PVOID) +NtUnmapViewOfSectionParams = ((1, 'ProcessHandle'), (1, 'BaseAddress')) + +#def EnumerateTraceGuidsEx(TraceQueryInfoClass, InBuffer, InBufferSize, OutBuffer, OutBufferSize, ReturnLength): +# return EnumerateTraceGuidsEx.ctypes_function(TraceQueryInfoClass, InBuffer, InBufferSize, OutBuffer, OutBufferSize, ReturnLength) +EnumerateTraceGuidsExPrototype = WINFUNCTYPE(ULONG, TRACE_QUERY_INFO_CLASS, PVOID, ULONG, PVOID, ULONG, PULONG) +EnumerateTraceGuidsExParams = ((1, 'TraceQueryInfoClass'), (1, 'InBuffer'), (1, 'InBufferSize'), (1, 'OutBuffer'), (1, 'OutBufferSize'), (1, 'ReturnLength')) + +#def QueryAllTracesA(PropertyArray, PropertyArrayCount, SessionCount): +# return QueryAllTracesA.ctypes_function(PropertyArray, PropertyArrayCount, SessionCount) +QueryAllTracesAPrototype = WINFUNCTYPE(ULONG, POINTER(PEVENT_TRACE_PROPERTIES), ULONG, PULONG) +QueryAllTracesAParams = ((1, 'PropertyArray'), (1, 'PropertyArrayCount'), (1, 'SessionCount')) + +#def QueryAllTracesW(PropertyArray, PropertyArrayCount, SessionCount): +# return QueryAllTracesW.ctypes_function(PropertyArray, PropertyArrayCount, SessionCount) +QueryAllTracesWPrototype = WINFUNCTYPE(ULONG, POINTER(PEVENT_TRACE_PROPERTIES), ULONG, PULONG) +QueryAllTracesWParams = ((1, 'PropertyArray'), (1, 'PropertyArrayCount'), (1, 'SessionCount')) + +#def OpenTraceA(Logfile): +# return OpenTraceA.ctypes_function(Logfile) +OpenTraceAPrototype = WINFUNCTYPE(TRACEHANDLE, PEVENT_TRACE_LOGFILEA) +OpenTraceAParams = ((1, 'Logfile'),) + +#def OpenTraceW(Logfile): +# return OpenTraceW.ctypes_function(Logfile) +OpenTraceWPrototype = WINFUNCTYPE(TRACEHANDLE, PEVENT_TRACE_LOGFILEW) +OpenTraceWParams = ((1, 'Logfile'),) + +#def StartTraceA(TraceHandle, InstanceName, Properties): +# return StartTraceA.ctypes_function(TraceHandle, InstanceName, Properties) +StartTraceAPrototype = WINFUNCTYPE(ULONG, PTRACEHANDLE, LPCSTR, PEVENT_TRACE_PROPERTIES) +StartTraceAParams = ((1, 'TraceHandle'), (1, 'InstanceName'), (1, 'Properties')) + +#def StartTraceW(TraceHandle, InstanceName, Properties): +# return StartTraceW.ctypes_function(TraceHandle, InstanceName, Properties) +StartTraceWPrototype = WINFUNCTYPE(ULONG, PTRACEHANDLE, LPCWSTR, PEVENT_TRACE_PROPERTIES) +StartTraceWParams = ((1, 'TraceHandle'), (1, 'InstanceName'), (1, 'Properties')) + +#def StopTraceA(TraceHandle, InstanceName, Properties): +# return StopTraceA.ctypes_function(TraceHandle, InstanceName, Properties) +StopTraceAPrototype = WINFUNCTYPE(ULONG, TRACEHANDLE, LPCSTR, PEVENT_TRACE_PROPERTIES) +StopTraceAParams = ((1, 'TraceHandle'), (1, 'InstanceName'), (1, 'Properties')) + +#def StopTraceW(TraceHandle, InstanceName, Properties): +# return StopTraceW.ctypes_function(TraceHandle, InstanceName, Properties) +StopTraceWPrototype = WINFUNCTYPE(ULONG, TRACEHANDLE, LPCWSTR, PEVENT_TRACE_PROPERTIES) +StopTraceWParams = ((1, 'TraceHandle'), (1, 'InstanceName'), (1, 'Properties')) + +#def ControlTraceA(TraceHandle, InstanceName, Properties, ControlCode): +# return ControlTraceA.ctypes_function(TraceHandle, InstanceName, Properties, ControlCode) +ControlTraceAPrototype = WINFUNCTYPE(ULONG, TRACEHANDLE, LPCSTR, PEVENT_TRACE_PROPERTIES, ULONG) +ControlTraceAParams = ((1, 'TraceHandle'), (1, 'InstanceName'), (1, 'Properties'), (1, 'ControlCode')) + +#def ControlTraceW(TraceHandle, InstanceName, Properties, ControlCode): +# return ControlTraceW.ctypes_function(TraceHandle, InstanceName, Properties, ControlCode) +ControlTraceWPrototype = WINFUNCTYPE(ULONG, TRACEHANDLE, LPCWSTR, PEVENT_TRACE_PROPERTIES, ULONG) +ControlTraceWParams = ((1, 'TraceHandle'), (1, 'InstanceName'), (1, 'Properties'), (1, 'ControlCode')) + +#def ProcessTrace(HandleArray, HandleCount, StartTime, EndTime): +# return ProcessTrace.ctypes_function(HandleArray, HandleCount, StartTime, EndTime) +ProcessTracePrototype = WINFUNCTYPE(ULONG, PTRACEHANDLE, ULONG, LPFILETIME, LPFILETIME) +ProcessTraceParams = ((1, 'HandleArray'), (1, 'HandleCount'), (1, 'StartTime'), (1, 'EndTime')) + +#def EnableTrace(Enable, EnableFlag, EnableLevel, ControlGuid, SessionHandle): +# return EnableTrace.ctypes_function(Enable, EnableFlag, EnableLevel, ControlGuid, SessionHandle) +EnableTracePrototype = WINFUNCTYPE(ULONG, ULONG, ULONG, ULONG, LPCGUID, TRACEHANDLE) +EnableTraceParams = ((1, 'Enable'), (1, 'EnableFlag'), (1, 'EnableLevel'), (1, 'ControlGuid'), (1, 'SessionHandle')) + +#def EnableTraceEx(ProviderId, SourceId, TraceHandle, IsEnabled, Level, MatchAnyKeyword, MatchAllKeyword, EnableProperty, EnableFilterDesc): +# return EnableTraceEx.ctypes_function(ProviderId, SourceId, TraceHandle, IsEnabled, Level, MatchAnyKeyword, MatchAllKeyword, EnableProperty, EnableFilterDesc) +EnableTraceExPrototype = WINFUNCTYPE(ULONG, LPCGUID, LPCGUID, TRACEHANDLE, ULONG, UCHAR, ULONGLONG, ULONGLONG, ULONG, PEVENT_FILTER_DESCRIPTOR) +EnableTraceExParams = ((1, 'ProviderId'), (1, 'SourceId'), (1, 'TraceHandle'), (1, 'IsEnabled'), (1, 'Level'), (1, 'MatchAnyKeyword'), (1, 'MatchAllKeyword'), (1, 'EnableProperty'), (1, 'EnableFilterDesc')) + +#def EnableTraceEx2(TraceHandle, ProviderId, ControlCode, Level, MatchAnyKeyword, MatchAllKeyword, Timeout, EnableParameters): +# return EnableTraceEx2.ctypes_function(TraceHandle, ProviderId, ControlCode, Level, MatchAnyKeyword, MatchAllKeyword, Timeout, EnableParameters) +EnableTraceEx2Prototype = WINFUNCTYPE(ULONG, TRACEHANDLE, LPCGUID, ULONG, UCHAR, ULONGLONG, ULONGLONG, ULONG, PENABLE_TRACE_PARAMETERS) +EnableTraceEx2Params = ((1, 'TraceHandle'), (1, 'ProviderId'), (1, 'ControlCode'), (1, 'Level'), (1, 'MatchAnyKeyword'), (1, 'MatchAllKeyword'), (1, 'Timeout'), (1, 'EnableParameters')) + +#def TraceQueryInformation(SessionHandle, InformationClass, TraceInformation, InformationLength, ReturnLength): +# return TraceQueryInformation.ctypes_function(SessionHandle, InformationClass, TraceInformation, InformationLength, ReturnLength) +TraceQueryInformationPrototype = WINFUNCTYPE(ULONG, TRACEHANDLE, TRACE_QUERY_INFO_CLASS, PVOID, ULONG, PULONG) +TraceQueryInformationParams = ((1, 'SessionHandle'), (1, 'InformationClass'), (1, 'TraceInformation'), (1, 'InformationLength'), (1, 'ReturnLength')) + +#def TraceSetInformation(SessionHandle, InformationClass, TraceInformation, InformationLength): +# return TraceSetInformation.ctypes_function(SessionHandle, InformationClass, TraceInformation, InformationLength) +TraceSetInformationPrototype = WINFUNCTYPE(ULONG, TRACEHANDLE, TRACE_INFO_CLASS, PVOID, ULONG) +TraceSetInformationParams = ((1, 'SessionHandle'), (1, 'InformationClass'), (1, 'TraceInformation'), (1, 'InformationLength')) + +#def NtOpenKey(KeyHandle, DesiredAccess, ObjectAttributes): +# return NtOpenKey.ctypes_function(KeyHandle, DesiredAccess, ObjectAttributes) +NtOpenKeyPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES) +NtOpenKeyParams = ((1, 'KeyHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes')) + +#def NtCreateKey(pKeyHandle, DesiredAccess, ObjectAttributes, TitleIndex, Class, CreateOptions, Disposition): +# return NtCreateKey.ctypes_function(pKeyHandle, DesiredAccess, ObjectAttributes, TitleIndex, Class, CreateOptions, Disposition) +NtCreateKeyPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG, PUNICODE_STRING, ULONG, PULONG) +NtCreateKeyParams = ((1, 'pKeyHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'TitleIndex'), (1, 'Class'), (1, 'CreateOptions'), (1, 'Disposition')) + +#def NtSetValueKey(KeyHandle, ValueName, TitleIndex, Type, Data, DataSize): +# return NtSetValueKey.ctypes_function(KeyHandle, ValueName, TitleIndex, Type, Data, DataSize) +NtSetValueKeyPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PUNICODE_STRING, ULONG, ULONG, PVOID, ULONG) +NtSetValueKeyParams = ((1, 'KeyHandle'), (1, 'ValueName'), (1, 'TitleIndex'), (1, 'Type'), (1, 'Data'), (1, 'DataSize')) + +#def NtQueryValueKey(KeyHandle, ValueName, KeyValueInformationClass, KeyValueInformation, Length, ResultLength): +# return NtQueryValueKey.ctypes_function(KeyHandle, ValueName, KeyValueInformationClass, KeyValueInformation, Length, ResultLength) +NtQueryValueKeyPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PUNICODE_STRING, KEY_VALUE_INFORMATION_CLASS, PVOID, ULONG, PULONG) +NtQueryValueKeyParams = ((1, 'KeyHandle'), (1, 'ValueName'), (1, 'KeyValueInformationClass'), (1, 'KeyValueInformation'), (1, 'Length'), (1, 'ResultLength')) + +#def NtQueryKey(KeyHandle, KeyInformationClass, KeyInformation, Length, ResultLength): +# return NtQueryKey.ctypes_function(KeyHandle, KeyInformationClass, KeyInformation, Length, ResultLength) +NtQueryKeyPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, KEY_INFORMATION_CLASS, PVOID, ULONG, PULONG) +NtQueryKeyParams = ((1, 'KeyHandle'), (1, 'KeyInformationClass'), (1, 'KeyInformation'), (1, 'Length'), (1, 'ResultLength')) + +#def NtEnumerateValueKey(KeyHandle, Index, KeyValueInformationClass, KeyValueInformation, Length, ResultLength): +# return NtEnumerateValueKey.ctypes_function(KeyHandle, Index, KeyValueInformationClass, KeyValueInformation, Length, ResultLength) +NtEnumerateValueKeyPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, ULONG, KEY_VALUE_INFORMATION_CLASS, PVOID, ULONG, PULONG) +NtEnumerateValueKeyParams = ((1, 'KeyHandle'), (1, 'Index'), (1, 'KeyValueInformationClass'), (1, 'KeyValueInformation'), (1, 'Length'), (1, 'ResultLength')) + +#def TdhEnumerateProviders(pBuffer, pBufferSize): +# return TdhEnumerateProviders.ctypes_function(pBuffer, pBufferSize) +TdhEnumerateProvidersPrototype = WINFUNCTYPE(TDHSTATUS, PPROVIDER_ENUMERATION_INFO, POINTER(ULONG)) +TdhEnumerateProvidersParams = ((1, 'pBuffer'), (1, 'pBufferSize')) + +#def ShellExecuteA(hwnd, lpOperation, lpFile, lpParameters, lpDirectory, nShowCmd): +# return ShellExecuteA.ctypes_function(hwnd, lpOperation, lpFile, lpParameters, lpDirectory, nShowCmd) +ShellExecuteAPrototype = WINFUNCTYPE(HINSTANCE, HWND, LPCSTR, LPCSTR, LPCSTR, LPCSTR, INT) +ShellExecuteAParams = ((1, 'hwnd'), (1, 'lpOperation'), (1, 'lpFile'), (1, 'lpParameters'), (1, 'lpDirectory'), (1, 'nShowCmd')) + +#def ShellExecuteW(hwnd, lpOperation, lpFile, lpParameters, lpDirectory, nShowCmd): +# return ShellExecuteW.ctypes_function(hwnd, lpOperation, lpFile, lpParameters, lpDirectory, nShowCmd) +ShellExecuteWPrototype = WINFUNCTYPE(HINSTANCE, HWND, LPWSTR, LPWSTR, LPWSTR, LPWSTR, INT) +ShellExecuteWParams = ((1, 'hwnd'), (1, 'lpOperation'), (1, 'lpFile'), (1, 'lpParameters'), (1, 'lpDirectory'), (1, 'nShowCmd')) + +#def SHGetPathFromIDListA(pidl, pszPath): +# return SHGetPathFromIDListA.ctypes_function(pidl, pszPath) +SHGetPathFromIDListAPrototype = WINFUNCTYPE(BOOL, PCIDLIST_ABSOLUTE, LPCSTR) +SHGetPathFromIDListAParams = ((1, 'pidl'), (1, 'pszPath')) + +#def SHGetPathFromIDListW(pidl, pszPath): +# return SHGetPathFromIDListW.ctypes_function(pidl, pszPath) +SHGetPathFromIDListWPrototype = WINFUNCTYPE(BOOL, PCIDLIST_ABSOLUTE, LPWSTR) +SHGetPathFromIDListWParams = ((1, 'pidl'), (1, 'pszPath')) #def NtAlpcCreatePort(PortHandle, ObjectAttributes, PortAttributes): # return NtAlpcCreatePort.ctypes_function(PortHandle, ObjectAttributes, PortAttributes) @@ -510,20 +455,165 @@ NtAlpcRevokeSecurityContextParams = ((1, 'PortHandle'), (1, 'Flags'), (1, 'Conte NtAlpcImpersonateClientOfPortPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PPORT_MESSAGE, PVOID) NtAlpcImpersonateClientOfPortParams = ((1, 'PortHandle'), (1, 'Message'), (1, 'Flags')) -#def StrStrIW(pszFirst, pszSrch): -# return StrStrIW.ctypes_function(pszFirst, pszSrch) -StrStrIWPrototype = WINFUNCTYPE(PWSTR, PWSTR, PWSTR) -StrStrIWParams = ((1, 'pszFirst'), (1, 'pszSrch')) +#def TpCallbackSendAlpcMessageOnCompletion(TpHandle, PortHandle, Flags, SendMessage): +# return TpCallbackSendAlpcMessageOnCompletion.ctypes_function(TpHandle, PortHandle, Flags, SendMessage) +TpCallbackSendAlpcMessageOnCompletionPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, HANDLE, ULONG, PPORT_MESSAGE) +TpCallbackSendAlpcMessageOnCompletionParams = ((1, 'TpHandle'), (1, 'PortHandle'), (1, 'Flags'), (1, 'SendMessage')) -#def StrStrIA(pszFirst, pszSrch): -# return StrStrIA.ctypes_function(pszFirst, pszSrch) -StrStrIAPrototype = WINFUNCTYPE(PCSTR, PCSTR, PCSTR) -StrStrIAParams = ((1, 'pszFirst'), (1, 'pszSrch')) +#def CreatePipe(hReadPipe, hWritePipe, lpPipeAttributes, nSize): +# return CreatePipe.ctypes_function(hReadPipe, hWritePipe, lpPipeAttributes, nSize) +CreatePipePrototype = WINFUNCTYPE(BOOL, PHANDLE, PHANDLE, LPSECURITY_ATTRIBUTES, DWORD) +CreatePipeParams = ((1, 'hReadPipe'), (1, 'hWritePipe'), (1, 'lpPipeAttributes'), (1, 'nSize')) -#def IsOS(dwOS): -# return IsOS.ctypes_function(dwOS) -IsOSPrototype = WINFUNCTYPE(BOOL, DWORD) -IsOSParams = ((1, 'dwOS'),) +#def CreateNamedPipeA(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes): +# return CreateNamedPipeA.ctypes_function(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes) +CreateNamedPipeAPrototype = WINFUNCTYPE(HANDLE, LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES) +CreateNamedPipeAParams = ((1, 'lpName'), (1, 'dwOpenMode'), (1, 'dwPipeMode'), (1, 'nMaxInstances'), (1, 'nOutBufferSize'), (1, 'nInBufferSize'), (1, 'nDefaultTimeOut'), (1, 'lpSecurityAttributes')) + +#def CreateNamedPipeW(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes): +# return CreateNamedPipeW.ctypes_function(lpName, dwOpenMode, dwPipeMode, nMaxInstances, nOutBufferSize, nInBufferSize, nDefaultTimeOut, lpSecurityAttributes) +CreateNamedPipeWPrototype = WINFUNCTYPE(HANDLE, LPWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES) +CreateNamedPipeWParams = ((1, 'lpName'), (1, 'dwOpenMode'), (1, 'dwPipeMode'), (1, 'nMaxInstances'), (1, 'nOutBufferSize'), (1, 'nInBufferSize'), (1, 'nDefaultTimeOut'), (1, 'lpSecurityAttributes')) + +#def ConnectNamedPipe(hNamedPipe, lpOverlapped): +# return ConnectNamedPipe.ctypes_function(hNamedPipe, lpOverlapped) +ConnectNamedPipePrototype = WINFUNCTYPE(BOOL, HANDLE, LPOVERLAPPED) +ConnectNamedPipeParams = ((1, 'hNamedPipe'), (1, 'lpOverlapped')) + +#def SetNamedPipeHandleState(hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout): +# return SetNamedPipeHandleState.ctypes_function(hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout) +SetNamedPipeHandleStatePrototype = WINFUNCTYPE(BOOL, HANDLE, LPDWORD, LPDWORD, LPDWORD) +SetNamedPipeHandleStateParams = ((1, 'hNamedPipe'), (1, 'lpMode'), (1, 'lpMaxCollectionCount'), (1, 'lpCollectDataTimeout')) + +#def PeekNamedPipe(hNamedPipe, lpBuffer, nBufferSize, lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage): +# return PeekNamedPipe.ctypes_function(hNamedPipe, lpBuffer, nBufferSize, lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage) +PeekNamedPipePrototype = WINFUNCTYPE(BOOL, HANDLE, LPVOID, DWORD, LPDWORD, LPDWORD, LPDWORD) +PeekNamedPipeParams = ((1, 'hNamedPipe'), (1, 'lpBuffer'), (1, 'nBufferSize'), (1, 'lpBytesRead'), (1, 'lpTotalBytesAvail'), (1, 'lpBytesLeftThisMessage')) + +#def CoInitializeEx(pvReserved, dwCoInit): +# return CoInitializeEx.ctypes_function(pvReserved, dwCoInit) +CoInitializeExPrototype = WINFUNCTYPE(HRESULT, LPVOID, DWORD) +CoInitializeExParams = ((1, 'pvReserved'), (1, 'dwCoInit')) + +#def CoInitializeSecurity(pSecDesc, cAuthSvc, asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pAuthList, dwCapabilities, pReserved3): +# return CoInitializeSecurity.ctypes_function(pSecDesc, cAuthSvc, asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pAuthList, dwCapabilities, pReserved3) +CoInitializeSecurityPrototype = WINFUNCTYPE(HRESULT, PSECURITY_DESCRIPTOR, LONG, POINTER(SOLE_AUTHENTICATION_SERVICE), PVOID, DWORD, DWORD, PVOID, DWORD, PVOID) +CoInitializeSecurityParams = ((1, 'pSecDesc'), (1, 'cAuthSvc'), (1, 'asAuthSvc'), (1, 'pReserved1'), (1, 'dwAuthnLevel'), (1, 'dwImpLevel'), (1, 'pAuthList'), (1, 'dwCapabilities'), (1, 'pReserved3')) + +#def CoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv): +# return CoCreateInstance.ctypes_function(rclsid, pUnkOuter, dwClsContext, riid, ppv) +CoCreateInstancePrototype = WINFUNCTYPE(HRESULT, REFCLSID, LPUNKNOWN, DWORD, REFIID, POINTER(LPVOID)) +CoCreateInstanceParams = ((1, 'rclsid'), (1, 'pUnkOuter'), (1, 'dwClsContext'), (1, 'riid'), (1, 'ppv')) + +#def CoCreateInstanceEx(rclsid, punkOuter, dwClsCtx, pServerInfo, dwCount, pResults): +# return CoCreateInstanceEx.ctypes_function(rclsid, punkOuter, dwClsCtx, pServerInfo, dwCount, pResults) +CoCreateInstanceExPrototype = WINFUNCTYPE(HRESULT, REFCLSID, POINTER(IUnknown), DWORD, POINTER(COSERVERINFO), DWORD, POINTER(MULTI_QI)) +CoCreateInstanceExParams = ((1, 'rclsid'), (1, 'punkOuter'), (1, 'dwClsCtx'), (1, 'pServerInfo'), (1, 'dwCount'), (1, 'pResults')) + +#def CoGetClassObject(rclsid, dwClsContext, pvReserved, riid, ppv): +# return CoGetClassObject.ctypes_function(rclsid, dwClsContext, pvReserved, riid, ppv) +CoGetClassObjectPrototype = WINFUNCTYPE(HRESULT, REFCLSID, DWORD, LPVOID, REFIID, POINTER(LPVOID)) +CoGetClassObjectParams = ((1, 'rclsid'), (1, 'dwClsContext'), (1, 'pvReserved'), (1, 'riid'), (1, 'ppv')) + +#def CoGetInterceptor(iidIntercepted, punkOuter, iid, ppv): +# return CoGetInterceptor.ctypes_function(iidIntercepted, punkOuter, iid, ppv) +CoGetInterceptorPrototype = WINFUNCTYPE(HRESULT, REFIID, POINTER(IUnknown), REFIID, POINTER(PVOID)) +CoGetInterceptorParams = ((1, 'iidIntercepted'), (1, 'punkOuter'), (1, 'iid'), (1, 'ppv')) + +#def CLSIDFromProgID(lpszProgID, lpclsid): +# return CLSIDFromProgID.ctypes_function(lpszProgID, lpclsid) +CLSIDFromProgIDPrototype = WINFUNCTYPE(HRESULT, LPCOLESTR, LPCLSID) +CLSIDFromProgIDParams = ((1, 'lpszProgID'), (1, 'lpclsid')) + +#def CoTaskMemFree(pv): +# return CoTaskMemFree.ctypes_function(pv) +CoTaskMemFreePrototype = WINFUNCTYPE(PVOID, LPVOID) +CoTaskMemFreeParams = ((1, 'pv'),) + +#def SymLoadModuleExA(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags): +# return SymLoadModuleExA.ctypes_function(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags) +SymLoadModuleExAPrototype = WINFUNCTYPE(DWORD64, HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD, PMODLOAD_DATA, DWORD) +SymLoadModuleExAParams = ((1, 'hProcess'), (1, 'hFile'), (1, 'ImageName'), (1, 'ModuleName'), (1, 'BaseOfDll'), (1, 'DllSize'), (1, 'Data'), (1, 'Flags')) + +#def SymLoadModuleExW(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags): +# return SymLoadModuleExW.ctypes_function(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags) +SymLoadModuleExWPrototype = WINFUNCTYPE(DWORD64, HANDLE, HANDLE, PCWSTR, PCWSTR, DWORD64, DWORD, PMODLOAD_DATA, DWORD) +SymLoadModuleExWParams = ((1, 'hProcess'), (1, 'hFile'), (1, 'ImageName'), (1, 'ModuleName'), (1, 'BaseOfDll'), (1, 'DllSize'), (1, 'Data'), (1, 'Flags')) + +#def SymFromAddr(hProcess, Address, Displacement, Symbol): +# return SymFromAddr.ctypes_function(hProcess, Address, Displacement, Symbol) +SymFromAddrPrototype = WINFUNCTYPE(BOOL, HANDLE, DWORD64, PDWORD64, PSYMBOL_INFO) +SymFromAddrParams = ((1, 'hProcess'), (1, 'Address'), (1, 'Displacement'), (1, 'Symbol')) + +#def SymGetModuleInfo64(hProcess, dwAddr, ModuleInfo): +# return SymGetModuleInfo64.ctypes_function(hProcess, dwAddr, ModuleInfo) +SymGetModuleInfo64Prototype = WINFUNCTYPE(BOOL, HANDLE, DWORD64, PIMAGEHLP_MODULE64) +SymGetModuleInfo64Params = ((1, 'hProcess'), (1, 'dwAddr'), (1, 'ModuleInfo')) + +#def SymInitialize(hProcess, UserSearchPath, fInvadeProcess): +# return SymInitialize.ctypes_function(hProcess, UserSearchPath, fInvadeProcess) +SymInitializePrototype = WINFUNCTYPE(BOOL, HANDLE, LPCSTR, BOOL) +SymInitializeParams = ((1, 'hProcess'), (1, 'UserSearchPath'), (1, 'fInvadeProcess')) + +#def SymFromName(hProcess, Name, Symbol): +# return SymFromName.ctypes_function(hProcess, Name, Symbol) +SymFromNamePrototype = WINFUNCTYPE(BOOL, HANDLE, LPCSTR, PSYMBOL_INFO) +SymFromNameParams = ((1, 'hProcess'), (1, 'Name'), (1, 'Symbol')) + +#def SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags): +# return SymLoadModuleEx.ctypes_function(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags) +SymLoadModuleExPrototype = WINFUNCTYPE(DWORD64, HANDLE, HANDLE, LPCSTR, LPCSTR, DWORD64, DWORD, PMODLOAD_DATA, DWORD) +SymLoadModuleExParams = ((1, 'hProcess'), (1, 'hFile'), (1, 'ImageName'), (1, 'ModuleName'), (1, 'BaseOfDll'), (1, 'DllSize'), (1, 'Data'), (1, 'Flags')) + +#def SymSetOptions(SymOptions): +# return SymSetOptions.ctypes_function(SymOptions) +SymSetOptionsPrototype = WINFUNCTYPE(DWORD, DWORD) +SymSetOptionsParams = ((1, 'SymOptions'),) + +#def SymEnumSymbols(hProcess, BaseOfDll, Mask, EnumSymbolsCallback, UserContext): +# return SymEnumSymbols.ctypes_function(hProcess, BaseOfDll, Mask, EnumSymbolsCallback, UserContext) +SymEnumSymbolsPrototype = WINFUNCTYPE(BOOL, HANDLE, ULONG64, PCSTR, PVOID, PVOID) +SymEnumSymbolsParams = ((1, 'hProcess'), (1, 'BaseOfDll'), (1, 'Mask'), (1, 'EnumSymbolsCallback'), (1, 'UserContext')) + +#def SymEnumSymbolsEx(hProcess, BaseOfDll, Mask, EnumSymbolsCallback, UserContext, Options): +# return SymEnumSymbolsEx.ctypes_function(hProcess, BaseOfDll, Mask, EnumSymbolsCallback, UserContext, Options) +SymEnumSymbolsExPrototype = WINFUNCTYPE(BOOL, HANDLE, ULONG64, PCSTR, PVOID, PVOID, DWORD) +SymEnumSymbolsExParams = ((1, 'hProcess'), (1, 'BaseOfDll'), (1, 'Mask'), (1, 'EnumSymbolsCallback'), (1, 'UserContext'), (1, 'Options')) + +#def SymEnumTypes(hProcess, BaseOfDll, EnumSymbolsCallback, UserContext): +# return SymEnumTypes.ctypes_function(hProcess, BaseOfDll, EnumSymbolsCallback, UserContext) +SymEnumTypesPrototype = WINFUNCTYPE(BOOL, HANDLE, ULONG64, PVOID, PVOID) +SymEnumTypesParams = ((1, 'hProcess'), (1, 'BaseOfDll'), (1, 'EnumSymbolsCallback'), (1, 'UserContext')) + +#def SymEnumTypesByName(hProcess, BaseOfDll, mask, EnumSymbolsCallback, UserContext): +# return SymEnumTypesByName.ctypes_function(hProcess, BaseOfDll, mask, EnumSymbolsCallback, UserContext) +SymEnumTypesByNamePrototype = WINFUNCTYPE(BOOL, HANDLE, ULONG64, PCSTR, PVOID, PVOID) +SymEnumTypesByNameParams = ((1, 'hProcess'), (1, 'BaseOfDll'), (1, 'mask'), (1, 'EnumSymbolsCallback'), (1, 'UserContext')) + +#def SymEnumerateModules64(hProcess, EnumModulesCallback, UserContext): +# return SymEnumerateModules64.ctypes_function(hProcess, EnumModulesCallback, UserContext) +SymEnumerateModules64Prototype = WINFUNCTYPE(BOOL, HANDLE, PVOID, PVOID) +SymEnumerateModules64Params = ((1, 'hProcess'), (1, 'EnumModulesCallback'), (1, 'UserContext')) + +#def SymGetTypeFromName(hProcess, BaseOfDll, Name, Symbol): +# return SymGetTypeFromName.ctypes_function(hProcess, BaseOfDll, Name, Symbol) +SymGetTypeFromNamePrototype = WINFUNCTYPE(BOOL, HANDLE, ULONG64, PCSTR, PSYMBOL_INFO) +SymGetTypeFromNameParams = ((1, 'hProcess'), (1, 'BaseOfDll'), (1, 'Name'), (1, 'Symbol')) + +#def SymGetTypeInfo(hProcess, ModBase, TypeId, GetType, pInfo): +# return SymGetTypeInfo.ctypes_function(hProcess, ModBase, TypeId, GetType, pInfo) +SymGetTypeInfoPrototype = WINFUNCTYPE(BOOL, HANDLE, DWORD64, ULONG, IMAGEHLP_SYMBOL_TYPE_INFO, PVOID) +SymGetTypeInfoParams = ((1, 'hProcess'), (1, 'ModBase'), (1, 'TypeId'), (1, 'GetType'), (1, 'pInfo')) + +#def SymSearch(hProcess, BaseOfDll, Index, SymTag, Mask, Address, EnumSymbolsCallback, UserContext, Options): +# return SymSearch.ctypes_function(hProcess, BaseOfDll, Index, SymTag, Mask, Address, EnumSymbolsCallback, UserContext, Options) +SymSearchPrototype = WINFUNCTYPE(BOOL, HANDLE, ULONG64, DWORD, DWORD, PCSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID, DWORD) +SymSearchParams = ((1, 'hProcess'), (1, 'BaseOfDll'), (1, 'Index'), (1, 'SymTag'), (1, 'Mask'), (1, 'Address'), (1, 'EnumSymbolsCallback'), (1, 'UserContext'), (1, 'Options')) + +#def SymSearchW(hProcess, BaseOfDll, Index, SymTag, Mask, Address, EnumSymbolsCallback, UserContext, Options): +# return SymSearchW.ctypes_function(hProcess, BaseOfDll, Index, SymTag, Mask, Address, EnumSymbolsCallback, UserContext, Options) +SymSearchWPrototype = WINFUNCTYPE(BOOL, HANDLE, ULONG64, DWORD, DWORD, PCWSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID, DWORD) +SymSearchWParams = ((1, 'hProcess'), (1, 'BaseOfDll'), (1, 'Index'), (1, 'SymTag'), (1, 'Mask'), (1, 'Address'), (1, 'EnumSymbolsCallback'), (1, 'UserContext'), (1, 'Options')) #def OpenEventLogA(lpUNCServerName, lpSourceName): # return OpenEventLogA.ctypes_function(lpUNCServerName, lpSourceName) @@ -705,51 +795,11 @@ CreateFileAParams = ((1, 'lpFileName'), (1, 'dwDesiredAccess'), (1, 'dwShareMode CreateFileWPrototype = WINFUNCTYPE(HANDLE, LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE) CreateFileWParams = ((1, 'lpFileName'), (1, 'dwDesiredAccess'), (1, 'dwShareMode'), (1, 'lpSecurityAttributes'), (1, 'dwCreationDisposition'), (1, 'dwFlagsAndAttributes'), (1, 'hTemplateFile')) -#def NtCreateFile(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, AllocationSize, FileAttributes, ShareAccess, CreateDisposition, CreateOptions, EaBuffer, EaLength): -# return NtCreateFile.ctypes_function(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, AllocationSize, FileAttributes, ShareAccess, CreateDisposition, CreateOptions, EaBuffer, EaLength) -NtCreateFilePrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, PLARGE_INTEGER, ULONG, ULONG, ULONG, ULONG, PVOID, ULONG) -NtCreateFileParams = ((1, 'FileHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'IoStatusBlock'), (1, 'AllocationSize'), (1, 'FileAttributes'), (1, 'ShareAccess'), (1, 'CreateDisposition'), (1, 'CreateOptions'), (1, 'EaBuffer'), (1, 'EaLength')) - #def LdrLoadDll(PathToFile, Flags, ModuleFileName, ModuleHandle): # return LdrLoadDll.ctypes_function(PathToFile, Flags, ModuleFileName, ModuleHandle) LdrLoadDllPrototype = WINFUNCTYPE(NTSTATUS, LPCWSTR, ULONG, PUNICODE_STRING, PHANDLE) LdrLoadDllParams = ((1, 'PathToFile'), (1, 'Flags'), (1, 'ModuleFileName'), (1, 'ModuleHandle')) -#def NtQuerySystemInformation(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength): -# return NtQuerySystemInformation.ctypes_function(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength) -NtQuerySystemInformationPrototype = WINFUNCTYPE(NTSTATUS, SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG) -NtQuerySystemInformationParams = ((1, 'SystemInformationClass'), (1, 'SystemInformation'), (1, 'SystemInformationLength'), (1, 'ReturnLength')) - -#def NtQueryInformationProcess(ProcessHandle, ProcessInformationClass, ProcessInformation, ProcessInformationLength, ReturnLength): -# return NtQueryInformationProcess.ctypes_function(ProcessHandle, ProcessInformationClass, ProcessInformation, ProcessInformationLength, ReturnLength) -NtQueryInformationProcessPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG) -NtQueryInformationProcessParams = ((1, 'ProcessHandle'), (1, 'ProcessInformationClass'), (1, 'ProcessInformation'), (1, 'ProcessInformationLength'), (1, 'ReturnLength')) - -#def NtSetInformationProcess(ProcessHandle, ProcessInformationClass, ProcessInformation, ProcessInformationLength): -# return NtSetInformationProcess.ctypes_function(ProcessHandle, ProcessInformationClass, ProcessInformation, ProcessInformationLength) -NtSetInformationProcessPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PROCESS_INFORMATION_CLASS, PVOID, ULONG) -NtSetInformationProcessParams = ((1, 'ProcessHandle'), (1, 'ProcessInformationClass'), (1, 'ProcessInformation'), (1, 'ProcessInformationLength')) - -#def NtQueryVirtualMemory(ProcessHandle, BaseAddress, MemoryInformationClass, MemoryInformation, MemoryInformationLength, ReturnLength): -# return NtQueryVirtualMemory.ctypes_function(ProcessHandle, BaseAddress, MemoryInformationClass, MemoryInformation, MemoryInformationLength, ReturnLength) -NtQueryVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PVOID, MEMORY_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T) -NtQueryVirtualMemoryParams = ((1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'MemoryInformationClass'), (1, 'MemoryInformation'), (1, 'MemoryInformationLength'), (1, 'ReturnLength')) - -#def NtQueryVolumeInformationFile(FileHandle, IoStatusBlock, FsInformation, Length, FsInformationClass): -# return NtQueryVolumeInformationFile.ctypes_function(FileHandle, IoStatusBlock, FsInformation, Length, FsInformationClass) -NtQueryVolumeInformationFilePrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FS_INFORMATION_CLASS) -NtQueryVolumeInformationFileParams = ((1, 'FileHandle'), (1, 'IoStatusBlock'), (1, 'FsInformation'), (1, 'Length'), (1, 'FsInformationClass')) - -#def NtCreateThreadEx(ThreadHandle, DesiredAccess, ObjectAttributes, ProcessHandle, lpStartAddress, lpParameter, CreateSuspended, dwStackSize, Unknown1, Unknown2, Unknown3): -# return NtCreateThreadEx.ctypes_function(ThreadHandle, DesiredAccess, ObjectAttributes, ProcessHandle, lpStartAddress, lpParameter, CreateSuspended, dwStackSize, Unknown1, Unknown2, Unknown3) -NtCreateThreadExPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, LPVOID, HANDLE, LPTHREAD_START_ROUTINE, LPVOID, BOOL, DWORD, DWORD, DWORD, LPVOID) -NtCreateThreadExParams = ((1, 'ThreadHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'ProcessHandle'), (1, 'lpStartAddress'), (1, 'lpParameter'), (1, 'CreateSuspended'), (1, 'dwStackSize'), (1, 'Unknown1'), (1, 'Unknown2'), (1, 'Unknown3')) - -#def NtQueryInformationThread(ThreadHandle, ThreadInformationClass, ThreadInformation, ThreadInformationLength, ReturnLength): -# return NtQueryInformationThread.ctypes_function(ThreadHandle, ThreadInformationClass, ThreadInformation, ThreadInformationLength, ReturnLength) -NtQueryInformationThreadPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, THREAD_INFORMATION_CLASS, PVOID, ULONG, PULONG) -NtQueryInformationThreadParams = ((1, 'ThreadHandle'), (1, 'ThreadInformationClass'), (1, 'ThreadInformation'), (1, 'ThreadInformationLength'), (1, 'ReturnLength')) - #def GetExitCodeThread(hThread, lpExitCode): # return GetExitCodeThread.ctypes_function(hThread, lpExitCode) GetExitCodeThreadPrototype = WINFUNCTYPE(BOOL, HANDLE, LPDWORD) @@ -780,16 +830,6 @@ VirtualAllocParams = ((1, 'lpAddress'), (1, 'dwSize'), (1, 'flAllocationType'), VirtualAllocExPrototype = WINFUNCTYPE(LPVOID, HANDLE, LPVOID, SIZE_T, DWORD, DWORD) VirtualAllocExParams = ((1, 'hProcess'), (1, 'lpAddress'), (1, 'dwSize'), (1, 'flAllocationType'), (1, 'flProtect')) -#def NtAllocateVirtualMemory(ProcessHandle, BaseAddress, ZeroBits, RegionSize, AllocationType, Protect): -# return NtAllocateVirtualMemory.ctypes_function(ProcessHandle, BaseAddress, ZeroBits, RegionSize, AllocationType, Protect) -NtAllocateVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, POINTER(PVOID), ULONG_PTR, PSIZE_T, ULONG, ULONG) -NtAllocateVirtualMemoryParams = ((1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'ZeroBits'), (1, 'RegionSize'), (1, 'AllocationType'), (1, 'Protect')) - -#def NtProtectVirtualMemory(ProcessHandle, BaseAddress, NumberOfBytesToProtect, NewAccessProtection, OldAccessProtection): -# return NtProtectVirtualMemory.ctypes_function(ProcessHandle, BaseAddress, NumberOfBytesToProtect, NewAccessProtection, OldAccessProtection) -NtProtectVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, POINTER(PVOID), PULONG, ULONG, PULONG) -NtProtectVirtualMemoryParams = ((1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'NumberOfBytesToProtect'), (1, 'NewAccessProtection'), (1, 'OldAccessProtection')) - #def VirtualFree(lpAddress, dwSize, dwFreeType): # return VirtualFree.ctypes_function(lpAddress, dwSize, dwFreeType) VirtualFreePrototype = WINFUNCTYPE(BOOL, LPVOID, SIZE_T, DWORD) @@ -800,11 +840,6 @@ VirtualFreeParams = ((1, 'lpAddress'), (1, 'dwSize'), (1, 'dwFreeType')) VirtualFreeExPrototype = WINFUNCTYPE(BOOL, HANDLE, LPVOID, SIZE_T, DWORD) VirtualFreeExParams = ((1, 'hProcess'), (1, 'lpAddress'), (1, 'dwSize'), (1, 'dwFreeType')) -#def NtFreeVirtualMemory(ProcessHandle, BaseAddress, RegionSize, FreeType): -# return NtFreeVirtualMemory.ctypes_function(ProcessHandle, BaseAddress, RegionSize, FreeType) -NtFreeVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, POINTER(PVOID), PSIZE_T, ULONG) -NtFreeVirtualMemoryParams = ((1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'RegionSize'), (1, 'FreeType')) - #def VirtualProtect(lpAddress, dwSize, flNewProtect, lpflOldProtect): # return VirtualProtect.ctypes_function(lpAddress, dwSize, flNewProtect, lpflOldProtect) VirtualProtectPrototype = WINFUNCTYPE(BOOL, LPVOID, SIZE_T, DWORD, PDWORD) @@ -885,21 +920,11 @@ CreateProcessAsUserWParams = ((1, 'hToken'), (1, 'lpApplicationName'), (1, 'lpCo GetThreadContextPrototype = WINFUNCTYPE(BOOL, HANDLE, LPCONTEXT) GetThreadContextParams = ((1, 'hThread'), (1, 'lpContext')) -#def NtGetContextThread(hThread, lpContext): -# return NtGetContextThread.ctypes_function(hThread, lpContext) -NtGetContextThreadPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, LPCONTEXT) -NtGetContextThreadParams = ((1, 'hThread'), (1, 'lpContext')) - #def SetThreadContext(hThread, lpContext): # return SetThreadContext.ctypes_function(hThread, lpContext) SetThreadContextPrototype = WINFUNCTYPE(BOOL, HANDLE, LPCONTEXT) SetThreadContextParams = ((1, 'hThread'), (1, 'lpContext')) -#def NtSetContextThread(hThread, lpContext): -# return NtSetContextThread.ctypes_function(hThread, lpContext) -NtSetContextThreadPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, LPCONTEXT) -NtSetContextThreadParams = ((1, 'hThread'), (1, 'lpContext')) - #def OpenThread(dwDesiredAccess, bInheritHandle, dwThreadId): # return OpenThread.ctypes_function(dwDesiredAccess, bInheritHandle, dwThreadId) OpenThreadPrototype = WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD) @@ -925,11 +950,6 @@ ReadProcessMemoryParams = ((1, 'hProcess'), (1, 'lpBaseAddress'), (1, 'lpBuffer' NtWow64ReadVirtualMemory64Prototype = WINFUNCTYPE(NTSTATUS, HANDLE, ULONG64, LPVOID, ULONG64, PULONG64) NtWow64ReadVirtualMemory64Params = ((1, 'hProcess'), (1, 'lpBaseAddress'), (1, 'lpBuffer'), (1, 'nSize'), (1, 'lpNumberOfBytesRead')) -#def NtReadVirtualMemory(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead): -# return NtReadVirtualMemory.ctypes_function(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead) -NtReadVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PVOID, LPVOID, ULONG, PULONG) -NtReadVirtualMemoryParams = ((1, 'hProcess'), (1, 'lpBaseAddress'), (1, 'lpBuffer'), (1, 'nSize'), (1, 'lpNumberOfBytesRead')) - #def WriteProcessMemory(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesWritten): # return WriteProcessMemory.ctypes_function(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesWritten) WriteProcessMemoryPrototype = WINFUNCTYPE(BOOL, HANDLE, LPVOID, LPCVOID, SIZE_T, POINTER(SIZE_T)) @@ -940,11 +960,6 @@ WriteProcessMemoryParams = ((1, 'hProcess'), (1, 'lpBaseAddress'), (1, 'lpBuffer NtWow64WriteVirtualMemory64Prototype = WINFUNCTYPE(NTSTATUS, HANDLE, ULONG64, LPVOID, ULONG64, PULONG64) NtWow64WriteVirtualMemory64Params = ((1, 'hProcess'), (1, 'lpBaseAddress'), (1, 'lpBuffer'), (1, 'nSize'), (1, 'lpNumberOfBytesWritten')) -#def NtWriteVirtualMemory(ProcessHandle, BaseAddress, Buffer, NumberOfBytesToWrite, NumberOfBytesWritten): -# return NtWriteVirtualMemory.ctypes_function(ProcessHandle, BaseAddress, Buffer, NumberOfBytesToWrite, NumberOfBytesWritten) -NtWriteVirtualMemoryPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PVOID, PVOID, ULONG, PULONG) -NtWriteVirtualMemoryParams = ((1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'Buffer'), (1, 'NumberOfBytesToWrite'), (1, 'NumberOfBytesWritten')) - #def CreateToolhelp32Snapshot(dwFlags, th32ProcessID): # return CreateToolhelp32Snapshot.ctypes_function(dwFlags, th32ProcessID) CreateToolhelp32SnapshotPrototype = WINFUNCTYPE(HANDLE, DWORD, DWORD) @@ -1150,21 +1165,6 @@ ReadFileParams = ((1, 'hFile'), (1, 'lpBuffer'), (1, 'nNumberOfBytesToRead'), (1 WriteFilePrototype = WINFUNCTYPE(BOOL, HANDLE, LPCVOID, DWORD, LPDWORD, LPOVERLAPPED) WriteFileParams = ((1, 'hFile'), (1, 'lpBuffer'), (1, 'nNumberOfBytesToWrite'), (1, 'lpNumberOfBytesWritten'), (1, 'lpOverlapped')) -#def GetExtendedTcpTable(pTcpTable, pdwSize, bOrder, ulAf, TableClass, Reserved): -# return GetExtendedTcpTable.ctypes_function(pTcpTable, pdwSize, bOrder, ulAf, TableClass, Reserved) -GetExtendedTcpTablePrototype = WINFUNCTYPE(DWORD, PVOID, PDWORD, BOOL, ULONG, TCP_TABLE_CLASS, ULONG) -GetExtendedTcpTableParams = ((1, 'pTcpTable'), (1, 'pdwSize'), (1, 'bOrder'), (1, 'ulAf'), (1, 'TableClass'), (1, 'Reserved')) - -#def GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, ulAf, TableClass, Reserved): -# return GetExtendedUdpTable.ctypes_function(pUdpTable, pdwSize, bOrder, ulAf, TableClass, Reserved) -GetExtendedUdpTablePrototype = WINFUNCTYPE(DWORD, PVOID, PDWORD, BOOL, ULONG, UDP_TABLE_CLASS, ULONG) -GetExtendedUdpTableParams = ((1, 'pUdpTable'), (1, 'pdwSize'), (1, 'bOrder'), (1, 'ulAf'), (1, 'TableClass'), (1, 'Reserved')) - -#def SetTcpEntry(pTcpRow): -# return SetTcpEntry.ctypes_function(pTcpRow) -SetTcpEntryPrototype = WINFUNCTYPE(DWORD, PMIB_TCPROW) -SetTcpEntryParams = ((1, 'pTcpRow'),) - #def AddVectoredContinueHandler(FirstHandler, VectoredHandler): # return AddVectoredContinueHandler.ctypes_function(FirstHandler, VectoredHandler) AddVectoredContinueHandlerPrototype = WINFUNCTYPE(PVOID, ULONG, PVECTORED_EXCEPTION_HANDLER) @@ -1220,31 +1220,6 @@ LoadLibraryExAParams = ((1, 'lpFileName'), (1, 'hFile'), (1, 'dwFlags')) LoadLibraryExWPrototype = WINFUNCTYPE(HMODULE, LPCWSTR, HANDLE, DWORD) LoadLibraryExWParams = ((1, 'lpFileName'), (1, 'hFile'), (1, 'dwFlags')) -#def SymInitialize(hProcess, UserSearchPath, fInvadeProcess): -# return SymInitialize.ctypes_function(hProcess, UserSearchPath, fInvadeProcess) -SymInitializePrototype = WINFUNCTYPE(BOOL, HANDLE, LPCSTR, BOOL) -SymInitializeParams = ((1, 'hProcess'), (1, 'UserSearchPath'), (1, 'fInvadeProcess')) - -#def SymFromName(hProcess, Name, Symbol): -# return SymFromName.ctypes_function(hProcess, Name, Symbol) -SymFromNamePrototype = WINFUNCTYPE(BOOL, HANDLE, LPCSTR, PSYMBOL_INFO) -SymFromNameParams = ((1, 'hProcess'), (1, 'Name'), (1, 'Symbol')) - -#def SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags): -# return SymLoadModuleEx.ctypes_function(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags) -SymLoadModuleExPrototype = WINFUNCTYPE(DWORD64, HANDLE, HANDLE, LPCSTR, LPCSTR, DWORD64, DWORD, PMODLOAD_DATA, DWORD) -SymLoadModuleExParams = ((1, 'hProcess'), (1, 'hFile'), (1, 'ImageName'), (1, 'ModuleName'), (1, 'BaseOfDll'), (1, 'DllSize'), (1, 'Data'), (1, 'Flags')) - -#def SymSetOptions(SymOptions): -# return SymSetOptions.ctypes_function(SymOptions) -SymSetOptionsPrototype = WINFUNCTYPE(DWORD, DWORD) -SymSetOptionsParams = ((1, 'SymOptions'),) - -#def SymGetTypeInfo(hProcess, ModBase, TypeId, GetType, pInfo): -# return SymGetTypeInfo.ctypes_function(hProcess, ModBase, TypeId, GetType, pInfo) -SymGetTypeInfoPrototype = WINFUNCTYPE(BOOL, HANDLE, DWORD64, ULONG, IMAGEHLP_SYMBOL_TYPE_INFO, PVOID) -SymGetTypeInfoParams = ((1, 'hProcess'), (1, 'ModBase'), (1, 'TypeId'), (1, 'GetType'), (1, 'pInfo')) - #def DeviceIoControl(hDevice, dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped): # return DeviceIoControl.ctypes_function(hDevice, dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped) DeviceIoControlPrototype = WINFUNCTYPE(BOOL, HANDLE, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPOVERLAPPED) @@ -1485,26 +1460,6 @@ RtlDecompressBufferExParams = ((1, 'CompressionFormat'), (1, 'UncompressedBuffer RtlGetCompressionWorkSpaceSizePrototype = WINFUNCTYPE(NTSTATUS, USHORT, PULONG, PULONG) RtlGetCompressionWorkSpaceSizeParams = ((1, 'CompressionFormatAndEngine'), (1, 'CompressBufferWorkSpaceSize'), (1, 'CompressFragmentWorkSpaceSize')) -#def NtCreateSection(SectionHandle, DesiredAccess, ObjectAttributes, MaximumSize, SectionPageProtection, AllocationAttributes, FileHandle): -# return NtCreateSection.ctypes_function(SectionHandle, DesiredAccess, ObjectAttributes, MaximumSize, SectionPageProtection, AllocationAttributes, FileHandle) -NtCreateSectionPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PLARGE_INTEGER, ULONG, ULONG, HANDLE) -NtCreateSectionParams = ((1, 'SectionHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'MaximumSize'), (1, 'SectionPageProtection'), (1, 'AllocationAttributes'), (1, 'FileHandle')) - -#def NtOpenSection(SectionHandle, DesiredAccess, ObjectAttributes): -# return NtOpenSection.ctypes_function(SectionHandle, DesiredAccess, ObjectAttributes) -NtOpenSectionPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES) -NtOpenSectionParams = ((1, 'SectionHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes')) - -#def NtMapViewOfSection(SectionHandle, ProcessHandle, BaseAddress, ZeroBits, CommitSize, SectionOffset, ViewSize, InheritDisposition, AllocationType, Win32Protect): -# return NtMapViewOfSection.ctypes_function(SectionHandle, ProcessHandle, BaseAddress, ZeroBits, CommitSize, SectionOffset, ViewSize, InheritDisposition, AllocationType, Win32Protect) -NtMapViewOfSectionPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, HANDLE, POINTER(PVOID), ULONG_PTR, SIZE_T, PLARGE_INTEGER, PSIZE_T, SECTION_INHERIT, ULONG, ULONG) -NtMapViewOfSectionParams = ((1, 'SectionHandle'), (1, 'ProcessHandle'), (1, 'BaseAddress'), (1, 'ZeroBits'), (1, 'CommitSize'), (1, 'SectionOffset'), (1, 'ViewSize'), (1, 'InheritDisposition'), (1, 'AllocationType'), (1, 'Win32Protect')) - -#def NtUnmapViewOfSection(ProcessHandle, BaseAddress): -# return NtUnmapViewOfSection.ctypes_function(ProcessHandle, BaseAddress) -NtUnmapViewOfSectionPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PVOID) -NtUnmapViewOfSectionParams = ((1, 'ProcessHandle'), (1, 'BaseAddress')) - #def OpenEventA(dwDesiredAccess, bInheritHandle, lpName): # return OpenEventA.ctypes_function(dwDesiredAccess, bInheritHandle, lpName) OpenEventAPrototype = WINFUNCTYPE(HANDLE, DWORD, BOOL, LPCSTR) @@ -1515,11 +1470,6 @@ OpenEventAParams = ((1, 'dwDesiredAccess'), (1, 'bInheritHandle'), (1, 'lpName') OpenEventWPrototype = WINFUNCTYPE(HANDLE, DWORD, BOOL, LPCWSTR) OpenEventWParams = ((1, 'dwDesiredAccess'), (1, 'bInheritHandle'), (1, 'lpName')) -#def NtOpenEvent(EventHandle, DesiredAccess, ObjectAttributes): -# return NtOpenEvent.ctypes_function(EventHandle, DesiredAccess, ObjectAttributes) -NtOpenEventPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES) -NtOpenEventParams = ((1, 'EventHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes')) - #def lstrcmpA(lpString1, lpString2): # return lstrcmpA.ctypes_function(lpString1, lpString2) lstrcmpAPrototype = WINFUNCTYPE(INT, LPCSTR, LPCSTR) @@ -1660,11 +1610,6 @@ FindNextVolumeAParams = ((1, 'hFindVolume'), (1, 'lpszVolumeName'), (1, 'cchBuff FindNextVolumeWPrototype = WINFUNCTYPE(BOOL, HANDLE, LPWSTR, DWORD) FindNextVolumeWParams = ((1, 'hFindVolume'), (1, 'lpszVolumeName'), (1, 'cchBufferLength')) -#def NtQueryObject(Handle, ObjectInformationClass, ObjectInformation, ObjectInformationLength, ReturnLength): -# return NtQueryObject.ctypes_function(Handle, ObjectInformationClass, ObjectInformation, ObjectInformationLength, ReturnLength) -NtQueryObjectPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG, PULONG) -NtQueryObjectParams = ((1, 'Handle'), (1, 'ObjectInformationClass'), (1, 'ObjectInformation'), (1, 'ObjectInformationLength'), (1, 'ReturnLength')) - #def DuplicateHandle(hSourceProcessHandle, hSourceHandle, hTargetProcessHandle, lpTargetHandle, dwDesiredAccess, bInheritHandle, dwOptions): # return DuplicateHandle.ctypes_function(hSourceProcessHandle, hSourceHandle, hTargetProcessHandle, lpTargetHandle, dwDesiredAccess, bInheritHandle, dwOptions) DuplicateHandlePrototype = WINFUNCTYPE(BOOL, HANDLE, HANDLE, HANDLE, LPHANDLE, DWORD, BOOL, DWORD) @@ -1765,26 +1710,6 @@ GetIfTableParams = ((1, 'pIfTable'), (1, 'pdwSize'), (1, 'bOrder')) GetIpAddrTablePrototype = WINFUNCTYPE(DWORD, PMIB_IPADDRTABLE, PULONG, BOOL) GetIpAddrTableParams = ((1, 'pIpAddrTable'), (1, 'pdwSize'), (1, 'bOrder')) -#def NtOpenDirectoryObject(DirectoryHandle, DesiredAccess, ObjectAttributes): -# return NtOpenDirectoryObject.ctypes_function(DirectoryHandle, DesiredAccess, ObjectAttributes) -NtOpenDirectoryObjectPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES) -NtOpenDirectoryObjectParams = ((1, 'DirectoryHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes')) - -#def NtQueryDirectoryObject(DirectoryHandle, Buffer, Length, ReturnSingleEntry, RestartScan, Context, ReturnLength): -# return NtQueryDirectoryObject.ctypes_function(DirectoryHandle, Buffer, Length, ReturnSingleEntry, RestartScan, Context, ReturnLength) -NtQueryDirectoryObjectPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PVOID, ULONG, BOOLEAN, BOOLEAN, PULONG, PULONG) -NtQueryDirectoryObjectParams = ((1, 'DirectoryHandle'), (1, 'Buffer'), (1, 'Length'), (1, 'ReturnSingleEntry'), (1, 'RestartScan'), (1, 'Context'), (1, 'ReturnLength')) - -#def NtQuerySymbolicLinkObject(LinkHandle, LinkTarget, ReturnedLength): -# return NtQuerySymbolicLinkObject.ctypes_function(LinkHandle, LinkTarget, ReturnedLength) -NtQuerySymbolicLinkObjectPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PUNICODE_STRING, PULONG) -NtQuerySymbolicLinkObjectParams = ((1, 'LinkHandle'), (1, 'LinkTarget'), (1, 'ReturnedLength')) - -#def NtOpenSymbolicLinkObject(LinkHandle, DesiredAccess, ObjectAttributes): -# return NtOpenSymbolicLinkObject.ctypes_function(LinkHandle, DesiredAccess, ObjectAttributes) -NtOpenSymbolicLinkObjectPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES) -NtOpenSymbolicLinkObjectParams = ((1, 'LinkHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes')) - #def GetProcessTimes(hProcess, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime): # return GetProcessTimes.ctypes_function(hProcess, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime) GetProcessTimesPrototype = WINFUNCTYPE(BOOL, HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME) @@ -1905,16 +1830,6 @@ GetWindowsDirectoryWParams = ((1, 'lpBuffer'), (1, 'uSize')) RtlGetUnloadEventTraceExPrototype = WINFUNCTYPE(VOID, POINTER(PULONG), POINTER(PULONG), POINTER(PVOID)) RtlGetUnloadEventTraceExParams = ((1, 'ElementSize'), (1, 'ElementCount'), (1, 'EventTrace')) -#def NtQueryInformationFile(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass): -# return NtQueryInformationFile.ctypes_function(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass) -NtQueryInformationFilePrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS) -NtQueryInformationFileParams = ((1, 'FileHandle'), (1, 'IoStatusBlock'), (1, 'FileInformation'), (1, 'Length'), (1, 'FileInformationClass')) - -#def NtQueryDirectoryFile(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, FileInformation, Length, FileInformationClass, ReturnSingleEntry, FileName, RestartScan): -# return NtQueryDirectoryFile.ctypes_function(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, FileInformation, Length, FileInformationClass, ReturnSingleEntry, FileName, RestartScan) -NtQueryDirectoryFilePrototype = WINFUNCTYPE(NTSTATUS, HANDLE, HANDLE, PIO_APC_ROUTINE, PVOID, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS, BOOLEAN, PUNICODE_STRING, BOOLEAN) -NtQueryDirectoryFileParams = ((1, 'FileHandle'), (1, 'Event'), (1, 'ApcRoutine'), (1, 'ApcContext'), (1, 'IoStatusBlock'), (1, 'FileInformation'), (1, 'Length'), (1, 'FileInformationClass'), (1, 'ReturnSingleEntry'), (1, 'FileName'), (1, 'RestartScan')) - #def RtlDosPathNameToNtPathName_U(DosName, NtName, PartName, RelativeName): # return RtlDosPathNameToNtPathName_U.ctypes_function(DosName, NtName, PartName, RelativeName) RtlDosPathNameToNtPathName_UPrototype = WINFUNCTYPE(BOOLEAN, PCWSTR, PUNICODE_STRING, POINTER(PCWSTR), PRTL_RELATIVE_NAME_U) @@ -1950,11 +1865,6 @@ SetProcessMitigationPolicyParams = ((1, 'MitigationPolicy'), (1, 'lpBuffer'), (1 GetProductInfoPrototype = WINFUNCTYPE(BOOL, DWORD, DWORD, DWORD, DWORD, PDWORD) GetProductInfoParams = ((1, 'dwOSMajorVersion'), (1, 'dwOSMinorVersion'), (1, 'dwSpMajorVersion'), (1, 'dwSpMinorVersion'), (1, 'pdwReturnedProductType')) -#def NtSetInformationFile(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass): -# return NtSetInformationFile.ctypes_function(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass) -NtSetInformationFilePrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS) -NtSetInformationFileParams = ((1, 'FileHandle'), (1, 'IoStatusBlock'), (1, 'FileInformation'), (1, 'Length'), (1, 'FileInformationClass')) - #def GetProcessMemoryInfo(Process, ppsmemCounters, cb): # return GetProcessMemoryInfo.ctypes_function(Process, ppsmemCounters, cb) GetProcessMemoryInfoPrototype = WINFUNCTYPE(BOOL, HANDLE, PPROCESS_MEMORY_COUNTERS, DWORD) @@ -1995,35 +1905,295 @@ GetFirmwareEnvironmentVariableExAParams = ((1, 'lpName'), (1, 'lpGuid'), (1, 'pB GetFirmwareEnvironmentVariableExWPrototype = WINFUNCTYPE(DWORD, LPCWSTR, LPCWSTR, PVOID, DWORD, PDWORD) GetFirmwareEnvironmentVariableExWParams = ((1, 'lpName'), (1, 'lpGuid'), (1, 'pBuffer'), (1, 'nSize'), (1, 'pdwAttribubutes')) -#def NtEnumerateSystemEnvironmentValuesEx(InformationClass, Buffer, BufferLength): -# return NtEnumerateSystemEnvironmentValuesEx.ctypes_function(InformationClass, Buffer, BufferLength) -NtEnumerateSystemEnvironmentValuesExPrototype = WINFUNCTYPE(NTSTATUS, ULONG, PVOID, ULONG) -NtEnumerateSystemEnvironmentValuesExParams = ((1, 'InformationClass'), (1, 'Buffer'), (1, 'BufferLength')) +#def GetCursorPos(lpPoint): +# return GetCursorPos.ctypes_function(lpPoint) +GetCursorPosPrototype = WINFUNCTYPE(BOOL, LPPOINT) +GetCursorPosParams = ((1, 'lpPoint'),) -#def NtOpenKey(KeyHandle, DesiredAccess, ObjectAttributes): -# return NtOpenKey.ctypes_function(KeyHandle, DesiredAccess, ObjectAttributes) -NtOpenKeyPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES) -NtOpenKeyParams = ((1, 'KeyHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes')) +#def WindowFromPoint(Point): +# return WindowFromPoint.ctypes_function(Point) +WindowFromPointPrototype = WINFUNCTYPE(HWND, POINT) +WindowFromPointParams = ((1, 'Point'),) -#def NtCreateKey(pKeyHandle, DesiredAccess, ObjectAttributes, TitleIndex, Class, CreateOptions, Disposition): -# return NtCreateKey.ctypes_function(pKeyHandle, DesiredAccess, ObjectAttributes, TitleIndex, Class, CreateOptions, Disposition) -NtCreateKeyPrototype = WINFUNCTYPE(NTSTATUS, PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG, PUNICODE_STRING, ULONG, PULONG) -NtCreateKeyParams = ((1, 'pKeyHandle'), (1, 'DesiredAccess'), (1, 'ObjectAttributes'), (1, 'TitleIndex'), (1, 'Class'), (1, 'CreateOptions'), (1, 'Disposition')) +#def GetWindowRect(hWnd, lpRect): +# return GetWindowRect.ctypes_function(hWnd, lpRect) +GetWindowRectPrototype = WINFUNCTYPE(BOOL, HWND, LPRECT) +GetWindowRectParams = ((1, 'hWnd'), (1, 'lpRect')) -#def NtSetValueKey(KeyHandle, ValueName, TitleIndex, Type, Data, DataSize): -# return NtSetValueKey.ctypes_function(KeyHandle, ValueName, TitleIndex, Type, Data, DataSize) -NtSetValueKeyPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PUNICODE_STRING, ULONG, ULONG, PVOID, ULONG) -NtSetValueKeyParams = ((1, 'KeyHandle'), (1, 'ValueName'), (1, 'TitleIndex'), (1, 'Type'), (1, 'Data'), (1, 'DataSize')) +#def EnumWindows(lpEnumFunc, lParam): +# return EnumWindows.ctypes_function(lpEnumFunc, lParam) +EnumWindowsPrototype = WINFUNCTYPE(BOOL, WNDENUMPROC, LPARAM) +EnumWindowsParams = ((1, 'lpEnumFunc'), (1, 'lParam')) -#def NtQueryValueKey(KeyHandle, ValueName, KeyValueInformationClass, KeyValueInformation, Length, ResultLength): -# return NtQueryValueKey.ctypes_function(KeyHandle, ValueName, KeyValueInformationClass, KeyValueInformation, Length, ResultLength) -NtQueryValueKeyPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, PUNICODE_STRING, KEY_VALUE_INFORMATION_CLASS, PVOID, ULONG, PULONG) -NtQueryValueKeyParams = ((1, 'KeyHandle'), (1, 'ValueName'), (1, 'KeyValueInformationClass'), (1, 'KeyValueInformation'), (1, 'Length'), (1, 'ResultLength')) +#def GetWindowTextA(hWnd, lpString, nMaxCount): +# return GetWindowTextA.ctypes_function(hWnd, lpString, nMaxCount) +GetWindowTextAPrototype = WINFUNCTYPE(INT, HWND, LPSTR, INT) +GetWindowTextAParams = ((1, 'hWnd'), (1, 'lpString'), (1, 'nMaxCount')) -#def NtEnumerateValueKey(KeyHandle, Index, KeyValueInformationClass, KeyValueInformation, Length, ResultLength): -# return NtEnumerateValueKey.ctypes_function(KeyHandle, Index, KeyValueInformationClass, KeyValueInformation, Length, ResultLength) -NtEnumerateValueKeyPrototype = WINFUNCTYPE(NTSTATUS, HANDLE, ULONG, KEY_VALUE_INFORMATION_CLASS, PVOID, ULONG, PULONG) -NtEnumerateValueKeyParams = ((1, 'KeyHandle'), (1, 'Index'), (1, 'KeyValueInformationClass'), (1, 'KeyValueInformation'), (1, 'Length'), (1, 'ResultLength')) +#def GetParent(hWnd): +# return GetParent.ctypes_function(hWnd) +GetParentPrototype = WINFUNCTYPE(HWND, HWND) +GetParentParams = ((1, 'hWnd'),) + +#def GetWindowTextW(hWnd, lpString, nMaxCount): +# return GetWindowTextW.ctypes_function(hWnd, lpString, nMaxCount) +GetWindowTextWPrototype = WINFUNCTYPE(INT, HWND, LPWSTR, INT) +GetWindowTextWParams = ((1, 'hWnd'), (1, 'lpString'), (1, 'nMaxCount')) + +#def GetWindowModuleFileNameA(hwnd, pszFileName, cchFileNameMax): +# return GetWindowModuleFileNameA.ctypes_function(hwnd, pszFileName, cchFileNameMax) +GetWindowModuleFileNameAPrototype = WINFUNCTYPE(UINT, HWND, LPSTR, UINT) +GetWindowModuleFileNameAParams = ((1, 'hwnd'), (1, 'pszFileName'), (1, 'cchFileNameMax')) + +#def GetWindowModuleFileNameW(hwnd, pszFileName, cchFileNameMax): +# return GetWindowModuleFileNameW.ctypes_function(hwnd, pszFileName, cchFileNameMax) +GetWindowModuleFileNameWPrototype = WINFUNCTYPE(UINT, HWND, LPWSTR, UINT) +GetWindowModuleFileNameWParams = ((1, 'hwnd'), (1, 'pszFileName'), (1, 'cchFileNameMax')) + +#def EnumChildWindows(hWndParent, lpEnumFunc, lParam): +# return EnumChildWindows.ctypes_function(hWndParent, lpEnumFunc, lParam) +EnumChildWindowsPrototype = WINFUNCTYPE(BOOL, HWND, WNDENUMPROC, LPARAM) +EnumChildWindowsParams = ((1, 'hWndParent'), (1, 'lpEnumFunc'), (1, 'lParam')) + +#def CloseWindow(hWnd): +# return CloseWindow.ctypes_function(hWnd) +CloseWindowPrototype = WINFUNCTYPE(BOOL, HWND) +CloseWindowParams = ((1, 'hWnd'),) + +#def GetDesktopWindow(): +# return GetDesktopWindow.ctypes_function() +GetDesktopWindowPrototype = WINFUNCTYPE(HWND) +GetDesktopWindowParams = () + +#def GetForegroundWindow(): +# return GetForegroundWindow.ctypes_function() +GetForegroundWindowPrototype = WINFUNCTYPE(HWND) +GetForegroundWindowParams = () + +#def BringWindowToTop(hWnd): +# return BringWindowToTop.ctypes_function(hWnd) +BringWindowToTopPrototype = WINFUNCTYPE(BOOL, HWND) +BringWindowToTopParams = ((1, 'hWnd'),) + +#def MoveWindow(hWnd, X, Y, nWidth, nHeight, bRepaint): +# return MoveWindow.ctypes_function(hWnd, X, Y, nWidth, nHeight, bRepaint) +MoveWindowPrototype = WINFUNCTYPE(BOOL, HWND, INT, INT, INT, INT, BOOL) +MoveWindowParams = ((1, 'hWnd'), (1, 'X'), (1, 'Y'), (1, 'nWidth'), (1, 'nHeight'), (1, 'bRepaint')) + +#def SetWindowPos(hWnd, hWndInsertAfter, X, Y, cx, cy, uFlags): +# return SetWindowPos.ctypes_function(hWnd, hWndInsertAfter, X, Y, cx, cy, uFlags) +SetWindowPosPrototype = WINFUNCTYPE(BOOL, HWND, HWND, INT, INT, INT, INT, UINT) +SetWindowPosParams = ((1, 'hWnd'), (1, 'hWndInsertAfter'), (1, 'X'), (1, 'Y'), (1, 'cx'), (1, 'cy'), (1, 'uFlags')) + +#def SetWindowTextA(hWnd, lpString): +# return SetWindowTextA.ctypes_function(hWnd, lpString) +SetWindowTextAPrototype = WINFUNCTYPE(BOOL, HWND, LPCSTR) +SetWindowTextAParams = ((1, 'hWnd'), (1, 'lpString')) + +#def SetWindowTextW(hWnd, lpString): +# return SetWindowTextW.ctypes_function(hWnd, lpString) +SetWindowTextWPrototype = WINFUNCTYPE(BOOL, HWND, LPWSTR) +SetWindowTextWParams = ((1, 'hWnd'), (1, 'lpString')) + +#def RealGetWindowClassA(hwnd, pszType, cchType): +# return RealGetWindowClassA.ctypes_function(hwnd, pszType, cchType) +RealGetWindowClassAPrototype = WINFUNCTYPE(UINT, HWND, LPCSTR, UINT) +RealGetWindowClassAParams = ((1, 'hwnd'), (1, 'pszType'), (1, 'cchType')) + +#def RealGetWindowClassW(hwnd, pszType, cchType): +# return RealGetWindowClassW.ctypes_function(hwnd, pszType, cchType) +RealGetWindowClassWPrototype = WINFUNCTYPE(UINT, HWND, LPWSTR, UINT) +RealGetWindowClassWParams = ((1, 'hwnd'), (1, 'pszType'), (1, 'cchType')) + +#def GetClassInfoExA(hinst, lpszClass, lpwcx): +# return GetClassInfoExA.ctypes_function(hinst, lpszClass, lpwcx) +GetClassInfoExAPrototype = WINFUNCTYPE(BOOL, HINSTANCE, LPCSTR, LPWNDCLASSEXA) +GetClassInfoExAParams = ((1, 'hinst'), (1, 'lpszClass'), (1, 'lpwcx')) + +#def GetClassInfoExW(hinst, lpszClass, lpwcx): +# return GetClassInfoExW.ctypes_function(hinst, lpszClass, lpwcx) +GetClassInfoExWPrototype = WINFUNCTYPE(BOOL, HINSTANCE, LPCWSTR, LPWNDCLASSEXW) +GetClassInfoExWParams = ((1, 'hinst'), (1, 'lpszClass'), (1, 'lpwcx')) + +#def GetClassNameA(hWnd, lpClassName, nMaxCount): +# return GetClassNameA.ctypes_function(hWnd, lpClassName, nMaxCount) +GetClassNameAPrototype = WINFUNCTYPE(INT, HWND, LPCSTR, INT) +GetClassNameAParams = ((1, 'hWnd'), (1, 'lpClassName'), (1, 'nMaxCount')) + +#def GetClassNameW(hWnd, lpClassName, nMaxCount): +# return GetClassNameW.ctypes_function(hWnd, lpClassName, nMaxCount) +GetClassNameWPrototype = WINFUNCTYPE(INT, HWND, LPWSTR, INT) +GetClassNameWParams = ((1, 'hWnd'), (1, 'lpClassName'), (1, 'nMaxCount')) + +#def GetWindowThreadProcessId(hWnd, lpdwProcessId): +# return GetWindowThreadProcessId.ctypes_function(hWnd, lpdwProcessId) +GetWindowThreadProcessIdPrototype = WINFUNCTYPE(DWORD, HWND, LPDWORD) +GetWindowThreadProcessIdParams = ((1, 'hWnd'), (1, 'lpdwProcessId')) + +#def FindWindowA(lpClassName, lpWindowName): +# return FindWindowA.ctypes_function(lpClassName, lpWindowName) +FindWindowAPrototype = WINFUNCTYPE(HWND, LPCSTR, LPCSTR) +FindWindowAParams = ((1, 'lpClassName'), (1, 'lpWindowName')) + +#def FindWindowW(lpClassName, lpWindowName): +# return FindWindowW.ctypes_function(lpClassName, lpWindowName) +FindWindowWPrototype = WINFUNCTYPE(HWND, LPCWSTR, LPCWSTR) +FindWindowWParams = ((1, 'lpClassName'), (1, 'lpWindowName')) + +#def GetExtendedTcpTable(pTcpTable, pdwSize, bOrder, ulAf, TableClass, Reserved): +# return GetExtendedTcpTable.ctypes_function(pTcpTable, pdwSize, bOrder, ulAf, TableClass, Reserved) +GetExtendedTcpTablePrototype = WINFUNCTYPE(DWORD, PVOID, PDWORD, BOOL, ULONG, TCP_TABLE_CLASS, ULONG) +GetExtendedTcpTableParams = ((1, 'pTcpTable'), (1, 'pdwSize'), (1, 'bOrder'), (1, 'ulAf'), (1, 'TableClass'), (1, 'Reserved')) + +#def GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, ulAf, TableClass, Reserved): +# return GetExtendedUdpTable.ctypes_function(pUdpTable, pdwSize, bOrder, ulAf, TableClass, Reserved) +GetExtendedUdpTablePrototype = WINFUNCTYPE(DWORD, PVOID, PDWORD, BOOL, ULONG, UDP_TABLE_CLASS, ULONG) +GetExtendedUdpTableParams = ((1, 'pUdpTable'), (1, 'pdwSize'), (1, 'bOrder'), (1, 'ulAf'), (1, 'TableClass'), (1, 'Reserved')) + +#def SetTcpEntry(pTcpRow): +# return SetTcpEntry.ctypes_function(pTcpRow) +SetTcpEntryPrototype = WINFUNCTYPE(DWORD, PMIB_TCPROW) +SetTcpEntryParams = ((1, 'pTcpRow'),) + +#def DnsGetCacheDataTable(DnsEntries): +# return DnsGetCacheDataTable.ctypes_function(DnsEntries) +DnsGetCacheDataTablePrototype = WINFUNCTYPE(DWORD, POINTER(PDNS_CACHE_ENTRY)) +DnsGetCacheDataTableParams = ((1, 'DnsEntries'),) + +#def DnsFree(pData, FreeType): +# return DnsFree.ctypes_function(pData, FreeType) +DnsFreePrototype = WINFUNCTYPE(VOID, PVOID, DNS_FREE_TYPE) +DnsFreeParams = ((1, 'pData'), (1, 'FreeType')) + +#def DnsQuery_A(pszName, wType, Options, pExtra, ppQueryResults, pReserved): +# return DnsQuery_A.ctypes_function(pszName, wType, Options, pExtra, ppQueryResults, pReserved) +DnsQuery_APrototype = WINFUNCTYPE(DNS_STATUS, PCSTR, WORD, DWORD, PVOID, POINTER(PDNS_RECORDA), POINTER(PVOID)) +DnsQuery_AParams = ((1, 'pszName'), (1, 'wType'), (1, 'Options'), (1, 'pExtra'), (1, 'ppQueryResults'), (1, 'pReserved')) + +#def DnsQuery_W(pszName, wType, Options, pExtra, ppQueryResults, pReserved): +# return DnsQuery_W.ctypes_function(pszName, wType, Options, pExtra, ppQueryResults, pReserved) +DnsQuery_WPrototype = WINFUNCTYPE(DNS_STATUS, PCWSTR, WORD, DWORD, PVOID, POINTER(PDNS_RECORDW), POINTER(PVOID)) +DnsQuery_WParams = ((1, 'pszName'), (1, 'wType'), (1, 'Options'), (1, 'pExtra'), (1, 'ppQueryResults'), (1, 'pReserved')) + +#def IsValidSecurityDescriptor(pSecurityDescriptor): +# return IsValidSecurityDescriptor.ctypes_function(pSecurityDescriptor) +IsValidSecurityDescriptorPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR) +IsValidSecurityDescriptorParams = ((1, 'pSecurityDescriptor'),) + +#def ConvertStringSecurityDescriptorToSecurityDescriptorA(StringSecurityDescriptor, StringSDRevision, SecurityDescriptor, SecurityDescriptorSize): +# return ConvertStringSecurityDescriptorToSecurityDescriptorA.ctypes_function(StringSecurityDescriptor, StringSDRevision, SecurityDescriptor, SecurityDescriptorSize) +ConvertStringSecurityDescriptorToSecurityDescriptorAPrototype = WINFUNCTYPE(BOOL, LPCSTR, DWORD, POINTER(PSECURITY_DESCRIPTOR), PULONG) +ConvertStringSecurityDescriptorToSecurityDescriptorAParams = ((1, 'StringSecurityDescriptor'), (1, 'StringSDRevision'), (1, 'SecurityDescriptor'), (1, 'SecurityDescriptorSize')) + +#def ConvertStringSecurityDescriptorToSecurityDescriptorW(StringSecurityDescriptor, StringSDRevision, SecurityDescriptor, SecurityDescriptorSize): +# return ConvertStringSecurityDescriptorToSecurityDescriptorW.ctypes_function(StringSecurityDescriptor, StringSDRevision, SecurityDescriptor, SecurityDescriptorSize) +ConvertStringSecurityDescriptorToSecurityDescriptorWPrototype = WINFUNCTYPE(BOOL, LPWSTR, DWORD, POINTER(PSECURITY_DESCRIPTOR), PULONG) +ConvertStringSecurityDescriptorToSecurityDescriptorWParams = ((1, 'StringSecurityDescriptor'), (1, 'StringSDRevision'), (1, 'SecurityDescriptor'), (1, 'SecurityDescriptorSize')) + +#def ConvertSecurityDescriptorToStringSecurityDescriptorA(SecurityDescriptor, RequestedStringSDRevision, SecurityInformation, StringSecurityDescriptor, StringSecurityDescriptorLen): +# return ConvertSecurityDescriptorToStringSecurityDescriptorA.ctypes_function(SecurityDescriptor, RequestedStringSDRevision, SecurityInformation, StringSecurityDescriptor, StringSecurityDescriptorLen) +ConvertSecurityDescriptorToStringSecurityDescriptorAPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, DWORD, DWORD, POINTER(LPCSTR), PULONG) +ConvertSecurityDescriptorToStringSecurityDescriptorAParams = ((1, 'SecurityDescriptor'), (1, 'RequestedStringSDRevision'), (1, 'SecurityInformation'), (1, 'StringSecurityDescriptor'), (1, 'StringSecurityDescriptorLen')) + +#def ConvertSecurityDescriptorToStringSecurityDescriptorW(SecurityDescriptor, RequestedStringSDRevision, SecurityInformation, StringSecurityDescriptor, StringSecurityDescriptorLen): +# return ConvertSecurityDescriptorToStringSecurityDescriptorW.ctypes_function(SecurityDescriptor, RequestedStringSDRevision, SecurityInformation, StringSecurityDescriptor, StringSecurityDescriptorLen) +ConvertSecurityDescriptorToStringSecurityDescriptorWPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, DWORD, DWORD, POINTER(LPWSTR), PULONG) +ConvertSecurityDescriptorToStringSecurityDescriptorWParams = ((1, 'SecurityDescriptor'), (1, 'RequestedStringSDRevision'), (1, 'SecurityInformation'), (1, 'StringSecurityDescriptor'), (1, 'StringSecurityDescriptorLen')) + +#def GetSecurityDescriptorControl(pSecurityDescriptor, pControl, lpdwRevision): +# return GetSecurityDescriptorControl.ctypes_function(pSecurityDescriptor, pControl, lpdwRevision) +GetSecurityDescriptorControlPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, LPDWORD) +GetSecurityDescriptorControlParams = ((1, 'pSecurityDescriptor'), (1, 'pControl'), (1, 'lpdwRevision')) + +#def GetSecurityDescriptorDacl(pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted): +# return GetSecurityDescriptorDacl.ctypes_function(pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted) +GetSecurityDescriptorDaclPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, LPBOOL, POINTER(PACL), LPBOOL) +GetSecurityDescriptorDaclParams = ((1, 'pSecurityDescriptor'), (1, 'lpbDaclPresent'), (1, 'pDacl'), (1, 'lpbDaclDefaulted')) + +#def GetSecurityDescriptorGroup(pSecurityDescriptor, pGroup, lpbGroupDefaulted): +# return GetSecurityDescriptorGroup.ctypes_function(pSecurityDescriptor, pGroup, lpbGroupDefaulted) +GetSecurityDescriptorGroupPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, POINTER(PSID), LPBOOL) +GetSecurityDescriptorGroupParams = ((1, 'pSecurityDescriptor'), (1, 'pGroup'), (1, 'lpbGroupDefaulted')) + +#def GetSecurityDescriptorLength(pSecurityDescriptor): +# return GetSecurityDescriptorLength.ctypes_function(pSecurityDescriptor) +GetSecurityDescriptorLengthPrototype = WINFUNCTYPE(DWORD, PSECURITY_DESCRIPTOR) +GetSecurityDescriptorLengthParams = ((1, 'pSecurityDescriptor'),) + +#def GetSecurityDescriptorOwner(pSecurityDescriptor, pOwner, lpbOwnerDefaulted): +# return GetSecurityDescriptorOwner.ctypes_function(pSecurityDescriptor, pOwner, lpbOwnerDefaulted) +GetSecurityDescriptorOwnerPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, POINTER(PSID), LPBOOL) +GetSecurityDescriptorOwnerParams = ((1, 'pSecurityDescriptor'), (1, 'pOwner'), (1, 'lpbOwnerDefaulted')) + +#def GetSecurityDescriptorRMControl(SecurityDescriptor, RMControl): +# return GetSecurityDescriptorRMControl.ctypes_function(SecurityDescriptor, RMControl) +GetSecurityDescriptorRMControlPrototype = WINFUNCTYPE(DWORD, PSECURITY_DESCRIPTOR, PUCHAR) +GetSecurityDescriptorRMControlParams = ((1, 'SecurityDescriptor'), (1, 'RMControl')) + +#def GetSecurityDescriptorSacl(pSecurityDescriptor, lpbSaclPresent, pSacl, lpbSaclDefaulted): +# return GetSecurityDescriptorSacl.ctypes_function(pSecurityDescriptor, lpbSaclPresent, pSacl, lpbSaclDefaulted) +GetSecurityDescriptorSaclPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, LPBOOL, POINTER(PACL), LPBOOL) +GetSecurityDescriptorSaclParams = ((1, 'pSecurityDescriptor'), (1, 'lpbSaclPresent'), (1, 'pSacl'), (1, 'lpbSaclDefaulted')) + +#def GetLengthSid(pSid): +# return GetLengthSid.ctypes_function(pSid) +GetLengthSidPrototype = WINFUNCTYPE(DWORD, PSID) +GetLengthSidParams = ((1, 'pSid'),) + +#def EqualSid(pSid1, pSid2): +# return EqualSid.ctypes_function(pSid1, pSid2) +EqualSidPrototype = WINFUNCTYPE(BOOL, PSID, PSID) +EqualSidParams = ((1, 'pSid1'), (1, 'pSid2')) + +#def CopySid(nDestinationSidLength, pDestinationSid, pSourceSid): +# return CopySid.ctypes_function(nDestinationSidLength, pDestinationSid, pSourceSid) +CopySidPrototype = WINFUNCTYPE(BOOL, DWORD, PSID, PSID) +CopySidParams = ((1, 'nDestinationSidLength'), (1, 'pDestinationSid'), (1, 'pSourceSid')) + +#def GetSidIdentifierAuthority(pSid): +# return GetSidIdentifierAuthority.ctypes_function(pSid) +GetSidIdentifierAuthorityPrototype = WINFUNCTYPE(PSID_IDENTIFIER_AUTHORITY, PSID) +GetSidIdentifierAuthorityParams = ((1, 'pSid'),) + +#def GetSidLengthRequired(nSubAuthorityCount): +# return GetSidLengthRequired.ctypes_function(nSubAuthorityCount) +GetSidLengthRequiredPrototype = WINFUNCTYPE(DWORD, UCHAR) +GetSidLengthRequiredParams = ((1, 'nSubAuthorityCount'),) + +#def GetSidSubAuthority(pSid, nSubAuthority): +# return GetSidSubAuthority.ctypes_function(pSid, nSubAuthority) +GetSidSubAuthorityPrototype = WINFUNCTYPE(PDWORD, PSID, DWORD) +GetSidSubAuthorityParams = ((1, 'pSid'), (1, 'nSubAuthority')) + +#def GetSidSubAuthorityCount(pSid): +# return GetSidSubAuthorityCount.ctypes_function(pSid) +GetSidSubAuthorityCountPrototype = WINFUNCTYPE(LPBYTE, PSID) +GetSidSubAuthorityCountParams = ((1, 'pSid'),) + +#def FreeSid(pSid): +# return FreeSid.ctypes_function(pSid) +FreeSidPrototype = WINFUNCTYPE(PVOID, PSID) +FreeSidParams = ((1, 'pSid'),) + +#def GetAce(pAcl, dwAceIndex, pAce): +# return GetAce.ctypes_function(pAcl, dwAceIndex, pAce) +GetAcePrototype = WINFUNCTYPE(BOOL, PACL, DWORD, POINTER(LPVOID)) +GetAceParams = ((1, 'pAcl'), (1, 'dwAceIndex'), (1, 'pAce')) + +#def GetAclInformation(pAcl, pAclInformation, nAclInformationLength, dwAclInformationClass): +# return GetAclInformation.ctypes_function(pAcl, pAclInformation, nAclInformationLength, dwAclInformationClass) +GetAclInformationPrototype = WINFUNCTYPE(BOOL, PACL, LPVOID, DWORD, ACL_INFORMATION_CLASS) +GetAclInformationParams = ((1, 'pAcl'), (1, 'pAclInformation'), (1, 'nAclInformationLength'), (1, 'dwAclInformationClass')) + +#def MapGenericMask(AccessMask, GenericMapping): +# return MapGenericMask.ctypes_function(AccessMask, GenericMapping) +MapGenericMaskPrototype = WINFUNCTYPE(PVOID, PDWORD, PGENERIC_MAPPING) +MapGenericMaskParams = ((1, 'AccessMask'), (1, 'GenericMapping')) + +#def AccessCheck(pSecurityDescriptor, ClientToken, DesiredAccess, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus): +# return AccessCheck.ctypes_function(pSecurityDescriptor, ClientToken, DesiredAccess, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus) +AccessCheckPrototype = WINFUNCTYPE(BOOL, PSECURITY_DESCRIPTOR, HANDLE, DWORD, PGENERIC_MAPPING, PPRIVILEGE_SET, LPDWORD, LPDWORD, LPBOOL) +AccessCheckParams = ((1, 'pSecurityDescriptor'), (1, 'ClientToken'), (1, 'DesiredAccess'), (1, 'GenericMapping'), (1, 'PrivilegeSet'), (1, 'PrivilegeSetLength'), (1, 'GrantedAccess'), (1, 'AccessStatus')) #def CryptCATAdminCalcHashFromFileHandle(hFile, pcbHash, pbHash, dwFlags): # return CryptCATAdminCalcHashFromFileHandle.ctypes_function(hFile, pcbHash, pbHash, dwFlags) @@ -2350,3 +2520,53 @@ CryptMsgControlParams = ((1, 'hCryptMsg'), (1, 'dwFlags'), (1, 'dwCtrlType'), (1 CryptMsgClosePrototype = WINFUNCTYPE(BOOL, HCRYPTMSG) CryptMsgCloseParams = ((1, 'hCryptMsg'),) +#def FileTimeToSystemTime(lpFileTime, lpSystemTime): +# return FileTimeToSystemTime.ctypes_function(lpFileTime, lpSystemTime) +FileTimeToSystemTimePrototype = WINFUNCTYPE(BOOL, POINTER(FILETIME), LPSYSTEMTIME) +FileTimeToSystemTimeParams = ((1, 'lpFileTime'), (1, 'lpSystemTime')) + +#def SystemTimeToFileTime(lpSystemTime, lpFileTime): +# return SystemTimeToFileTime.ctypes_function(lpSystemTime, lpFileTime) +SystemTimeToFileTimePrototype = WINFUNCTYPE(BOOL, POINTER(SYSTEMTIME), LPFILETIME) +SystemTimeToFileTimeParams = ((1, 'lpSystemTime'), (1, 'lpFileTime')) + +#def GetSystemTime(lpSystemTime): +# return GetSystemTime.ctypes_function(lpSystemTime) +GetSystemTimePrototype = WINFUNCTYPE(PVOID, LPSYSTEMTIME) +GetSystemTimeParams = ((1, 'lpSystemTime'),) + +#def GetSystemTimeAsFileTime(lpSystemTimeAsFileTime): +# return GetSystemTimeAsFileTime.ctypes_function(lpSystemTimeAsFileTime) +GetSystemTimeAsFileTimePrototype = WINFUNCTYPE(PVOID, LPFILETIME) +GetSystemTimeAsFileTimeParams = ((1, 'lpSystemTimeAsFileTime'),) + +#def CreateFileTransactedA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile, hTransaction, pusMiniVersion, pExtendedParameter): +# return CreateFileTransactedA.ctypes_function(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile, hTransaction, pusMiniVersion, pExtendedParameter) +CreateFileTransactedAPrototype = WINFUNCTYPE(HANDLE, LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE, HANDLE, PUSHORT, PVOID) +CreateFileTransactedAParams = ((1, 'lpFileName'), (1, 'dwDesiredAccess'), (1, 'dwShareMode'), (1, 'lpSecurityAttributes'), (1, 'dwCreationDisposition'), (1, 'dwFlagsAndAttributes'), (1, 'hTemplateFile'), (1, 'hTransaction'), (1, 'pusMiniVersion'), (1, 'pExtendedParameter')) + +#def CreateFileTransactedW(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile, hTransaction, pusMiniVersion, pExtendedParameter): +# return CreateFileTransactedW.ctypes_function(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile, hTransaction, pusMiniVersion, pExtendedParameter) +CreateFileTransactedWPrototype = WINFUNCTYPE(HANDLE, LPWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE, HANDLE, PUSHORT, PVOID) +CreateFileTransactedWParams = ((1, 'lpFileName'), (1, 'dwDesiredAccess'), (1, 'dwShareMode'), (1, 'lpSecurityAttributes'), (1, 'dwCreationDisposition'), (1, 'dwFlagsAndAttributes'), (1, 'hTemplateFile'), (1, 'hTransaction'), (1, 'pusMiniVersion'), (1, 'pExtendedParameter')) + +#def CommitTransaction(TransactionHandle): +# return CommitTransaction.ctypes_function(TransactionHandle) +CommitTransactionPrototype = WINFUNCTYPE(BOOL, HANDLE) +CommitTransactionParams = ((1, 'TransactionHandle'),) + +#def CreateTransaction(lpTransactionAttributes, UOW, CreateOptions, IsolationLevel, IsolationFlags, Timeout, Description): +# return CreateTransaction.ctypes_function(lpTransactionAttributes, UOW, CreateOptions, IsolationLevel, IsolationFlags, Timeout, Description) +CreateTransactionPrototype = WINFUNCTYPE(HANDLE, LPSECURITY_ATTRIBUTES, LPGUID, DWORD, DWORD, DWORD, DWORD, LPWSTR) +CreateTransactionParams = ((1, 'lpTransactionAttributes'), (1, 'UOW'), (1, 'CreateOptions'), (1, 'IsolationLevel'), (1, 'IsolationFlags'), (1, 'Timeout'), (1, 'Description')) + +#def RollbackTransaction(TransactionHandle): +# return RollbackTransaction.ctypes_function(TransactionHandle) +RollbackTransactionPrototype = WINFUNCTYPE(BOOL, HANDLE) +RollbackTransactionParams = ((1, 'TransactionHandle'),) + +#def OpenTransaction(dwDesiredAccess, TransactionId): +# return OpenTransaction.ctypes_function(dwDesiredAccess, TransactionId) +OpenTransactionPrototype = WINFUNCTYPE(HANDLE, DWORD, LPGUID) +OpenTransactionParams = ((1, 'dwDesiredAccess'), (1, 'TransactionId')) + diff --git a/windows/generated_def/winstructs.py b/windows/generated_def/winstructs.py index 8a7242d..e79e5c6 100644 --- a/windows/generated_def/winstructs.py +++ b/windows/generated_def/winstructs.py @@ -36,6 +36,10 @@ class EnumType(DWORD): value = self.value return "<{0} {1}({2})>".format(type(self).__name__, value.name, hex(raw_value)) return "<{0}({1})>".format(type(self).__name__, hex(self.value)) + +# Sale: windef is hardcoded +import windef +SZOID_MAPPER = FlagMapper(*(getattr(windef, x) for x in dir(windef) if x.startswith("szOID"))) FC_ZERO = EnumValue("NDR_FORMAT_CHARACTER", "FC_ZERO", 0x0) FC_BYTE = EnumValue("NDR_FORMAT_CHARACTER", "FC_BYTE", 0x1) FC_CHAR = EnumValue("NDR_FORMAT_CHARACTER", "FC_CHAR", 0x2) @@ -150,399 +154,113 @@ class NDR_FORMAT_CHARACTER(EnumType): mapper = FlagMapper(*values) -WBEM_GENUS_CLASS = EnumValue("tag_WBEM_GENUS_TYPE", "WBEM_GENUS_CLASS", 0x1) -WBEM_GENUS_INSTANCE = EnumValue("tag_WBEM_GENUS_TYPE", "WBEM_GENUS_INSTANCE", 0x2) -class tag_WBEM_GENUS_TYPE(EnumType): - values = [WBEM_GENUS_CLASS, WBEM_GENUS_INSTANCE] +TASK_ACTION_EXEC = EnumValue("_TASK_ACTION_TYPE", "TASK_ACTION_EXEC", 0x0) +TASK_ACTION_COM_HANDLER = EnumValue("_TASK_ACTION_TYPE", "TASK_ACTION_COM_HANDLER", 0x5) +TASK_ACTION_SEND_EMAIL = EnumValue("_TASK_ACTION_TYPE", "TASK_ACTION_SEND_EMAIL", 0x6) +TASK_ACTION_SHOW_MESSAGE = EnumValue("_TASK_ACTION_TYPE", "TASK_ACTION_SHOW_MESSAGE", 0x7) +class _TASK_ACTION_TYPE(EnumType): + values = [TASK_ACTION_EXEC, TASK_ACTION_COM_HANDLER, TASK_ACTION_SEND_EMAIL, TASK_ACTION_SHOW_MESSAGE] mapper = FlagMapper(*values) -WBEM_GENUS_TYPE = tag_WBEM_GENUS_TYPE +TASK_ACTION_TYPE = _TASK_ACTION_TYPE -WBEM_FLAG_CREATE_OR_UPDATE = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_CREATE_OR_UPDATE", 0x0) -WBEM_FLAG_UPDATE_ONLY = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_UPDATE_ONLY", 0x1) -WBEM_FLAG_CREATE_ONLY = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_CREATE_ONLY", 0x2) -WBEM_FLAG_UPDATE_COMPATIBLE = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_UPDATE_COMPATIBLE", 0x0) -WBEM_FLAG_UPDATE_SAFE_MODE = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_UPDATE_SAFE_MODE", 0x20) -WBEM_FLAG_UPDATE_FORCE_MODE = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_UPDATE_FORCE_MODE", 0x40) -WBEM_MASK_UPDATE_MODE = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_MASK_UPDATE_MODE", 0x60) -WBEM_FLAG_ADVISORY = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_ADVISORY", 0x10000) -class tag_WBEM_CHANGE_FLAG_TYPE(EnumType): - values = [WBEM_FLAG_CREATE_OR_UPDATE, WBEM_FLAG_UPDATE_ONLY, WBEM_FLAG_CREATE_ONLY, WBEM_FLAG_UPDATE_COMPATIBLE, WBEM_FLAG_UPDATE_SAFE_MODE, WBEM_FLAG_UPDATE_FORCE_MODE, WBEM_MASK_UPDATE_MODE, WBEM_FLAG_ADVISORY] +TASK_RUNLEVEL_LUA = EnumValue("_TASK_RUNLEVEL_TYPE", "TASK_RUNLEVEL_LUA", 0x0) +TASK_RUNLEVEL_HIGHEST = EnumValue("_TASK_RUNLEVEL_TYPE", "TASK_RUNLEVEL_HIGHEST", 0x1) +class _TASK_RUNLEVEL_TYPE(EnumType): + values = [TASK_RUNLEVEL_LUA, TASK_RUNLEVEL_HIGHEST] mapper = FlagMapper(*values) -WBEM_CHANGE_FLAG_TYPE = tag_WBEM_CHANGE_FLAG_TYPE +TASK_RUNLEVEL_TYPE = _TASK_RUNLEVEL_TYPE -WBEM_NO_ERROR = EnumValue("tag_WBEMSTATUS", "WBEM_NO_ERROR", 0x0) -WBEM_S_NO_ERROR = EnumValue("tag_WBEMSTATUS", "WBEM_S_NO_ERROR", 0x0) -WBEM_S_SAME = EnumValue("tag_WBEMSTATUS", "WBEM_S_SAME", 0x0) -WBEM_S_FALSE = EnumValue("tag_WBEMSTATUS", "WBEM_S_FALSE", 0x1) -WBEM_S_ALREADY_EXISTS = EnumValue("tag_WBEMSTATUS", "WBEM_S_ALREADY_EXISTS", 0x40001) -WBEM_S_RESET_TO_DEFAULT = EnumValue("tag_WBEMSTATUS", "WBEM_S_RESET_TO_DEFAULT", 0x40002) -WBEM_S_DIFFERENT = EnumValue("tag_WBEMSTATUS", "WBEM_S_DIFFERENT", 0x40003) -WBEM_S_TIMEDOUT = EnumValue("tag_WBEMSTATUS", "WBEM_S_TIMEDOUT", 0x40004) -WBEM_S_NO_MORE_DATA = EnumValue("tag_WBEMSTATUS", "WBEM_S_NO_MORE_DATA", 0x40005) -WBEM_S_OPERATION_CANCELLED = EnumValue("tag_WBEMSTATUS", "WBEM_S_OPERATION_CANCELLED", 0x40006) -WBEM_S_PENDING = EnumValue("tag_WBEMSTATUS", "WBEM_S_PENDING", 0x40007) -WBEM_S_DUPLICATE_OBJECTS = EnumValue("tag_WBEMSTATUS", "WBEM_S_DUPLICATE_OBJECTS", 0x40008) -WBEM_S_ACCESS_DENIED = EnumValue("tag_WBEMSTATUS", "WBEM_S_ACCESS_DENIED", 0x40009) -WBEM_S_PARTIAL_RESULTS = EnumValue("tag_WBEMSTATUS", "WBEM_S_PARTIAL_RESULTS", 0x40010) -WBEM_S_SOURCE_NOT_AVAILABLE = EnumValue("tag_WBEMSTATUS", "WBEM_S_SOURCE_NOT_AVAILABLE", 0x40017) -WBEM_E_FAILED = EnumValue("tag_WBEMSTATUS", "WBEM_E_FAILED", 0x80041001) -WBEM_E_NOT_FOUND = EnumValue("tag_WBEMSTATUS", "WBEM_E_NOT_FOUND", 0x80041002) -WBEM_E_ACCESS_DENIED = EnumValue("tag_WBEMSTATUS", "WBEM_E_ACCESS_DENIED", 0x80041003) -WBEM_E_PROVIDER_FAILURE = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_FAILURE", 0x80041004) -WBEM_E_TYPE_MISMATCH = EnumValue("tag_WBEMSTATUS", "WBEM_E_TYPE_MISMATCH", 0x80041005) -WBEM_E_OUT_OF_MEMORY = EnumValue("tag_WBEMSTATUS", "WBEM_E_OUT_OF_MEMORY", 0x80041006) -WBEM_E_INVALID_CONTEXT = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_CONTEXT", 0x80041007) -WBEM_E_INVALID_PARAMETER = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_PARAMETER", 0x80041008) -WBEM_E_NOT_AVAILABLE = EnumValue("tag_WBEMSTATUS", "WBEM_E_NOT_AVAILABLE", 0x80041009) -WBEM_E_CRITICAL_ERROR = EnumValue("tag_WBEMSTATUS", "WBEM_E_CRITICAL_ERROR", 0x8004100a) -WBEM_E_INVALID_STREAM = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_STREAM", 0x8004100b) -WBEM_E_NOT_SUPPORTED = EnumValue("tag_WBEMSTATUS", "WBEM_E_NOT_SUPPORTED", 0x8004100c) -WBEM_E_INVALID_SUPERCLASS = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_SUPERCLASS", 0x8004100d) -WBEM_E_INVALID_NAMESPACE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_NAMESPACE", 0x8004100e) -WBEM_E_INVALID_OBJECT = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_OBJECT", 0x8004100f) -WBEM_E_INVALID_CLASS = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_CLASS", 0x80041010) -WBEM_E_PROVIDER_NOT_FOUND = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_NOT_FOUND", 0x80041011) -WBEM_E_INVALID_PROVIDER_REGISTRATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_PROVIDER_REGISTRATION", 0x80041012) -WBEM_E_PROVIDER_LOAD_FAILURE = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_LOAD_FAILURE", 0x80041013) -WBEM_E_INITIALIZATION_FAILURE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INITIALIZATION_FAILURE", 0x80041014) -WBEM_E_TRANSPORT_FAILURE = EnumValue("tag_WBEMSTATUS", "WBEM_E_TRANSPORT_FAILURE", 0x80041015) -WBEM_E_INVALID_OPERATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_OPERATION", 0x80041016) -WBEM_E_INVALID_QUERY = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_QUERY", 0x80041017) -WBEM_E_INVALID_QUERY_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_QUERY_TYPE", 0x80041018) -WBEM_E_ALREADY_EXISTS = EnumValue("tag_WBEMSTATUS", "WBEM_E_ALREADY_EXISTS", 0x80041019) -WBEM_E_OVERRIDE_NOT_ALLOWED = EnumValue("tag_WBEMSTATUS", "WBEM_E_OVERRIDE_NOT_ALLOWED", 0x8004101a) -WBEM_E_PROPAGATED_QUALIFIER = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROPAGATED_QUALIFIER", 0x8004101b) -WBEM_E_PROPAGATED_PROPERTY = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROPAGATED_PROPERTY", 0x8004101c) -WBEM_E_UNEXPECTED = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNEXPECTED", 0x8004101d) -WBEM_E_ILLEGAL_OPERATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_ILLEGAL_OPERATION", 0x8004101e) -WBEM_E_CANNOT_BE_KEY = EnumValue("tag_WBEMSTATUS", "WBEM_E_CANNOT_BE_KEY", 0x8004101f) -WBEM_E_INCOMPLETE_CLASS = EnumValue("tag_WBEMSTATUS", "WBEM_E_INCOMPLETE_CLASS", 0x80041020) -WBEM_E_INVALID_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_SYNTAX", 0x80041021) -WBEM_E_NONDECORATED_OBJECT = EnumValue("tag_WBEMSTATUS", "WBEM_E_NONDECORATED_OBJECT", 0x80041022) -WBEM_E_READ_ONLY = EnumValue("tag_WBEMSTATUS", "WBEM_E_READ_ONLY", 0x80041023) -WBEM_E_PROVIDER_NOT_CAPABLE = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_NOT_CAPABLE", 0x80041024) -WBEM_E_CLASS_HAS_CHILDREN = EnumValue("tag_WBEMSTATUS", "WBEM_E_CLASS_HAS_CHILDREN", 0x80041025) -WBEM_E_CLASS_HAS_INSTANCES = EnumValue("tag_WBEMSTATUS", "WBEM_E_CLASS_HAS_INSTANCES", 0x80041026) -WBEM_E_QUERY_NOT_IMPLEMENTED = EnumValue("tag_WBEMSTATUS", "WBEM_E_QUERY_NOT_IMPLEMENTED", 0x80041027) -WBEM_E_ILLEGAL_NULL = EnumValue("tag_WBEMSTATUS", "WBEM_E_ILLEGAL_NULL", 0x80041028) -WBEM_E_INVALID_QUALIFIER_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_QUALIFIER_TYPE", 0x80041029) -WBEM_E_INVALID_PROPERTY_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_PROPERTY_TYPE", 0x8004102a) -WBEM_E_VALUE_OUT_OF_RANGE = EnumValue("tag_WBEMSTATUS", "WBEM_E_VALUE_OUT_OF_RANGE", 0x8004102b) -WBEM_E_CANNOT_BE_SINGLETON = EnumValue("tag_WBEMSTATUS", "WBEM_E_CANNOT_BE_SINGLETON", 0x8004102c) -WBEM_E_INVALID_CIM_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_CIM_TYPE", 0x8004102d) -WBEM_E_INVALID_METHOD = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_METHOD", 0x8004102e) -WBEM_E_INVALID_METHOD_PARAMETERS = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_METHOD_PARAMETERS", 0x8004102f) -WBEM_E_SYSTEM_PROPERTY = EnumValue("tag_WBEMSTATUS", "WBEM_E_SYSTEM_PROPERTY", 0x80041030) -WBEM_E_INVALID_PROPERTY = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_PROPERTY", 0x80041031) -WBEM_E_CALL_CANCELLED = EnumValue("tag_WBEMSTATUS", "WBEM_E_CALL_CANCELLED", 0x80041032) -WBEM_E_SHUTTING_DOWN = EnumValue("tag_WBEMSTATUS", "WBEM_E_SHUTTING_DOWN", 0x80041033) -WBEM_E_PROPAGATED_METHOD = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROPAGATED_METHOD", 0x80041034) -WBEM_E_UNSUPPORTED_PARAMETER = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNSUPPORTED_PARAMETER", 0x80041035) -WBEM_E_MISSING_PARAMETER_ID = EnumValue("tag_WBEMSTATUS", "WBEM_E_MISSING_PARAMETER_ID", 0x80041036) -WBEM_E_INVALID_PARAMETER_ID = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_PARAMETER_ID", 0x80041037) -WBEM_E_NONCONSECUTIVE_PARAMETER_IDS = EnumValue("tag_WBEMSTATUS", "WBEM_E_NONCONSECUTIVE_PARAMETER_IDS", 0x80041038) -WBEM_E_PARAMETER_ID_ON_RETVAL = EnumValue("tag_WBEMSTATUS", "WBEM_E_PARAMETER_ID_ON_RETVAL", 0x80041039) -WBEM_E_INVALID_OBJECT_PATH = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_OBJECT_PATH", 0x8004103a) -WBEM_E_OUT_OF_DISK_SPACE = EnumValue("tag_WBEMSTATUS", "WBEM_E_OUT_OF_DISK_SPACE", 0x8004103b) -WBEM_E_BUFFER_TOO_SMALL = EnumValue("tag_WBEMSTATUS", "WBEM_E_BUFFER_TOO_SMALL", 0x8004103c) -WBEM_E_UNSUPPORTED_PUT_EXTENSION = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNSUPPORTED_PUT_EXTENSION", 0x8004103d) -WBEM_E_UNKNOWN_OBJECT_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNKNOWN_OBJECT_TYPE", 0x8004103e) -WBEM_E_UNKNOWN_PACKET_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNKNOWN_PACKET_TYPE", 0x8004103f) -WBEM_E_MARSHAL_VERSION_MISMATCH = EnumValue("tag_WBEMSTATUS", "WBEM_E_MARSHAL_VERSION_MISMATCH", 0x80041040) -WBEM_E_MARSHAL_INVALID_SIGNATURE = EnumValue("tag_WBEMSTATUS", "WBEM_E_MARSHAL_INVALID_SIGNATURE", 0x80041041) -WBEM_E_INVALID_QUALIFIER = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_QUALIFIER", 0x80041042) -WBEM_E_INVALID_DUPLICATE_PARAMETER = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_DUPLICATE_PARAMETER", 0x80041043) -WBEM_E_TOO_MUCH_DATA = EnumValue("tag_WBEMSTATUS", "WBEM_E_TOO_MUCH_DATA", 0x80041044) -WBEM_E_SERVER_TOO_BUSY = EnumValue("tag_WBEMSTATUS", "WBEM_E_SERVER_TOO_BUSY", 0x80041045) -WBEM_E_INVALID_FLAVOR = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_FLAVOR", 0x80041046) -WBEM_E_CIRCULAR_REFERENCE = EnumValue("tag_WBEMSTATUS", "WBEM_E_CIRCULAR_REFERENCE", 0x80041047) -WBEM_E_UNSUPPORTED_CLASS_UPDATE = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNSUPPORTED_CLASS_UPDATE", 0x80041048) -WBEM_E_CANNOT_CHANGE_KEY_INHERITANCE = EnumValue("tag_WBEMSTATUS", "WBEM_E_CANNOT_CHANGE_KEY_INHERITANCE", 0x80041049) -WBEM_E_CANNOT_CHANGE_INDEX_INHERITANCE = EnumValue("tag_WBEMSTATUS", "WBEM_E_CANNOT_CHANGE_INDEX_INHERITANCE", 0x80041050) -WBEM_E_TOO_MANY_PROPERTIES = EnumValue("tag_WBEMSTATUS", "WBEM_E_TOO_MANY_PROPERTIES", 0x80041051) -WBEM_E_UPDATE_TYPE_MISMATCH = EnumValue("tag_WBEMSTATUS", "WBEM_E_UPDATE_TYPE_MISMATCH", 0x80041052) -WBEM_E_UPDATE_OVERRIDE_NOT_ALLOWED = EnumValue("tag_WBEMSTATUS", "WBEM_E_UPDATE_OVERRIDE_NOT_ALLOWED", 0x80041053) -WBEM_E_UPDATE_PROPAGATED_METHOD = EnumValue("tag_WBEMSTATUS", "WBEM_E_UPDATE_PROPAGATED_METHOD", 0x80041054) -WBEM_E_METHOD_NOT_IMPLEMENTED = EnumValue("tag_WBEMSTATUS", "WBEM_E_METHOD_NOT_IMPLEMENTED", 0x80041055) -WBEM_E_METHOD_DISABLED = EnumValue("tag_WBEMSTATUS", "WBEM_E_METHOD_DISABLED", 0x80041056) -WBEM_E_REFRESHER_BUSY = EnumValue("tag_WBEMSTATUS", "WBEM_E_REFRESHER_BUSY", 0x80041057) -WBEM_E_UNPARSABLE_QUERY = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNPARSABLE_QUERY", 0x80041058) -WBEM_E_NOT_EVENT_CLASS = EnumValue("tag_WBEMSTATUS", "WBEM_E_NOT_EVENT_CLASS", 0x80041059) -WBEM_E_MISSING_GROUP_WITHIN = EnumValue("tag_WBEMSTATUS", "WBEM_E_MISSING_GROUP_WITHIN", 0x8004105a) -WBEM_E_MISSING_AGGREGATION_LIST = EnumValue("tag_WBEMSTATUS", "WBEM_E_MISSING_AGGREGATION_LIST", 0x8004105b) -WBEM_E_PROPERTY_NOT_AN_OBJECT = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROPERTY_NOT_AN_OBJECT", 0x8004105c) -WBEM_E_AGGREGATING_BY_OBJECT = EnumValue("tag_WBEMSTATUS", "WBEM_E_AGGREGATING_BY_OBJECT", 0x8004105d) -WBEM_E_UNINTERPRETABLE_PROVIDER_QUERY = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNINTERPRETABLE_PROVIDER_QUERY", 0x8004105f) -WBEM_E_BACKUP_RESTORE_WINMGMT_RUNNING = EnumValue("tag_WBEMSTATUS", "WBEM_E_BACKUP_RESTORE_WINMGMT_RUNNING", 0x80041060) -WBEM_E_QUEUE_OVERFLOW = EnumValue("tag_WBEMSTATUS", "WBEM_E_QUEUE_OVERFLOW", 0x80041061) -WBEM_E_PRIVILEGE_NOT_HELD = EnumValue("tag_WBEMSTATUS", "WBEM_E_PRIVILEGE_NOT_HELD", 0x80041062) -WBEM_E_INVALID_OPERATOR = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_OPERATOR", 0x80041063) -WBEM_E_LOCAL_CREDENTIALS = EnumValue("tag_WBEMSTATUS", "WBEM_E_LOCAL_CREDENTIALS", 0x80041064) -WBEM_E_CANNOT_BE_ABSTRACT = EnumValue("tag_WBEMSTATUS", "WBEM_E_CANNOT_BE_ABSTRACT", 0x80041065) -WBEM_E_AMENDED_OBJECT = EnumValue("tag_WBEMSTATUS", "WBEM_E_AMENDED_OBJECT", 0x80041066) -WBEM_E_CLIENT_TOO_SLOW = EnumValue("tag_WBEMSTATUS", "WBEM_E_CLIENT_TOO_SLOW", 0x80041067) -WBEM_E_NULL_SECURITY_DESCRIPTOR = EnumValue("tag_WBEMSTATUS", "WBEM_E_NULL_SECURITY_DESCRIPTOR", 0x80041068) -WBEM_E_TIMED_OUT = EnumValue("tag_WBEMSTATUS", "WBEM_E_TIMED_OUT", 0x80041069) -WBEM_E_INVALID_ASSOCIATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_ASSOCIATION", 0x8004106a) -WBEM_E_AMBIGUOUS_OPERATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_AMBIGUOUS_OPERATION", 0x8004106b) -WBEM_E_QUOTA_VIOLATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_QUOTA_VIOLATION", 0x8004106c) -WBEM_E_RESERVED_001 = EnumValue("tag_WBEMSTATUS", "WBEM_E_RESERVED_001", 0x8004106d) -WBEM_E_RESERVED_002 = EnumValue("tag_WBEMSTATUS", "WBEM_E_RESERVED_002", 0x8004106e) -WBEM_E_UNSUPPORTED_LOCALE = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNSUPPORTED_LOCALE", 0x8004106f) -WBEM_E_HANDLE_OUT_OF_DATE = EnumValue("tag_WBEMSTATUS", "WBEM_E_HANDLE_OUT_OF_DATE", 0x80041070) -WBEM_E_CONNECTION_FAILED = EnumValue("tag_WBEMSTATUS", "WBEM_E_CONNECTION_FAILED", 0x80041071) -WBEM_E_INVALID_HANDLE_REQUEST = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_HANDLE_REQUEST", 0x80041072) -WBEM_E_PROPERTY_NAME_TOO_WIDE = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROPERTY_NAME_TOO_WIDE", 0x80041073) -WBEM_E_CLASS_NAME_TOO_WIDE = EnumValue("tag_WBEMSTATUS", "WBEM_E_CLASS_NAME_TOO_WIDE", 0x80041074) -WBEM_E_METHOD_NAME_TOO_WIDE = EnumValue("tag_WBEMSTATUS", "WBEM_E_METHOD_NAME_TOO_WIDE", 0x80041075) -WBEM_E_QUALIFIER_NAME_TOO_WIDE = EnumValue("tag_WBEMSTATUS", "WBEM_E_QUALIFIER_NAME_TOO_WIDE", 0x80041076) -WBEM_E_RERUN_COMMAND = EnumValue("tag_WBEMSTATUS", "WBEM_E_RERUN_COMMAND", 0x80041077) -WBEM_E_DATABASE_VER_MISMATCH = EnumValue("tag_WBEMSTATUS", "WBEM_E_DATABASE_VER_MISMATCH", 0x80041078) -WBEM_E_VETO_DELETE = EnumValue("tag_WBEMSTATUS", "WBEM_E_VETO_DELETE", 0x80041079) -WBEM_E_VETO_PUT = EnumValue("tag_WBEMSTATUS", "WBEM_E_VETO_PUT", 0x8004107a) -WBEM_E_INVALID_LOCALE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_LOCALE", 0x80041080) -WBEM_E_PROVIDER_SUSPENDED = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_SUSPENDED", 0x80041081) -WBEM_E_SYNCHRONIZATION_REQUIRED = EnumValue("tag_WBEMSTATUS", "WBEM_E_SYNCHRONIZATION_REQUIRED", 0x80041082) -WBEM_E_NO_SCHEMA = EnumValue("tag_WBEMSTATUS", "WBEM_E_NO_SCHEMA", 0x80041083) -WBEM_E_PROVIDER_ALREADY_REGISTERED = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_ALREADY_REGISTERED", 0x80041084) -WBEM_E_PROVIDER_NOT_REGISTERED = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_NOT_REGISTERED", 0x80041085) -WBEM_E_FATAL_TRANSPORT_ERROR = EnumValue("tag_WBEMSTATUS", "WBEM_E_FATAL_TRANSPORT_ERROR", 0x80041086) -WBEM_E_ENCRYPTED_CONNECTION_REQUIRED = EnumValue("tag_WBEMSTATUS", "WBEM_E_ENCRYPTED_CONNECTION_REQUIRED", 0x80041087) -WBEM_E_PROVIDER_TIMED_OUT = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_TIMED_OUT", 0x80041088) -WBEM_E_NO_KEY = EnumValue("tag_WBEMSTATUS", "WBEM_E_NO_KEY", 0x80041089) -WBEM_E_PROVIDER_DISABLED = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_DISABLED", 0x8004108a) -WBEMESS_E_REGISTRATION_TOO_BROAD = EnumValue("tag_WBEMSTATUS", "WBEMESS_E_REGISTRATION_TOO_BROAD", 0x80042001) -WBEMESS_E_REGISTRATION_TOO_PRECISE = EnumValue("tag_WBEMSTATUS", "WBEMESS_E_REGISTRATION_TOO_PRECISE", 0x80042002) -WBEMESS_E_AUTHZ_NOT_PRIVILEGED = EnumValue("tag_WBEMSTATUS", "WBEMESS_E_AUTHZ_NOT_PRIVILEGED", 0x80042003) -WBEMMOF_E_EXPECTED_QUALIFIER_NAME = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_QUALIFIER_NAME", 0x80044001) -WBEMMOF_E_EXPECTED_SEMI = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_SEMI", 0x80044002) -WBEMMOF_E_EXPECTED_OPEN_BRACE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_OPEN_BRACE", 0x80044003) -WBEMMOF_E_EXPECTED_CLOSE_BRACE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_CLOSE_BRACE", 0x80044004) -WBEMMOF_E_EXPECTED_CLOSE_BRACKET = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_CLOSE_BRACKET", 0x80044005) -WBEMMOF_E_EXPECTED_CLOSE_PAREN = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_CLOSE_PAREN", 0x80044006) -WBEMMOF_E_ILLEGAL_CONSTANT_VALUE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_ILLEGAL_CONSTANT_VALUE", 0x80044007) -WBEMMOF_E_EXPECTED_TYPE_IDENTIFIER = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_TYPE_IDENTIFIER", 0x80044008) -WBEMMOF_E_EXPECTED_OPEN_PAREN = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_OPEN_PAREN", 0x80044009) -WBEMMOF_E_UNRECOGNIZED_TOKEN = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNRECOGNIZED_TOKEN", 0x8004400a) -WBEMMOF_E_UNRECOGNIZED_TYPE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNRECOGNIZED_TYPE", 0x8004400b) -WBEMMOF_E_EXPECTED_PROPERTY_NAME = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_PROPERTY_NAME", 0x8004400c) -WBEMMOF_E_TYPEDEF_NOT_SUPPORTED = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_TYPEDEF_NOT_SUPPORTED", 0x8004400d) -WBEMMOF_E_UNEXPECTED_ALIAS = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNEXPECTED_ALIAS", 0x8004400e) -WBEMMOF_E_UNEXPECTED_ARRAY_INIT = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNEXPECTED_ARRAY_INIT", 0x8004400f) -WBEMMOF_E_INVALID_AMENDMENT_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_AMENDMENT_SYNTAX", 0x80044010) -WBEMMOF_E_INVALID_DUPLICATE_AMENDMENT = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_DUPLICATE_AMENDMENT", 0x80044011) -WBEMMOF_E_INVALID_PRAGMA = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_PRAGMA", 0x80044012) -WBEMMOF_E_INVALID_NAMESPACE_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_NAMESPACE_SYNTAX", 0x80044013) -WBEMMOF_E_EXPECTED_CLASS_NAME = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_CLASS_NAME", 0x80044014) -WBEMMOF_E_TYPE_MISMATCH = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_TYPE_MISMATCH", 0x80044015) -WBEMMOF_E_EXPECTED_ALIAS_NAME = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_ALIAS_NAME", 0x80044016) -WBEMMOF_E_INVALID_CLASS_DECLARATION = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_CLASS_DECLARATION", 0x80044017) -WBEMMOF_E_INVALID_INSTANCE_DECLARATION = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_INSTANCE_DECLARATION", 0x80044018) -WBEMMOF_E_EXPECTED_DOLLAR = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_DOLLAR", 0x80044019) -WBEMMOF_E_CIMTYPE_QUALIFIER = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_CIMTYPE_QUALIFIER", 0x8004401a) -WBEMMOF_E_DUPLICATE_PROPERTY = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_DUPLICATE_PROPERTY", 0x8004401b) -WBEMMOF_E_INVALID_NAMESPACE_SPECIFICATION = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_NAMESPACE_SPECIFICATION", 0x8004401c) -WBEMMOF_E_OUT_OF_RANGE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_OUT_OF_RANGE", 0x8004401d) -WBEMMOF_E_INVALID_FILE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_FILE", 0x8004401e) -WBEMMOF_E_ALIASES_IN_EMBEDDED = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_ALIASES_IN_EMBEDDED", 0x8004401f) -WBEMMOF_E_NULL_ARRAY_ELEM = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_NULL_ARRAY_ELEM", 0x80044020) -WBEMMOF_E_DUPLICATE_QUALIFIER = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_DUPLICATE_QUALIFIER", 0x80044021) -WBEMMOF_E_EXPECTED_FLAVOR_TYPE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_FLAVOR_TYPE", 0x80044022) -WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES", 0x80044023) -WBEMMOF_E_MULTIPLE_ALIASES = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_MULTIPLE_ALIASES", 0x80044024) -WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES2 = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES2", 0x80044025) -WBEMMOF_E_NO_ARRAYS_RETURNED = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_NO_ARRAYS_RETURNED", 0x80044026) -WBEMMOF_E_MUST_BE_IN_OR_OUT = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_MUST_BE_IN_OR_OUT", 0x80044027) -WBEMMOF_E_INVALID_FLAGS_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_FLAGS_SYNTAX", 0x80044028) -WBEMMOF_E_EXPECTED_BRACE_OR_BAD_TYPE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_BRACE_OR_BAD_TYPE", 0x80044029) -WBEMMOF_E_UNSUPPORTED_CIMV22_QUAL_VALUE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNSUPPORTED_CIMV22_QUAL_VALUE", 0x8004402a) -WBEMMOF_E_UNSUPPORTED_CIMV22_DATA_TYPE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNSUPPORTED_CIMV22_DATA_TYPE", 0x8004402b) -WBEMMOF_E_INVALID_DELETEINSTANCE_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_DELETEINSTANCE_SYNTAX", 0x8004402c) -WBEMMOF_E_INVALID_QUALIFIER_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_QUALIFIER_SYNTAX", 0x8004402d) -WBEMMOF_E_QUALIFIER_USED_OUTSIDE_SCOPE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_QUALIFIER_USED_OUTSIDE_SCOPE", 0x8004402e) -WBEMMOF_E_ERROR_CREATING_TEMP_FILE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_ERROR_CREATING_TEMP_FILE", 0x8004402f) -WBEMMOF_E_ERROR_INVALID_INCLUDE_FILE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_ERROR_INVALID_INCLUDE_FILE", 0x80044030) -WBEMMOF_E_INVALID_DELETECLASS_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_DELETECLASS_SYNTAX", 0x80044031) -class tag_WBEMSTATUS(EnumType): - values = [WBEM_NO_ERROR, WBEM_S_NO_ERROR, WBEM_S_SAME, WBEM_S_FALSE, WBEM_S_ALREADY_EXISTS, WBEM_S_RESET_TO_DEFAULT, WBEM_S_DIFFERENT, WBEM_S_TIMEDOUT, WBEM_S_NO_MORE_DATA, WBEM_S_OPERATION_CANCELLED, WBEM_S_PENDING, WBEM_S_DUPLICATE_OBJECTS, WBEM_S_ACCESS_DENIED, WBEM_S_PARTIAL_RESULTS, WBEM_S_SOURCE_NOT_AVAILABLE, WBEM_E_FAILED, WBEM_E_NOT_FOUND, WBEM_E_ACCESS_DENIED, WBEM_E_PROVIDER_FAILURE, WBEM_E_TYPE_MISMATCH, WBEM_E_OUT_OF_MEMORY, WBEM_E_INVALID_CONTEXT, WBEM_E_INVALID_PARAMETER, WBEM_E_NOT_AVAILABLE, WBEM_E_CRITICAL_ERROR, WBEM_E_INVALID_STREAM, WBEM_E_NOT_SUPPORTED, WBEM_E_INVALID_SUPERCLASS, WBEM_E_INVALID_NAMESPACE, WBEM_E_INVALID_OBJECT, WBEM_E_INVALID_CLASS, WBEM_E_PROVIDER_NOT_FOUND, WBEM_E_INVALID_PROVIDER_REGISTRATION, WBEM_E_PROVIDER_LOAD_FAILURE, WBEM_E_INITIALIZATION_FAILURE, WBEM_E_TRANSPORT_FAILURE, WBEM_E_INVALID_OPERATION, WBEM_E_INVALID_QUERY, WBEM_E_INVALID_QUERY_TYPE, WBEM_E_ALREADY_EXISTS, WBEM_E_OVERRIDE_NOT_ALLOWED, WBEM_E_PROPAGATED_QUALIFIER, WBEM_E_PROPAGATED_PROPERTY, WBEM_E_UNEXPECTED, WBEM_E_ILLEGAL_OPERATION, WBEM_E_CANNOT_BE_KEY, WBEM_E_INCOMPLETE_CLASS, WBEM_E_INVALID_SYNTAX, WBEM_E_NONDECORATED_OBJECT, WBEM_E_READ_ONLY, WBEM_E_PROVIDER_NOT_CAPABLE, WBEM_E_CLASS_HAS_CHILDREN, WBEM_E_CLASS_HAS_INSTANCES, WBEM_E_QUERY_NOT_IMPLEMENTED, WBEM_E_ILLEGAL_NULL, WBEM_E_INVALID_QUALIFIER_TYPE, WBEM_E_INVALID_PROPERTY_TYPE, WBEM_E_VALUE_OUT_OF_RANGE, WBEM_E_CANNOT_BE_SINGLETON, WBEM_E_INVALID_CIM_TYPE, WBEM_E_INVALID_METHOD, WBEM_E_INVALID_METHOD_PARAMETERS, WBEM_E_SYSTEM_PROPERTY, WBEM_E_INVALID_PROPERTY, WBEM_E_CALL_CANCELLED, WBEM_E_SHUTTING_DOWN, WBEM_E_PROPAGATED_METHOD, WBEM_E_UNSUPPORTED_PARAMETER, WBEM_E_MISSING_PARAMETER_ID, WBEM_E_INVALID_PARAMETER_ID, WBEM_E_NONCONSECUTIVE_PARAMETER_IDS, WBEM_E_PARAMETER_ID_ON_RETVAL, WBEM_E_INVALID_OBJECT_PATH, WBEM_E_OUT_OF_DISK_SPACE, WBEM_E_BUFFER_TOO_SMALL, WBEM_E_UNSUPPORTED_PUT_EXTENSION, WBEM_E_UNKNOWN_OBJECT_TYPE, WBEM_E_UNKNOWN_PACKET_TYPE, WBEM_E_MARSHAL_VERSION_MISMATCH, WBEM_E_MARSHAL_INVALID_SIGNATURE, WBEM_E_INVALID_QUALIFIER, WBEM_E_INVALID_DUPLICATE_PARAMETER, WBEM_E_TOO_MUCH_DATA, WBEM_E_SERVER_TOO_BUSY, WBEM_E_INVALID_FLAVOR, WBEM_E_CIRCULAR_REFERENCE, WBEM_E_UNSUPPORTED_CLASS_UPDATE, WBEM_E_CANNOT_CHANGE_KEY_INHERITANCE, WBEM_E_CANNOT_CHANGE_INDEX_INHERITANCE, WBEM_E_TOO_MANY_PROPERTIES, WBEM_E_UPDATE_TYPE_MISMATCH, WBEM_E_UPDATE_OVERRIDE_NOT_ALLOWED, WBEM_E_UPDATE_PROPAGATED_METHOD, WBEM_E_METHOD_NOT_IMPLEMENTED, WBEM_E_METHOD_DISABLED, WBEM_E_REFRESHER_BUSY, WBEM_E_UNPARSABLE_QUERY, WBEM_E_NOT_EVENT_CLASS, WBEM_E_MISSING_GROUP_WITHIN, WBEM_E_MISSING_AGGREGATION_LIST, WBEM_E_PROPERTY_NOT_AN_OBJECT, WBEM_E_AGGREGATING_BY_OBJECT, WBEM_E_UNINTERPRETABLE_PROVIDER_QUERY, WBEM_E_BACKUP_RESTORE_WINMGMT_RUNNING, WBEM_E_QUEUE_OVERFLOW, WBEM_E_PRIVILEGE_NOT_HELD, WBEM_E_INVALID_OPERATOR, WBEM_E_LOCAL_CREDENTIALS, WBEM_E_CANNOT_BE_ABSTRACT, WBEM_E_AMENDED_OBJECT, WBEM_E_CLIENT_TOO_SLOW, WBEM_E_NULL_SECURITY_DESCRIPTOR, WBEM_E_TIMED_OUT, WBEM_E_INVALID_ASSOCIATION, WBEM_E_AMBIGUOUS_OPERATION, WBEM_E_QUOTA_VIOLATION, WBEM_E_RESERVED_001, WBEM_E_RESERVED_002, WBEM_E_UNSUPPORTED_LOCALE, WBEM_E_HANDLE_OUT_OF_DATE, WBEM_E_CONNECTION_FAILED, WBEM_E_INVALID_HANDLE_REQUEST, WBEM_E_PROPERTY_NAME_TOO_WIDE, WBEM_E_CLASS_NAME_TOO_WIDE, WBEM_E_METHOD_NAME_TOO_WIDE, WBEM_E_QUALIFIER_NAME_TOO_WIDE, WBEM_E_RERUN_COMMAND, WBEM_E_DATABASE_VER_MISMATCH, WBEM_E_VETO_DELETE, WBEM_E_VETO_PUT, WBEM_E_INVALID_LOCALE, WBEM_E_PROVIDER_SUSPENDED, WBEM_E_SYNCHRONIZATION_REQUIRED, WBEM_E_NO_SCHEMA, WBEM_E_PROVIDER_ALREADY_REGISTERED, WBEM_E_PROVIDER_NOT_REGISTERED, WBEM_E_FATAL_TRANSPORT_ERROR, WBEM_E_ENCRYPTED_CONNECTION_REQUIRED, WBEM_E_PROVIDER_TIMED_OUT, WBEM_E_NO_KEY, WBEM_E_PROVIDER_DISABLED, WBEMESS_E_REGISTRATION_TOO_BROAD, WBEMESS_E_REGISTRATION_TOO_PRECISE, WBEMESS_E_AUTHZ_NOT_PRIVILEGED, WBEMMOF_E_EXPECTED_QUALIFIER_NAME, WBEMMOF_E_EXPECTED_SEMI, WBEMMOF_E_EXPECTED_OPEN_BRACE, WBEMMOF_E_EXPECTED_CLOSE_BRACE, WBEMMOF_E_EXPECTED_CLOSE_BRACKET, WBEMMOF_E_EXPECTED_CLOSE_PAREN, WBEMMOF_E_ILLEGAL_CONSTANT_VALUE, WBEMMOF_E_EXPECTED_TYPE_IDENTIFIER, WBEMMOF_E_EXPECTED_OPEN_PAREN, WBEMMOF_E_UNRECOGNIZED_TOKEN, WBEMMOF_E_UNRECOGNIZED_TYPE, WBEMMOF_E_EXPECTED_PROPERTY_NAME, WBEMMOF_E_TYPEDEF_NOT_SUPPORTED, WBEMMOF_E_UNEXPECTED_ALIAS, WBEMMOF_E_UNEXPECTED_ARRAY_INIT, WBEMMOF_E_INVALID_AMENDMENT_SYNTAX, WBEMMOF_E_INVALID_DUPLICATE_AMENDMENT, WBEMMOF_E_INVALID_PRAGMA, WBEMMOF_E_INVALID_NAMESPACE_SYNTAX, WBEMMOF_E_EXPECTED_CLASS_NAME, WBEMMOF_E_TYPE_MISMATCH, WBEMMOF_E_EXPECTED_ALIAS_NAME, WBEMMOF_E_INVALID_CLASS_DECLARATION, WBEMMOF_E_INVALID_INSTANCE_DECLARATION, WBEMMOF_E_EXPECTED_DOLLAR, WBEMMOF_E_CIMTYPE_QUALIFIER, WBEMMOF_E_DUPLICATE_PROPERTY, WBEMMOF_E_INVALID_NAMESPACE_SPECIFICATION, WBEMMOF_E_OUT_OF_RANGE, WBEMMOF_E_INVALID_FILE, WBEMMOF_E_ALIASES_IN_EMBEDDED, WBEMMOF_E_NULL_ARRAY_ELEM, WBEMMOF_E_DUPLICATE_QUALIFIER, WBEMMOF_E_EXPECTED_FLAVOR_TYPE, WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES, WBEMMOF_E_MULTIPLE_ALIASES, WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES2, WBEMMOF_E_NO_ARRAYS_RETURNED, WBEMMOF_E_MUST_BE_IN_OR_OUT, WBEMMOF_E_INVALID_FLAGS_SYNTAX, WBEMMOF_E_EXPECTED_BRACE_OR_BAD_TYPE, WBEMMOF_E_UNSUPPORTED_CIMV22_QUAL_VALUE, WBEMMOF_E_UNSUPPORTED_CIMV22_DATA_TYPE, WBEMMOF_E_INVALID_DELETEINSTANCE_SYNTAX, WBEMMOF_E_INVALID_QUALIFIER_SYNTAX, WBEMMOF_E_QUALIFIER_USED_OUTSIDE_SCOPE, WBEMMOF_E_ERROR_CREATING_TEMP_FILE, WBEMMOF_E_ERROR_INVALID_INCLUDE_FILE, WBEMMOF_E_INVALID_DELETECLASS_SYNTAX] +TASK_LOGON_NONE = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_NONE", 0x0) +TASK_LOGON_PASSWORD = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_PASSWORD", 0x1) +TASK_LOGON_S4U = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_S4U", 0x2) +TASK_LOGON_INTERACTIVE_TOKEN = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_INTERACTIVE_TOKEN", 0x3) +TASK_LOGON_GROUP = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_GROUP", 0x4) +TASK_LOGON_SERVICE_ACCOUNT = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_SERVICE_ACCOUNT", 0x5) +TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD", 0x6) +class _TASK_LOGON_TYPE(EnumType): + values = [TASK_LOGON_NONE, TASK_LOGON_PASSWORD, TASK_LOGON_S4U, TASK_LOGON_INTERACTIVE_TOKEN, TASK_LOGON_GROUP, TASK_LOGON_SERVICE_ACCOUNT, TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD] mapper = FlagMapper(*values) -WBEMSTATUS = tag_WBEMSTATUS +TASK_LOGON_TYPE = _TASK_LOGON_TYPE -WBEM_NO_WAIT = EnumValue("tag_WBEM_TIMEOUT_TYPE", "WBEM_NO_WAIT", 0x0) -WBEM_INFINITE = EnumValue("tag_WBEM_TIMEOUT_TYPE", "WBEM_INFINITE", 0xffffffff) -class tag_WBEM_TIMEOUT_TYPE(EnumType): - values = [WBEM_NO_WAIT, WBEM_INFINITE] +TASK_STATE_UNKNOWN = EnumValue("_TASK_STATE", "TASK_STATE_UNKNOWN", 0x0) +TASK_STATE_DISABLED = EnumValue("_TASK_STATE", "TASK_STATE_DISABLED", 0x1) +TASK_STATE_QUEUED = EnumValue("_TASK_STATE", "TASK_STATE_QUEUED", 0x2) +TASK_STATE_READY = EnumValue("_TASK_STATE", "TASK_STATE_READY", 0x3) +TASK_STATE_RUNNING = EnumValue("_TASK_STATE", "TASK_STATE_RUNNING", 0x4) +class _TASK_STATE(EnumType): + values = [TASK_STATE_UNKNOWN, TASK_STATE_DISABLED, TASK_STATE_QUEUED, TASK_STATE_READY, TASK_STATE_RUNNING] mapper = FlagMapper(*values) -WBEM_TIMEOUT_TYPE = tag_WBEM_TIMEOUT_TYPE +TASK_STATE = _TASK_STATE -WBEM_FLAG_RETURN_IMMEDIATELY = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_RETURN_IMMEDIATELY", 0x10) -WBEM_FLAG_RETURN_WBEM_COMPLETE = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_RETURN_WBEM_COMPLETE", 0x0) -WBEM_FLAG_BIDIRECTIONAL = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_BIDIRECTIONAL", 0x0) -WBEM_FLAG_FORWARD_ONLY = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_FORWARD_ONLY", 0x20) -WBEM_FLAG_NO_ERROR_OBJECT = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_NO_ERROR_OBJECT", 0x40) -WBEM_FLAG_RETURN_ERROR_OBJECT = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_RETURN_ERROR_OBJECT", 0x0) -WBEM_FLAG_SEND_STATUS = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_SEND_STATUS", 0x80) -WBEM_FLAG_DONT_SEND_STATUS = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_DONT_SEND_STATUS", 0x0) -WBEM_FLAG_ENSURE_LOCATABLE = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_ENSURE_LOCATABLE", 0x100) -WBEM_FLAG_DIRECT_READ = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_DIRECT_READ", 0x200) -WBEM_FLAG_SEND_ONLY_SELECTED = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_SEND_ONLY_SELECTED", 0x0) -WBEM_RETURN_WHEN_COMPLETE = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_RETURN_WHEN_COMPLETE", 0x0) -WBEM_RETURN_IMMEDIATELY = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_RETURN_IMMEDIATELY", 0x10) -WBEM_MASK_RESERVED_FLAGS = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_MASK_RESERVED_FLAGS", 0x1f000) -WBEM_FLAG_USE_AMENDED_QUALIFIERS = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_USE_AMENDED_QUALIFIERS", 0x20000) -WBEM_FLAG_STRONG_VALIDATION = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_STRONG_VALIDATION", 0x100000) -class tag_WBEM_GENERIC_FLAG_TYPE(EnumType): - values = [WBEM_FLAG_RETURN_IMMEDIATELY, WBEM_FLAG_RETURN_WBEM_COMPLETE, WBEM_FLAG_BIDIRECTIONAL, WBEM_FLAG_FORWARD_ONLY, WBEM_FLAG_NO_ERROR_OBJECT, WBEM_FLAG_RETURN_ERROR_OBJECT, WBEM_FLAG_SEND_STATUS, WBEM_FLAG_DONT_SEND_STATUS, WBEM_FLAG_ENSURE_LOCATABLE, WBEM_FLAG_DIRECT_READ, WBEM_FLAG_SEND_ONLY_SELECTED, WBEM_RETURN_WHEN_COMPLETE, WBEM_RETURN_IMMEDIATELY, WBEM_MASK_RESERVED_FLAGS, WBEM_FLAG_USE_AMENDED_QUALIFIERS, WBEM_FLAG_STRONG_VALIDATION] +TASK_INSTANCES_PARALLEL = EnumValue("_TASK_INSTANCES_POLICY", "TASK_INSTANCES_PARALLEL", 0x0) +TASK_INSTANCES_QUEUE = EnumValue("_TASK_INSTANCES_POLICY", "TASK_INSTANCES_QUEUE", 0x1) +TASK_INSTANCES_IGNORE_NEW = EnumValue("_TASK_INSTANCES_POLICY", "TASK_INSTANCES_IGNORE_NEW", 0x2) +TASK_INSTANCES_STOP_EXISTING = EnumValue("_TASK_INSTANCES_POLICY", "TASK_INSTANCES_STOP_EXISTING", 0x3) +class _TASK_INSTANCES_POLICY(EnumType): + values = [TASK_INSTANCES_PARALLEL, TASK_INSTANCES_QUEUE, TASK_INSTANCES_IGNORE_NEW, TASK_INSTANCES_STOP_EXISTING] mapper = FlagMapper(*values) -WBEM_GENERIC_FLAG_TYPE = tag_WBEM_GENERIC_FLAG_TYPE +TASK_INSTANCES_POLICY = _TASK_INSTANCES_POLICY -WBEM_FLAG_CONNECT_REPOSITORY_ONLY = EnumValue("tag_WBEM_CONNECT_OPTIONS", "WBEM_FLAG_CONNECT_REPOSITORY_ONLY", 0x40) -WBEM_FLAG_CONNECT_USE_MAX_WAIT = EnumValue("tag_WBEM_CONNECT_OPTIONS", "WBEM_FLAG_CONNECT_USE_MAX_WAIT", 0x80) -WBEM_FLAG_CONNECT_PROVIDERS = EnumValue("tag_WBEM_CONNECT_OPTIONS", "WBEM_FLAG_CONNECT_PROVIDERS", 0x100) -class tag_WBEM_CONNECT_OPTIONS(EnumType): - values = [WBEM_FLAG_CONNECT_REPOSITORY_ONLY, WBEM_FLAG_CONNECT_USE_MAX_WAIT, WBEM_FLAG_CONNECT_PROVIDERS] +TASK_COMPATIBILITY_AT = EnumValue("_TASK_COMPATIBILITY", "TASK_COMPATIBILITY_AT", 0x0) +TASK_COMPATIBILITY_V1 = EnumValue("_TASK_COMPATIBILITY", "TASK_COMPATIBILITY_V1", 0x1) +TASK_COMPATIBILITY_V2 = EnumValue("_TASK_COMPATIBILITY", "TASK_COMPATIBILITY_V2", 0x2) +class _TASK_COMPATIBILITY(EnumType): + values = [TASK_COMPATIBILITY_AT, TASK_COMPATIBILITY_V1, TASK_COMPATIBILITY_V2] mapper = FlagMapper(*values) -WBEM_CONNECT_OPTIONS = tag_WBEM_CONNECT_OPTIONS +TASK_COMPATIBILITY = _TASK_COMPATIBILITY -WBEM_FLAG_DEEP = EnumValue("tag_WBEM_QUERY_FLAG_TYPE", "WBEM_FLAG_DEEP", 0x0) -WBEM_FLAG_SHALLOW = EnumValue("tag_WBEM_QUERY_FLAG_TYPE", "WBEM_FLAG_SHALLOW", 0x1) -WBEM_FLAG_PROTOTYPE = EnumValue("tag_WBEM_QUERY_FLAG_TYPE", "WBEM_FLAG_PROTOTYPE", 0x2) -class tag_WBEM_QUERY_FLAG_TYPE(EnumType): - values = [WBEM_FLAG_DEEP, WBEM_FLAG_SHALLOW, WBEM_FLAG_PROTOTYPE] +TASK_TRIGGER_EVENT = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_EVENT", 0x0) +TASK_TRIGGER_TIME = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_TIME", 0x1) +TASK_TRIGGER_DAILY = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_DAILY", 0x2) +TASK_TRIGGER_WEEKLY = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_WEEKLY", 0x3) +TASK_TRIGGER_MONTHLY = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_MONTHLY", 0x4) +TASK_TRIGGER_MONTHLYDOW = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_MONTHLYDOW", 0x5) +TASK_TRIGGER_IDLE = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_IDLE", 0x6) +TASK_TRIGGER_REGISTRATION = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_REGISTRATION", 0x7) +TASK_TRIGGER_BOOT = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_BOOT", 0x8) +TASK_TRIGGER_LOGON = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_LOGON", 0x9) +TASK_TRIGGER_SESSION_STATE_CHANGE = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_SESSION_STATE_CHANGE", 0xb) +class _TASK_TRIGGER_TYPE2(EnumType): + values = [TASK_TRIGGER_EVENT, TASK_TRIGGER_TIME, TASK_TRIGGER_DAILY, TASK_TRIGGER_WEEKLY, TASK_TRIGGER_MONTHLY, TASK_TRIGGER_MONTHLYDOW, TASK_TRIGGER_IDLE, TASK_TRIGGER_REGISTRATION, TASK_TRIGGER_BOOT, TASK_TRIGGER_LOGON, TASK_TRIGGER_SESSION_STATE_CHANGE] mapper = FlagMapper(*values) -WBEM_QUERY_FLAG_TYPE = tag_WBEM_QUERY_FLAG_TYPE +TASK_TRIGGER_TYPE2 = _TASK_TRIGGER_TYPE2 -class _API_SET_VALUE_ENTRY(Structure): - _fields_ = [ - ("Flags", ULONG), - ("NameOffset", ULONG), - ("NameLength", ULONG), - ("ValueOffset", ULONG), - ("ValueLength", ULONG), - ] -API_SET_VALUE_ENTRY = _API_SET_VALUE_ENTRY -PAPI_SET_VALUE_ENTRY = POINTER(_API_SET_VALUE_ENTRY) +TASK_ENUM_HIDDEN = EnumValue("_TASK_ENUM_FLAGS", "TASK_ENUM_HIDDEN", 0x1) +class _TASK_ENUM_FLAGS(EnumType): + values = [TASK_ENUM_HIDDEN] + mapper = FlagMapper(*values) +TASK_ENUM_FLAGS = _TASK_ENUM_FLAGS -class _API_SET_NAMESPACE_ENTRY(Structure): - _fields_ = [ - ("Flags", ULONG), - ("NameOffset", ULONG), - ("NameLength", ULONG), - ("AliasOffset", ULONG), - ("AliasLength", ULONG), - ("DataOffset", ULONG), - ] -PAPI_SET_NAMESPACE_ENTRY = POINTER(_API_SET_NAMESPACE_ENTRY) -API_SET_NAMESPACE_ENTRY = _API_SET_NAMESPACE_ENTRY -class _API_SET_NAMESPACE_ARRAY(Structure): - _fields_ = [ - ("Version", ULONG), - ("Size", ULONG), - ("Flags", ULONG), - ("Count", ULONG), - ("Array", API_SET_NAMESPACE_ENTRY * ANYSIZE_ARRAY), - ] -PAPI_SET_NAMESPACE_ARRAY = POINTER(_API_SET_NAMESPACE_ARRAY) -API_SET_NAMESPACE_ARRAY = _API_SET_NAMESPACE_ARRAY +TASK_VALIDATE_ONLY = EnumValue("_TASK_CREATION", "TASK_VALIDATE_ONLY", 0x1) +TASK_CREATE = EnumValue("_TASK_CREATION", "TASK_CREATE", 0x2) +TASK_UPDATE = EnumValue("_TASK_CREATION", "TASK_UPDATE", 0x4) +TASK_CREATE_OR_UPDATE = EnumValue("_TASK_CREATION", "TASK_CREATE_OR_UPDATE", 0x6) +TASK_DISABLE = EnumValue("_TASK_CREATION", "TASK_DISABLE", 0x8) +TASK_DONT_ADD_PRINCIPAL_ACE = EnumValue("_TASK_CREATION", "TASK_DONT_ADD_PRINCIPAL_ACE", 0x10) +TASK_IGNORE_REGISTRATION_TRIGGERS = EnumValue("_TASK_CREATION", "TASK_IGNORE_REGISTRATION_TRIGGERS", 0x20) +class _TASK_CREATION(EnumType): + values = [TASK_VALIDATE_ONLY, TASK_CREATE, TASK_UPDATE, TASK_CREATE_OR_UPDATE, TASK_DISABLE, TASK_DONT_ADD_PRINCIPAL_ACE, TASK_IGNORE_REGISTRATION_TRIGGERS] + mapper = FlagMapper(*values) +TASK_CREATION = _TASK_CREATION -class _API_SET_VALUE_ENTRY_V2(Structure): - _fields_ = [ - ("NameOffset", ULONG), - ("NameLength", ULONG), - ("ValueOffset", ULONG), - ("ValueLength", ULONG), - ] -PAPI_SET_VALUE_ENTRY_V2 = POINTER(_API_SET_VALUE_ENTRY_V2) -API_SET_VALUE_ENTRY_V2 = _API_SET_VALUE_ENTRY_V2 -class _API_SET_VALUE_ARRAY_V2(Structure): - _fields_ = [ - ("Count", ULONG), - ("Array", API_SET_VALUE_ENTRY_V2 * ANYSIZE_ARRAY), - ] -API_SET_VALUE_ARRAY_V2 = _API_SET_VALUE_ARRAY_V2 -PAPI_SET_VALUE_ARRAY_V2 = POINTER(_API_SET_VALUE_ARRAY_V2) +TASK_RUN_NO_FLAGS = EnumValue("TASK_RUN_FLAGS", "TASK_RUN_NO_FLAGS", 0x0) +TASK_RUN_AS_SELF = EnumValue("TASK_RUN_FLAGS", "TASK_RUN_AS_SELF", 0x1) +TASK_RUN_IGNORE_CONSTRAINTS = EnumValue("TASK_RUN_FLAGS", "TASK_RUN_IGNORE_CONSTRAINTS", 0x2) +TASK_RUN_USE_SESSION_ID = EnumValue("TASK_RUN_FLAGS", "TASK_RUN_USE_SESSION_ID", 0x4) +TASK_RUN_USER_SID = EnumValue("TASK_RUN_FLAGS", "TASK_RUN_USER_SID", 0x8) +class TASK_RUN_FLAGS(EnumType): + values = [TASK_RUN_NO_FLAGS, TASK_RUN_AS_SELF, TASK_RUN_IGNORE_CONSTRAINTS, TASK_RUN_USE_SESSION_ID, TASK_RUN_USER_SID] + mapper = FlagMapper(*values) -class _API_SET_NAMESPACE_ENTRY_V2(Structure): - _fields_ = [ - ("NameOffset", ULONG), - ("NameLength", ULONG), - ("DataOffset", ULONG), - ] -PAPI_SET_NAMESPACE_ENTRY_V2 = POINTER(_API_SET_NAMESPACE_ENTRY_V2) -API_SET_NAMESPACE_ENTRY_V2 = _API_SET_NAMESPACE_ENTRY_V2 - -class _API_SET_NAMESPACE_ARRAY_V2(Structure): - _fields_ = [ - ("Version", ULONG), - ("Count", ULONG), - ("Array", API_SET_NAMESPACE_ENTRY_V2 * ANYSIZE_ARRAY), - ] -API_SET_NAMESPACE_ARRAY_V2 = _API_SET_NAMESPACE_ARRAY_V2 -PAPI_SET_NAMESPACE_ARRAY_V2 = POINTER(_API_SET_NAMESPACE_ARRAY_V2) - -class _API_SET_VALUE_ARRAY_V4(Structure): - _fields_ = [ - ("GuessFlags", ULONG), - ("Count", ULONG), - ("Array", API_SET_VALUE_ENTRY_V2 * ANYSIZE_ARRAY), - ] -API_SET_VALUE_ARRAY_V4 = _API_SET_VALUE_ARRAY_V4 -PAPI_SET_VALUE_ARRAY_V2 = POINTER(_API_SET_VALUE_ARRAY_V4) - -class _API_SET_NAMESPACE_ARRAY_V4(Structure): - _fields_ = [ - ("Version", ULONG), - ("Size", ULONG), - ("Flags", ULONG), - ("Count", ULONG), - ("Array", API_SET_NAMESPACE_ENTRY * ANYSIZE_ARRAY), - ] -API_SET_NAMESPACE_ARRAY_V4 = _API_SET_NAMESPACE_ARRAY_V4 -PAPI_SET_NAMESPACE_ARRAY_V4 = POINTER(_API_SET_NAMESPACE_ARRAY_V4) - -class _API_SET_NAMESPACE_ENTRY_V4(Structure): - _fields_ = [ - ("Flags", ULONG), - ("NameOffset", ULONG), - ("NameLength", ULONG), - ("AliasOffset", ULONG), - ("AliasLength", ULONG), - ("DataOffset", ULONG), - ] -PAPI_SET_NAMESPACE_ENTRY_V4 = POINTER(_API_SET_NAMESPACE_ENTRY_V4) -API_SET_NAMESPACE_ENTRY_V4 = _API_SET_NAMESPACE_ENTRY_V4 - -class _API_SET_NAMESPACE_ENTRY_V6(Structure): - _fields_ = [ - ("Flags", ULONG), - ("NameOffset", ULONG), - ("NameLength", ULONG), - ("HashedLength", ULONG), - ("ValueOffset", ULONG), - ("ValueCount", ULONG), - ] -API_SET_NAMESPACE_ENTRY_V6 = _API_SET_NAMESPACE_ENTRY_V6 - -class _API_SET_NAMESPACE_V6(Structure): - _fields_ = [ - ("Version", ULONG), - ("Size", ULONG), - ("Flags", ULONG), - ("Count", ULONG), - ("EntryOffset", ULONG), - ("HashOffset", ULONG), - ("HashFactor", ULONG), - ] -API_SET_NAMESPACE_V6 = _API_SET_NAMESPACE_V6 VOID = DWORD BYTE = c_ubyte @@ -552,6 +270,8 @@ SIZE_T = c_size_t PSIZE_T = POINTER(SIZE_T) PVOID = c_void_p NTSTATUS = DWORD +TDHSTATUS = ULONG +DNS_STATUS = ULONG SECURITY_INFORMATION = DWORD PSECURITY_INFORMATION = POINTER(SECURITY_INFORMATION) PULONG = POINTER(ULONG) @@ -611,7 +331,6 @@ DISPID = LONG MEMBERID = DISPID LRESULT = LONG_PTR LPUNKNOWN = POINTER(PVOID) -LPFILETIME = POINTER(FILETIME) LPPOINT = POINTER(POINT) LPRECT = POINTER(RECT) SPC_UUID = BYTE*16 @@ -623,6 +342,8 @@ NCRYPT_PROV_HANDLE = ULONG_PTR NCRYPT_KEY_HANDLE = ULONG_PTR NCRYPT_HASH_HANDLE = ULONG_PTR NCRYPT_SECRET_HANDLE = ULONG_PTR +TRACEHANDLE = ULONG64 +PTRACEHANDLE = POINTER(TRACEHANDLE) INT8 = c_byte INT16 = SHORT INT32 = INT @@ -643,6 +364,7 @@ HBRUSH = HANDLE HCRYPTPROV_OR_NCRYPT_KEY_HANDLE = PULONG EVT_HANDLE = HANDLE EVT_OBJECT_ARRAY_PROPERTY_HANDLE = HANDLE +IP4_ADDRESS = DWORD PSECURITY_DESCRIPTOR = PVOID SECURITY_DESCRIPTOR_CONTROL = WORD PSECURITY_DESCRIPTOR_CONTROL = POINTER(SECURITY_DESCRIPTOR_CONTROL) @@ -715,6 +437,12 @@ FARPROC = PVOID PIO_APC_ROUTINE = PVOID PVECTORED_EXCEPTION_HANDLER = PVOID PFN_CRYPT_GET_SIGNER_CERTIFICATE = PVOID +PSYM_ENUMERATESYMBOLS_CALLBACK = PVOID +PSYM_ENUMERATESYMBOLS_CALLBACKW = PVOID +PEVENT_CALLBACK = PVOID +PEVENT_TRACE_BUFFER_CALLBACKA = PVOID +PEVENT_TRACE_BUFFER_CALLBACKW = PVOID +PEVENT_RECORD_CALLBACK = PVOID LPCONTEXT = PVOID HCERTSTORE = PVOID HCRYPTMSG = PVOID @@ -950,8 +678,8 @@ FILE_DISPOSITION_INFORMATION = _FILE_DISPOSITION_INFORMATION class _FILE_FULL_EA_INFORMATION(Structure): _fields_ = [ ("NextEntryOffset", ULONG), - ("Flags", UCHAR), - ("EaNameLength", UCHAR), + ("Flags", BYTE), + ("EaNameLength", BYTE), ("EaValueLength", USHORT), ("EaName", CHAR * 1), ] @@ -967,50 +695,23 @@ class _FILE_GET_EA_INFORMATION(Structure): FILE_GET_EA_INFORMATION = _FILE_GET_EA_INFORMATION PFILE_GET_EA_INFORMATION = POINTER(_FILE_GET_EA_INFORMATION) -KeyValueBasicInformation = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValueBasicInformation", 0x0) -KeyValueFullInformation = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValueFullInformation", 0x1) -KeyValuePartialInformation = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValuePartialInformation", 0x2) -KeyValueFullInformationAlign64 = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValueFullInformationAlign64", 0x3) -KeyValuePartialInformationAlign64 = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValuePartialInformationAlign64", 0x4) -KeyValueLayerInformation = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValueLayerInformation", 0x5) -MaxKeyValueInfoClass = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "MaxKeyValueInfoClass", 0x6) -class _KEY_VALUE_INFORMATION_CLASS(EnumType): - values = [KeyValueBasicInformation, KeyValueFullInformation, KeyValuePartialInformation, KeyValueFullInformationAlign64, KeyValuePartialInformationAlign64, KeyValueLayerInformation, MaxKeyValueInfoClass] - mapper = FlagMapper(*values) -KEY_VALUE_INFORMATION_CLASS = _KEY_VALUE_INFORMATION_CLASS - - -class _KEY_VALUE_BASIC_INFORMATION(Structure): +class tagVS_FIXEDFILEINFO(Structure): _fields_ = [ - ("TitleIndex", ULONG), - ("Type", ULONG), - ("NameLength", ULONG), - ("Name", WCHAR * 1), + ("dwSignature", DWORD), + ("dwStrucVersion", DWORD), + ("dwFileVersionMS", DWORD), + ("dwFileVersionLS", DWORD), + ("dwProductVersionMS", DWORD), + ("dwProductVersionLS", DWORD), + ("dwFileFlagsMask", DWORD), + ("dwFileFlags", DWORD), + ("dwFileOS", DWORD), + ("dwFileType", DWORD), + ("dwFileSubtype", DWORD), + ("dwFileDateMS", DWORD), + ("dwFileDateLS", DWORD), ] -PKEY_VALUE_BASIC_INFORMATION = POINTER(_KEY_VALUE_BASIC_INFORMATION) -KEY_VALUE_BASIC_INFORMATION = _KEY_VALUE_BASIC_INFORMATION - -class _KEY_VALUE_FULL_INFORMATION(Structure): - _fields_ = [ - ("TitleIndex", ULONG), - ("Type", ULONG), - ("DataOffset", ULONG), - ("DataLength", ULONG), - ("NameLength", ULONG), - ("Name", WCHAR * 1), - ] -KEY_VALUE_FULL_INFORMATION = _KEY_VALUE_FULL_INFORMATION -PKEY_VALUE_FULL_INFORMATION = POINTER(_KEY_VALUE_FULL_INFORMATION) - -class _KEY_VALUE_PARTIAL_INFORMATION(Structure): - _fields_ = [ - ("TitleIndex", ULONG), - ("Type", ULONG), - ("DataLength", ULONG), - ("Data", UCHAR * 1), - ] -PKEY_VALUE_PARTIAL_INFORMATION = POINTER(_KEY_VALUE_PARTIAL_INFORMATION) -KEY_VALUE_PARTIAL_INFORMATION = _KEY_VALUE_PARTIAL_INFORMATION +VS_FIXEDFILEINFO = tagVS_FIXEDFILEINFO class _GUID(Structure): _fields_ = [ @@ -1020,6 +721,7 @@ class _GUID(Structure): ("Data4", BYTE * 8), ] REFCLSID = POINTER(_GUID) +LPCGUID = POINTER(_GUID) REFGUID = POINTER(_GUID) LPGUID = POINTER(_GUID) IID = _GUID @@ -1075,6 +777,7 @@ class _GUID(INITIAL_GUID): datas.append(int(part_iid[4][i * 2:(i + 1) * 2], 16)) return cls.from_raw(*datas, strid=iid) + @classmethod def from_raw(cls, Data1, Data2, Data3, Data41, Data42, Data43, Data44, Data45, Data46, Data47, Data48, **kwargs): return cls(Data1, Data2, Data3, (BYTE*8)(Data41, Data42, Data43, Data44, Data45, Data46, Data47, Data48), **kwargs) @@ -1085,6 +788,7 @@ class _GUID(INITIAL_GUID): return (self.Data1, self.Data2, self.Data3, self.Data4[:]) == (other.Data1, other.Data2, other.Data3, other.Data4[:]) REFCLSID = POINTER(_GUID) +LPCGUID = POINTER(_GUID) REFGUID = POINTER(_GUID) LPGUID = POINTER(_GUID) IID = _GUID @@ -1107,6 +811,129 @@ class SYM_TYPE(EnumType): mapper = FlagMapper(*values) +btNoType = EnumValue("BasicType", "btNoType", 0x0) +btVoid = EnumValue("BasicType", "btVoid", 0x1) +btChar = EnumValue("BasicType", "btChar", 0x2) +btWChar = EnumValue("BasicType", "btWChar", 0x3) +btInt = EnumValue("BasicType", "btInt", 0x6) +btUInt = EnumValue("BasicType", "btUInt", 0x7) +btFloat = EnumValue("BasicType", "btFloat", 0x8) +btBCD = EnumValue("BasicType", "btBCD", 0x9) +btBool = EnumValue("BasicType", "btBool", 0xa) +btLong = EnumValue("BasicType", "btLong", 0xd) +btULong = EnumValue("BasicType", "btULong", 0xe) +btCurrency = EnumValue("BasicType", "btCurrency", 0x19) +btDate = EnumValue("BasicType", "btDate", 0x1a) +btVariant = EnumValue("BasicType", "btVariant", 0x1b) +btComplex = EnumValue("BasicType", "btComplex", 0x1c) +btBit = EnumValue("BasicType", "btBit", 0x1d) +btBSTR = EnumValue("BasicType", "btBSTR", 0x1e) +btHresult = EnumValue("BasicType", "btHresult", 0x1f) +class BasicType(EnumType): + values = [btNoType, btVoid, btChar, btWChar, btInt, btUInt, btFloat, btBCD, btBool, btLong, btULong, btCurrency, btDate, btVariant, btComplex, btBit, btBSTR, btHresult] + mapper = FlagMapper(*values) + + +DataIsUnknown = EnumValue("DataKind", "DataIsUnknown", 0x0) +DataIsLocal = EnumValue("DataKind", "DataIsLocal", 0x1) +DataIsStaticLocal = EnumValue("DataKind", "DataIsStaticLocal", 0x2) +DataIsParam = EnumValue("DataKind", "DataIsParam", 0x3) +DataIsObjectPtr = EnumValue("DataKind", "DataIsObjectPtr", 0x4) +DataIsFileStatic = EnumValue("DataKind", "DataIsFileStatic", 0x5) +DataIsGlobal = EnumValue("DataKind", "DataIsGlobal", 0x6) +DataIsMember = EnumValue("DataKind", "DataIsMember", 0x7) +DataIsStaticMember = EnumValue("DataKind", "DataIsStaticMember", 0x8) +DataIsConstant = EnumValue("DataKind", "DataIsConstant", 0x9) +class DataKind(EnumType): + values = [DataIsUnknown, DataIsLocal, DataIsStaticLocal, DataIsParam, DataIsObjectPtr, DataIsFileStatic, DataIsGlobal, DataIsMember, DataIsStaticMember, DataIsConstant] + mapper = FlagMapper(*values) + + +UdtStruct = EnumValue("UdtKind", "UdtStruct", 0x0) +UdtClass = EnumValue("UdtKind", "UdtClass", 0x1) +UdtUnion = EnumValue("UdtKind", "UdtUnion", 0x2) +class UdtKind(EnumType): + values = [UdtStruct, UdtClass, UdtUnion] + mapper = FlagMapper(*values) + + +SymTagNull = EnumValue("_SymTagEnum", "SymTagNull", 0x0) +SymTagExe = EnumValue("_SymTagEnum", "SymTagExe", 0x1) +SymTagCompiland = EnumValue("_SymTagEnum", "SymTagCompiland", 0x2) +SymTagCompilandDetails = EnumValue("_SymTagEnum", "SymTagCompilandDetails", 0x3) +SymTagCompilandEnv = EnumValue("_SymTagEnum", "SymTagCompilandEnv", 0x4) +SymTagFunction = EnumValue("_SymTagEnum", "SymTagFunction", 0x5) +SymTagBlock = EnumValue("_SymTagEnum", "SymTagBlock", 0x6) +SymTagData = EnumValue("_SymTagEnum", "SymTagData", 0x7) +SymTagAnnotation = EnumValue("_SymTagEnum", "SymTagAnnotation", 0x8) +SymTagLabel = EnumValue("_SymTagEnum", "SymTagLabel", 0x9) +SymTagPublicSymbol = EnumValue("_SymTagEnum", "SymTagPublicSymbol", 0xa) +SymTagUDT = EnumValue("_SymTagEnum", "SymTagUDT", 0xb) +SymTagEnum = EnumValue("_SymTagEnum", "SymTagEnum", 0xc) +SymTagFunctionType = EnumValue("_SymTagEnum", "SymTagFunctionType", 0xd) +SymTagPointerType = EnumValue("_SymTagEnum", "SymTagPointerType", 0xe) +SymTagArrayType = EnumValue("_SymTagEnum", "SymTagArrayType", 0xf) +SymTagBaseType = EnumValue("_SymTagEnum", "SymTagBaseType", 0x10) +SymTagTypedef = EnumValue("_SymTagEnum", "SymTagTypedef", 0x11) +SymTagBaseClass = EnumValue("_SymTagEnum", "SymTagBaseClass", 0x12) +SymTagFriend = EnumValue("_SymTagEnum", "SymTagFriend", 0x13) +SymTagFunctionArgType = EnumValue("_SymTagEnum", "SymTagFunctionArgType", 0x14) +SymTagFuncDebugStart = EnumValue("_SymTagEnum", "SymTagFuncDebugStart", 0x15) +SymTagFuncDebugEnd = EnumValue("_SymTagEnum", "SymTagFuncDebugEnd", 0x16) +SymTagUsingNamespace = EnumValue("_SymTagEnum", "SymTagUsingNamespace", 0x17) +SymTagVTableShape = EnumValue("_SymTagEnum", "SymTagVTableShape", 0x18) +SymTagVTable = EnumValue("_SymTagEnum", "SymTagVTable", 0x19) +SymTagCustom = EnumValue("_SymTagEnum", "SymTagCustom", 0x1a) +SymTagThunk = EnumValue("_SymTagEnum", "SymTagThunk", 0x1b) +SymTagCustomType = EnumValue("_SymTagEnum", "SymTagCustomType", 0x1c) +SymTagManagedType = EnumValue("_SymTagEnum", "SymTagManagedType", 0x1d) +SymTagDimension = EnumValue("_SymTagEnum", "SymTagDimension", 0x1e) +class _SymTagEnum(EnumType): + values = [SymTagNull, SymTagExe, SymTagCompiland, SymTagCompilandDetails, SymTagCompilandEnv, SymTagFunction, SymTagBlock, SymTagData, SymTagAnnotation, SymTagLabel, SymTagPublicSymbol, SymTagUDT, SymTagEnum, SymTagFunctionType, SymTagPointerType, SymTagArrayType, SymTagBaseType, SymTagTypedef, SymTagBaseClass, SymTagFriend, SymTagFunctionArgType, SymTagFuncDebugStart, SymTagFuncDebugEnd, SymTagUsingNamespace, SymTagVTableShape, SymTagVTable, SymTagCustom, SymTagThunk, SymTagCustomType, SymTagManagedType, SymTagDimension] + mapper = FlagMapper(*values) +SymTagEnum = _SymTagEnum + + +TI_GET_SYMTAG = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_SYMTAG", 0x0) +TI_GET_SYMNAME = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_SYMNAME", 0x1) +TI_GET_LENGTH = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_LENGTH", 0x2) +TI_GET_TYPE = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_TYPE", 0x3) +TI_GET_TYPEID = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_TYPEID", 0x4) +TI_GET_BASETYPE = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_BASETYPE", 0x5) +TI_GET_ARRAYINDEXTYPEID = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_ARRAYINDEXTYPEID", 0x6) +TI_FINDCHILDREN = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_FINDCHILDREN", 0x7) +TI_GET_DATAKIND = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_DATAKIND", 0x8) +TI_GET_ADDRESSOFFSET = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_ADDRESSOFFSET", 0x9) +TI_GET_OFFSET = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_OFFSET", 0xa) +TI_GET_VALUE = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VALUE", 0xb) +TI_GET_COUNT = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_COUNT", 0xc) +TI_GET_CHILDRENCOUNT = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_CHILDRENCOUNT", 0xd) +TI_GET_BITPOSITION = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_BITPOSITION", 0xe) +TI_GET_VIRTUALBASECLASS = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VIRTUALBASECLASS", 0xf) +TI_GET_VIRTUALTABLESHAPEID = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VIRTUALTABLESHAPEID", 0x10) +TI_GET_VIRTUALBASEPOINTEROFFSET = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VIRTUALBASEPOINTEROFFSET", 0x11) +TI_GET_CLASSPARENTID = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_CLASSPARENTID", 0x12) +TI_GET_NESTED = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_NESTED", 0x13) +TI_GET_SYMINDEX = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_SYMINDEX", 0x14) +TI_GET_LEXICALPARENT = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_LEXICALPARENT", 0x15) +TI_GET_ADDRESS = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_ADDRESS", 0x16) +TI_GET_THISADJUST = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_THISADJUST", 0x17) +TI_GET_UDTKIND = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_UDTKIND", 0x18) +TI_IS_EQUIV_TO = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_IS_EQUIV_TO", 0x19) +TI_GET_CALLING_CONVENTION = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_CALLING_CONVENTION", 0x1a) +TI_IS_CLOSE_EQUIV_TO = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_IS_CLOSE_EQUIV_TO", 0x1b) +TI_GTIEX_REQS_VALID = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GTIEX_REQS_VALID", 0x1c) +TI_GET_VIRTUALBASEOFFSET = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VIRTUALBASEOFFSET", 0x1d) +TI_GET_VIRTUALBASEDISPINDEX = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VIRTUALBASEDISPINDEX", 0x1e) +TI_GET_IS_REFERENCE = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_IS_REFERENCE", 0x1f) +TI_GET_INDIRECTVIRTUALBASECLASS = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_INDIRECTVIRTUALBASECLASS", 0x20) +IMAGEHLP_SYMBOL_TYPE_INFO_MAX = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "IMAGEHLP_SYMBOL_TYPE_INFO_MAX", 0x21) +class _IMAGEHLP_SYMBOL_TYPE_INFO(EnumType): + values = [TI_GET_SYMTAG, TI_GET_SYMNAME, TI_GET_LENGTH, TI_GET_TYPE, TI_GET_TYPEID, TI_GET_BASETYPE, TI_GET_ARRAYINDEXTYPEID, TI_FINDCHILDREN, TI_GET_DATAKIND, TI_GET_ADDRESSOFFSET, TI_GET_OFFSET, TI_GET_VALUE, TI_GET_COUNT, TI_GET_CHILDRENCOUNT, TI_GET_BITPOSITION, TI_GET_VIRTUALBASECLASS, TI_GET_VIRTUALTABLESHAPEID, TI_GET_VIRTUALBASEPOINTEROFFSET, TI_GET_CLASSPARENTID, TI_GET_NESTED, TI_GET_SYMINDEX, TI_GET_LEXICALPARENT, TI_GET_ADDRESS, TI_GET_THISADJUST, TI_GET_UDTKIND, TI_IS_EQUIV_TO, TI_GET_CALLING_CONVENTION, TI_IS_CLOSE_EQUIV_TO, TI_GTIEX_REQS_VALID, TI_GET_VIRTUALBASEOFFSET, TI_GET_VIRTUALBASEDISPINDEX, TI_GET_IS_REFERENCE, TI_GET_INDIRECTVIRTUALBASECLASS, IMAGEHLP_SYMBOL_TYPE_INFO_MAX] + mapper = FlagMapper(*values) +IMAGEHLP_SYMBOL_TYPE_INFO = _IMAGEHLP_SYMBOL_TYPE_INFO + + class _IMAGEHLP_MODULE64(Structure): _fields_ = [ ("SizeOfStruct", DWORD), @@ -1136,2137 +963,34 @@ class _IMAGEHLP_MODULE64(Structure): PIMAGEHLP_MODULE64 = POINTER(_IMAGEHLP_MODULE64) IMAGEHLP_MODULE64 = _IMAGEHLP_MODULE64 -class _CERT_STRONG_SIGN_SERIALIZED_INFO(Structure): +class _SYMBOL_INFO(Structure): _fields_ = [ - ("dwFlags", DWORD), - ("pwszCNGSignHashAlgids", LPWSTR), - ("pwszCNGPubKeyMinBitLengths", LPWSTR), + ("SizeOfStruct", ULONG), + ("TypeIndex", ULONG), + ("Reserved", ULONG64 * 2), + ("Index", ULONG), + ("Size", ULONG), + ("ModBase", ULONG64), + ("Flags", ULONG), + ("Value", ULONG64), + ("Address", ULONG64), + ("Register", ULONG), + ("Scope", ULONG), + ("Tag", ULONG), + ("NameLen", ULONG), + ("MaxNameLen", ULONG), + ("Name", CHAR * 1), ] -CERT_STRONG_SIGN_SERIALIZED_INFO = _CERT_STRONG_SIGN_SERIALIZED_INFO -PCERT_STRONG_SIGN_SERIALIZED_INFO = POINTER(_CERT_STRONG_SIGN_SERIALIZED_INFO) - -class TMP_CERT_STRONG_SIGN_PARA_UNION_TYPE(Union): - _fields_ = [ - ("pvInfo", PVOID), - ("pSerializedInfo", PCERT_STRONG_SIGN_SERIALIZED_INFO), - ("pszOID", LPSTR), - ] - - -class _CERT_STRONG_SIGN_PARA(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("dwInfoChoice", DWORD), - ("tmp_union", TMP_CERT_STRONG_SIGN_PARA_UNION_TYPE), - ] -CERT_STRONG_SIGN_PARA = _CERT_STRONG_SIGN_PARA -PCCERT_STRONG_SIGN_PARA = POINTER(_CERT_STRONG_SIGN_PARA) -PCERT_STRONG_SIGN_PARA = POINTER(_CERT_STRONG_SIGN_PARA) - -class _CRYPTOAPI_BLOB(Structure): - _fields_ = [ - ("cbData", DWORD), - ("pbData", POINTER(BYTE)), - ] -CRYPT_INTEGER_BLOB = _CRYPTOAPI_BLOB -PCRYPT_DATA_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_OBJID_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_DER_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRL_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_UINT_BLOB = POINTER(_CRYPTOAPI_BLOB) -CERT_NAME_BLOB = _CRYPTOAPI_BLOB -PCRYPT_DIGEST_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_INTEGER_BLOB = POINTER(_CRYPTOAPI_BLOB) -CERT_RDN_VALUE_BLOB = _CRYPTOAPI_BLOB -PCERT_NAME_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_HASH_BLOB = POINTER(_CRYPTOAPI_BLOB) -CRYPT_DATA_BLOB = _CRYPTOAPI_BLOB -DATA_BLOB = _CRYPTOAPI_BLOB -CRYPT_UINT_BLOB = _CRYPTOAPI_BLOB -PCERT_RDN_VALUE_BLOB = POINTER(_CRYPTOAPI_BLOB) -CRYPT_HASH_BLOB = _CRYPTOAPI_BLOB -CRL_BLOB = _CRYPTOAPI_BLOB -PCERT_BLOB = POINTER(_CRYPTOAPI_BLOB) -CRYPT_DIGEST_BLOB = _CRYPTOAPI_BLOB -CRYPT_OBJID_BLOB = _CRYPTOAPI_BLOB -CERT_BLOB = _CRYPTOAPI_BLOB -CRYPT_DER_BLOB = _CRYPTOAPI_BLOB -PDATA_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_ATTR_BLOB = POINTER(_CRYPTOAPI_BLOB) -CRYPT_ATTR_BLOB = _CRYPTOAPI_BLOB - -class _CRYPTOAPI_BLOB(_CRYPTOAPI_BLOB): - @classmethod - def from_string(cls, buf): - self = cls() - self.cbData = len(buf) - self.pbData = (BYTE * self.cbData)(*bytearray(buf)) - return self +SYMBOL_INFO = _SYMBOL_INFO +PSYMBOL_INFO = POINTER(_SYMBOL_INFO) +old_SYMBOL_INFO = _SYMBOL_INFO +class _SYMBOL_INFO(old_SYMBOL_INFO): @property - def data(self): - return bytearray(self.pbData[:self.cbData]) -CRYPT_INTEGER_BLOB = _CRYPTOAPI_BLOB -PCRYPT_DATA_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_OBJID_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_DER_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRL_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_UINT_BLOB = POINTER(_CRYPTOAPI_BLOB) -CERT_NAME_BLOB = _CRYPTOAPI_BLOB -PCRYPT_DIGEST_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_INTEGER_BLOB = POINTER(_CRYPTOAPI_BLOB) -CERT_RDN_VALUE_BLOB = _CRYPTOAPI_BLOB -PCERT_NAME_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_HASH_BLOB = POINTER(_CRYPTOAPI_BLOB) -CRYPT_DATA_BLOB = _CRYPTOAPI_BLOB -DATA_BLOB = _CRYPTOAPI_BLOB -CRYPT_UINT_BLOB = _CRYPTOAPI_BLOB -PCERT_RDN_VALUE_BLOB = POINTER(_CRYPTOAPI_BLOB) -CRYPT_HASH_BLOB = _CRYPTOAPI_BLOB -CRL_BLOB = _CRYPTOAPI_BLOB -PCERT_BLOB = POINTER(_CRYPTOAPI_BLOB) -CRYPT_DIGEST_BLOB = _CRYPTOAPI_BLOB -CRYPT_OBJID_BLOB = _CRYPTOAPI_BLOB -CERT_BLOB = _CRYPTOAPI_BLOB -CRYPT_DER_BLOB = _CRYPTOAPI_BLOB -PDATA_BLOB = POINTER(_CRYPTOAPI_BLOB) -PCRYPT_ATTR_BLOB = POINTER(_CRYPTOAPI_BLOB) -CRYPT_ATTR_BLOB = _CRYPTOAPI_BLOB -class CRYPTCATATTRIBUTE_(Structure): - _fields_ = [ - ("cbStruct", DWORD), - ("pwszReferenceTag", LPWSTR), - ("dwAttrTypeAndAction", DWORD), - ("cbValue", DWORD), - ("pbValue", POINTER(BYTE)), - ("dwReserved", DWORD), - ] -CRYPTCATATTRIBUTE = CRYPTCATATTRIBUTE_ -PCRYPTCATATTRIBUTE = POINTER(CRYPTCATATTRIBUTE_) - -class _CRYPT_ATTRIBUTE_TYPE_VALUE(Structure): - _fields_ = [ - ("pszObjId", LPSTR), - ("Value", CRYPT_OBJID_BLOB), - ] -CRYPT_ATTRIBUTE_TYPE_VALUE = _CRYPT_ATTRIBUTE_TYPE_VALUE -PCRYPT_ATTRIBUTE_TYPE_VALUE = POINTER(_CRYPT_ATTRIBUTE_TYPE_VALUE) - -class _CRYPT_ALGORITHM_IDENTIFIER(Structure): - _fields_ = [ - ("pszObjId", LPSTR), - ("Parameters", CRYPT_OBJID_BLOB), - ] -CRYPT_ALGORITHM_IDENTIFIER = _CRYPT_ALGORITHM_IDENTIFIER -PCRYPT_ALGORITHM_IDENTIFIER = POINTER(_CRYPT_ALGORITHM_IDENTIFIER) - -class SIP_INDIRECT_DATA_(Structure): - _fields_ = [ - ("Data", CRYPT_ATTRIBUTE_TYPE_VALUE), - ("DigestAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("Digest", CRYPT_HASH_BLOB), - ] -SIP_INDIRECT_DATA = SIP_INDIRECT_DATA_ -PSIP_INDIRECT_DATA = POINTER(SIP_INDIRECT_DATA_) - -class CRYPTCATMEMBER_(Structure): - _fields_ = [ - ("cbStruct", DWORD), - ("pwszReferenceTag", LPWSTR), - ("pwszFileName", LPWSTR), - ("gSubjectType", GUID), - ("fdwMemberFlags", DWORD), - ("pIndirectData", POINTER(SIP_INDIRECT_DATA)), - ("dwCertVersion", DWORD), - ("dwReserved", DWORD), - ("hReserved", HANDLE), - ("sEncodedIndirectData", CRYPT_ATTR_BLOB), - ("sEncodedMemberInfo", CRYPT_ATTR_BLOB), - ] -CRYPTCATMEMBER = CRYPTCATMEMBER_ -PCRYPTCATMEMBER = POINTER(CRYPTCATMEMBER_) - -class WINTRUST_FILE_INFO_(Structure): - _fields_ = [ - ("cbStruct", DWORD), - ("pcwszFilePath", LPCWSTR), - ("hFile", HANDLE), - ("pgKnownSubject", POINTER(GUID)), - ] -WINTRUST_FILE_INFO = WINTRUST_FILE_INFO_ -PWINTRUST_FILE_INFO = POINTER(WINTRUST_FILE_INFO_) - -class _CRYPT_ATTRIBUTE(Structure): - _fields_ = [ - ("pszObjId", LPSTR), - ("cValue", DWORD), - ("rgValue", PCRYPT_ATTR_BLOB), - ] -PCRYPT_ATTRIBUTE = POINTER(_CRYPT_ATTRIBUTE) -CRYPT_ATTRIBUTE = _CRYPT_ATTRIBUTE - -class _CTL_ENTRY(Structure): - _fields_ = [ - ("SubjectIdentifier", CRYPT_DATA_BLOB), - ("cAttribute", DWORD), - ("rgAttribute", PCRYPT_ATTRIBUTE), - ] -PCTL_ENTRY = POINTER(_CTL_ENTRY) -CTL_ENTRY = _CTL_ENTRY - -class _CRYPT_ATTRIBUTE(Structure): - _fields_ = [ - ("pszObjId", LPSTR), - ("cValue", DWORD), - ("rgValue", PCRYPT_ATTR_BLOB), - ] -PCRYPT_ATTRIBUTE = POINTER(_CRYPT_ATTRIBUTE) -CRYPT_ATTRIBUTE = _CRYPT_ATTRIBUTE - -class _CRYPT_ATTRIBUTES(Structure): - _fields_ = [ - ("cAttr", DWORD), - ("rgAttr", PCRYPT_ATTRIBUTE), - ] -CRYPT_ATTRIBUTES = _CRYPT_ATTRIBUTES -PCRYPT_ATTRIBUTES = POINTER(_CRYPT_ATTRIBUTES) - -class _CERT_EXTENSION(Structure): - _fields_ = [ - ("pszObjId", LPSTR), - ("fCritical", BOOL), - ("Value", CRYPT_OBJID_BLOB), - ] -CERT_EXTENSION = _CERT_EXTENSION -PCERT_EXTENSION = POINTER(_CERT_EXTENSION) - -class _CRL_ENTRY(Structure): - _fields_ = [ - ("SerialNumber", CRYPT_INTEGER_BLOB), - ("RevocationDate", FILETIME), - ("cExtension", DWORD), - ("rgExtension", PCERT_EXTENSION), - ] -CRL_ENTRY = _CRL_ENTRY -PCRL_ENTRY = POINTER(_CRL_ENTRY) - -class _CRL_INFO(Structure): - _fields_ = [ - ("dwVersion", DWORD), - ("SignatureAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("Issuer", CERT_NAME_BLOB), - ("ThisUpdate", FILETIME), - ("NextUpdate", FILETIME), - ("cCRLEntry", DWORD), - ("rgCRLEntry", PCRL_ENTRY), - ("cExtension", DWORD), - ("rgExtension", PCERT_EXTENSION), - ] -CRL_INFO = _CRL_INFO -PCRL_INFO = POINTER(_CRL_INFO) - -class _CRL_CONTEXT(Structure): - _fields_ = [ - ("dwCertEncodingType", DWORD), - ("pbCrlEncoded", POINTER(BYTE)), - ("cbCrlEncoded", DWORD), - ("pCrlInfo", PCRL_INFO), - ("hCertStore", HCERTSTORE), - ] -PCCRL_CONTEXT = POINTER(_CRL_CONTEXT) -CRL_CONTEXT = _CRL_CONTEXT -PCRL_CONTEXT = POINTER(_CRL_CONTEXT) - -class _CMSG_SIGNER_INFO(Structure): - _fields_ = [ - ("dwVersion", DWORD), - ("Issuer", CERT_NAME_BLOB), - ("SerialNumber", CRYPT_INTEGER_BLOB), - ("HashAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("HashEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("EncryptedHash", CRYPT_DATA_BLOB), - ("AuthAttrs", CRYPT_ATTRIBUTES), - ("UnauthAttrs", CRYPT_ATTRIBUTES), - ] -CMSG_SIGNER_INFO = _CMSG_SIGNER_INFO -PCMSG_SIGNER_INFO = POINTER(_CMSG_SIGNER_INFO) - -class _CTL_USAGE(Structure): - _fields_ = [ - ("cUsageIdentifier", DWORD), - ("rgpszUsageIdentifier", POINTER(LPSTR)), - ] -CERT_ENHKEY_USAGE = _CTL_USAGE -PCTL_USAGE = POINTER(_CTL_USAGE) -CTL_USAGE = _CTL_USAGE -PCERT_ENHKEY_USAGE = POINTER(_CTL_USAGE) - -class _CTL_INFO(Structure): - _fields_ = [ - ("dwVersion", DWORD), - ("SubjectUsage", CTL_USAGE), - ("ListIdentifier", CRYPT_DATA_BLOB), - ("SequenceNumber", CRYPT_INTEGER_BLOB), - ("ThisUpdate", FILETIME), - ("NextUpdate", FILETIME), - ("SubjectAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("cCTLEntry", DWORD), - ("rgCTLEntry", PCTL_ENTRY), - ("cExtension", DWORD), - ("rgExtension", PCERT_EXTENSION), - ] -CTL_INFO = _CTL_INFO -PCTL_INFO = POINTER(_CTL_INFO) - -class _CTL_CONTEXT(Structure): - _fields_ = [ - ("dwMsgAndCertEncodingType", DWORD), - ("pbCtlEncoded", POINTER(BYTE)), - ("cbCtlEncoded", DWORD), - ("pCtlInfo", PCTL_INFO), - ("hCertStore", HCERTSTORE), - ("hCryptMsg", HCRYPTMSG), - ("pbCtlContent", POINTER(BYTE)), - ("cbCtlContent", DWORD), - ] -PCTL_CONTEXT = POINTER(_CTL_CONTEXT) -CTL_CONTEXT = _CTL_CONTEXT -PCCTL_CONTEXT = POINTER(_CTL_CONTEXT) - -class WINTRUST_CATALOG_INFO_(Structure): - _fields_ = [ - ("cbStruct", DWORD), - ("dwCatalogVersion", DWORD), - ("pcwszCatalogFilePath", LPCWSTR), - ("pcwszMemberTag", LPCWSTR), - ("pcwszMemberFilePath", LPCWSTR), - ("hMemberFile", HANDLE), - ("pbCalculatedFileHash", POINTER(BYTE)), - ("cbCalculatedFileHash", DWORD), - ("pcCatalogContext", PCCTL_CONTEXT), - ] -PWINTRUST_CATALOG_INFO = POINTER(WINTRUST_CATALOG_INFO_) -WINTRUST_CATALOG_INFO = WINTRUST_CATALOG_INFO_ - -class WINTRUST_BLOB_INFO_(Structure): - _fields_ = [ - ("cbStruct", DWORD), - ("gSubject", GUID), - ("pcwszDisplayName", LPCWSTR), - ("cbMemObject", DWORD), - ("pbMemObject", POINTER(BYTE)), - ("cbMemSignedMsg", DWORD), - ("pbMemSignedMsg", POINTER(BYTE)), - ] -PWINTRUST_BLOB_INFO = POINTER(WINTRUST_BLOB_INFO_) -WINTRUST_BLOB_INFO = WINTRUST_BLOB_INFO_ - -class _CRYPT_BIT_BLOB(Structure): - _fields_ = [ - ("cbData", DWORD), - ("pbData", POINTER(BYTE)), - ("cUnusedBits", DWORD), - ] -CRYPT_BIT_BLOB = _CRYPT_BIT_BLOB -PCRYPT_BIT_BLOB = POINTER(_CRYPT_BIT_BLOB) - -class _CRYPT_BIT_BLOB(_CRYPT_BIT_BLOB): - @property - def data(self): - return bytearray(self.pbData[:self.cbData]) -CRYPT_BIT_BLOB = _CRYPT_BIT_BLOB -PCRYPT_BIT_BLOB = POINTER(_CRYPT_BIT_BLOB) -class _CERT_PUBLIC_KEY_INFO(Structure): - _fields_ = [ - ("Algorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("PublicKey", CRYPT_BIT_BLOB), - ] -PCERT_PUBLIC_KEY_INFO = POINTER(_CERT_PUBLIC_KEY_INFO) -CERT_PUBLIC_KEY_INFO = _CERT_PUBLIC_KEY_INFO - -class _CERT_INFO(Structure): - _fields_ = [ - ("dwVersion", DWORD), - ("SerialNumber", CRYPT_INTEGER_BLOB), - ("SignatureAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("Issuer", CERT_NAME_BLOB), - ("NotBefore", FILETIME), - ("NotAfter", FILETIME), - ("Subject", CERT_NAME_BLOB), - ("SubjectPublicKeyInfo", CERT_PUBLIC_KEY_INFO), - ("IssuerUniqueId", CRYPT_BIT_BLOB), - ("SubjectUniqueId", CRYPT_BIT_BLOB), - ("cExtension", DWORD), - ("rgExtension", PCERT_EXTENSION), - ] -CERT_INFO = _CERT_INFO -PCERT_INFO = POINTER(_CERT_INFO) - -class _CERT_ISSUER_SERIAL_NUMBER(Structure): - _fields_ = [ - ("Issuer", CERT_NAME_BLOB), - ("SerialNumber", CRYPT_INTEGER_BLOB), - ] -CERT_ISSUER_SERIAL_NUMBER = _CERT_ISSUER_SERIAL_NUMBER -PCERT_ISSUER_SERIAL_NUMBER = POINTER(_CERT_ISSUER_SERIAL_NUMBER) - -class _TMPUNION_CERT_ID(Union): - _fields_ = [ - ("IssuerSerialNumber", CERT_ISSUER_SERIAL_NUMBER), - ("KeyId", CRYPT_HASH_BLOB), - ("HashId", CRYPT_HASH_BLOB), - ] -TMPUNION_CERT_ID = _TMPUNION_CERT_ID - -class _CERT_ID(Structure): - _fields_ = [ - ("dwIdChoice", DWORD), - ("DUMMYUNIONNAME", TMPUNION_CERT_ID), - ] -CERT_ID = _CERT_ID -PCERT_ID = POINTER(_CERT_ID) - -class _CERT_CONTEXT(Structure): - _fields_ = [ - ("dwCertEncodingType", DWORD), - ("pbCertEncoded", POINTER(BYTE)), - ("cbCertEncoded", DWORD), - ("pCertInfo", PCERT_INFO), - ("hCertStore", HCERTSTORE), - ] -PCCERT_CONTEXT = POINTER(_CERT_CONTEXT) -CERT_CONTEXT = _CERT_CONTEXT -PCERT_CONTEXT = POINTER(_CERT_CONTEXT) - -class WINTRUST_SGNR_INFO_(Structure): - _fields_ = [ - ("cbStruct", DWORD), - ("pcwszDisplayName", LPCWSTR), - ("psSignerInfo", POINTER(CMSG_SIGNER_INFO)), - ("chStores", DWORD), - ("pahStores", POINTER(HCERTSTORE)), - ] -WINTRUST_SGNR_INFO = WINTRUST_SGNR_INFO_ -PWINTRUST_SGNR_INFO = POINTER(WINTRUST_SGNR_INFO_) - -class WINTRUST_CERT_INFO_(Structure): - _fields_ = [ - ("cbStruct", DWORD), - ("pcwszDisplayName", LPCWSTR), - ("psCertContext", POINTER(CERT_CONTEXT)), - ("chStores", DWORD), - ("pahStores", POINTER(HCERTSTORE)), - ("dwFlags", DWORD), - ("psftVerifyAsOf", POINTER(FILETIME)), - ] -WINTRUST_CERT_INFO = WINTRUST_CERT_INFO_ -PWINTRUST_CERT_INFO = POINTER(WINTRUST_CERT_INFO_) - -class _TMP_WINTRUST_UNION_TYPE(Union): - _fields_ = [ - ("pFile", POINTER(WINTRUST_FILE_INFO_)), - ("pCatalog", POINTER(WINTRUST_CATALOG_INFO_)), - ("pBlob", POINTER(WINTRUST_BLOB_INFO_)), - ("pSgnr", POINTER(WINTRUST_SGNR_INFO_)), - ("pCert", POINTER(WINTRUST_CERT_INFO_)), - ] -TMP_WINTRUST_UNION_TYPE = _TMP_WINTRUST_UNION_TYPE - -class _WINTRUST_DATA(Structure): - _fields_ = [ - ("cbStruct", DWORD), - ("pPolicyCallbackData", LPVOID), - ("pSIPClientData", LPVOID), - ("dwUIChoice", DWORD), - ("fdwRevocationChecks", DWORD), - ("dwUnionChoice", DWORD), - ("tmp_union", TMP_WINTRUST_UNION_TYPE), - ("dwStateAction", DWORD), - ("hWVTStateData", HANDLE), - ("pwszURLReference", POINTER(WCHAR)), - ("dwProvFlags", DWORD), - ("dwUIContext", DWORD), - ] -PWINTRUST_DATA = POINTER(_WINTRUST_DATA) -WINTRUST_DATA = _WINTRUST_DATA - -class _CRYPT_SIGN_MESSAGE_PARA(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("dwMsgEncodingType", DWORD), - ("pSigningCert", PCCERT_CONTEXT), - ("HashAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("pvHashAuxInfo", PVOID), - ("cMsgCert", DWORD), - ("rgpMsgCert", POINTER(PCCERT_CONTEXT)), - ("cMsgCrl", DWORD), - ("rgpMsgCrl", POINTER(PCCRL_CONTEXT)), - ("cAuthAttr", DWORD), - ("rgAuthAttr", PCRYPT_ATTRIBUTE), - ("cUnauthAttr", DWORD), - ("rgUnauthAttr", PCRYPT_ATTRIBUTE), - ("dwFlags", DWORD), - ("dwInnerContentType", DWORD), - ("HashEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("pvHashEncryptionAuxInfo", PVOID), - ] -CRYPT_SIGN_MESSAGE_PARA = _CRYPT_SIGN_MESSAGE_PARA -PCRYPT_SIGN_MESSAGE_PARA = POINTER(_CRYPT_SIGN_MESSAGE_PARA) - -class _CRYPT_HASH_MESSAGE_PARA(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("dwMsgEncodingType", DWORD), - ("hCryptProv", HCRYPTPROV_LEGACY), - ("HashAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("pvHashAuxInfo", PVOID), - ] -PCRYPT_HASH_MESSAGE_PARA = POINTER(_CRYPT_HASH_MESSAGE_PARA) -CRYPT_HASH_MESSAGE_PARA = _CRYPT_HASH_MESSAGE_PARA - -class _CRYPT_KEY_VERIFY_MESSAGE_PARA(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("dwMsgEncodingType", DWORD), - ("hCryptProv", HCRYPTPROV_LEGACY), - ] -CRYPT_KEY_VERIFY_MESSAGE_PARA = _CRYPT_KEY_VERIFY_MESSAGE_PARA -PCRYPT_KEY_VERIFY_MESSAGE_PARA = POINTER(_CRYPT_KEY_VERIFY_MESSAGE_PARA) - -class _CRYPT_VERIFY_MESSAGE_PARA(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("dwMsgAndCertEncodingType", DWORD), - ("hCryptProv", HCRYPTPROV_LEGACY), - ("pfnGetSignerCertificate", PFN_CRYPT_GET_SIGNER_CERTIFICATE), - ("pvGetArg", PVOID), - ("pStrongSignPara", PCCERT_STRONG_SIGN_PARA), - ] -CRYPT_VERIFY_MESSAGE_PARA = _CRYPT_VERIFY_MESSAGE_PARA -PCRYPT_VERIFY_MESSAGE_PARA = POINTER(_CRYPT_VERIFY_MESSAGE_PARA) - -class _SPC_SERIALIZED_OBJECT(Structure): - _fields_ = [ - ("ClassId", SPC_UUID), - ("SerializedData", CRYPT_DATA_BLOB), - ] -SPC_SERIALIZED_OBJECT = _SPC_SERIALIZED_OBJECT -PSPC_SERIALIZED_OBJECT = POINTER(_SPC_SERIALIZED_OBJECT) - -class _TMP_SPC_LINK_UNION(Union): - _fields_ = [ - ("pwszUrl", LPWSTR), - ("Moniker", SPC_SERIALIZED_OBJECT), - ("pwszFile", LPWSTR), - ] -TMP_SPC_LINK_UNION = _TMP_SPC_LINK_UNION - -class SPC_LINK_(Structure): - _fields_ = [ - ("dwLinkChoice", DWORD), - ("u", TMP_SPC_LINK_UNION), - ] -PSPC_LINK = POINTER(SPC_LINK_) -SPC_LINK = SPC_LINK_ - -class _SPC_SP_OPUS_INFO(Structure): - _fields_ = [ - ("pwszProgramName", LPCWSTR), - ("pMoreInfo", POINTER(SPC_LINK_)), - ("pPublisherInfo", POINTER(SPC_LINK_)), - ] -PSPC_SP_OPUS_INFO = POINTER(_SPC_SP_OPUS_INFO) -SPC_SP_OPUS_INFO = _SPC_SP_OPUS_INFO - -class _CERT_TRUST_STATUS(Structure): - _fields_ = [ - ("dwErrorStatus", DWORD), - ("dwInfoStatus", DWORD), - ] -PCERT_TRUST_STATUS = POINTER(_CERT_TRUST_STATUS) -CERT_TRUST_STATUS = _CERT_TRUST_STATUS - -class _CERT_TRUST_LIST_INFO(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("pCtlEntry", PCTL_ENTRY), - ("pCtlContext", PCCTL_CONTEXT), - ] -PCERT_TRUST_LIST_INFO = POINTER(_CERT_TRUST_LIST_INFO) -CERT_TRUST_LIST_INFO = _CERT_TRUST_LIST_INFO - -class _CERT_REVOCATION_CRL_INFO(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("pBaseCrlContext", PCCRL_CONTEXT), - ("pDeltaCrlContext", PCCRL_CONTEXT), - ("pCrlEntry", PCRL_ENTRY), - ("fDeltaCrlEntry", BOOL), - ] -CERT_REVOCATION_CRL_INFO = _CERT_REVOCATION_CRL_INFO -PCERT_REVOCATION_CRL_INFO = POINTER(_CERT_REVOCATION_CRL_INFO) - -class _CERT_REVOCATION_INFO(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("dwRevocationResult", DWORD), - ("pszRevocationOid", LPCSTR), - ("pvOidSpecificInfo", LPVOID), - ("fHasFreshnessTime", BOOL), - ("dwFreshnessTime", DWORD), - ("pCrlInfo", PCERT_REVOCATION_CRL_INFO), - ] -CERT_REVOCATION_INFO = _CERT_REVOCATION_INFO -PCERT_REVOCATION_INFO = POINTER(_CERT_REVOCATION_INFO) - -class _CERT_CHAIN_ELEMENT(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("pCertContext", PCCERT_CONTEXT), - ("TrustStatus", CERT_TRUST_STATUS), - ("pRevocationInfo", PCERT_REVOCATION_INFO), - ("pIssuanceUsage", PCERT_ENHKEY_USAGE), - ("pApplicationUsage", PCERT_ENHKEY_USAGE), - ("pwszExtendedErrorInfo", LPCWSTR), - ] -PCERT_CHAIN_ELEMENT = POINTER(_CERT_CHAIN_ELEMENT) -CERT_CHAIN_ELEMENT = _CERT_CHAIN_ELEMENT -PCCERT_CHAIN_ELEMENT = POINTER(_CERT_CHAIN_ELEMENT) - -class _CERT_SIMPLE_CHAIN(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("TrustStatus", CERT_TRUST_STATUS), - ("cElement", DWORD), - ("rgpElement", POINTER(PCERT_CHAIN_ELEMENT)), - ("pTrustListInfo", PCERT_TRUST_LIST_INFO), - ("fHasRevocationFreshnessTime", BOOL), - ("dwRevocationFreshnessTime", DWORD), - ] -CERT_SIMPLE_CHAIN = _CERT_SIMPLE_CHAIN -PCERT_SIMPLE_CHAIN = POINTER(_CERT_SIMPLE_CHAIN) -PCCERT_SIMPLE_CHAIN = POINTER(_CERT_SIMPLE_CHAIN) - -# Self referencing struct tricks -class _CERT_CHAIN_CONTEXT(Structure): pass -CERT_CHAIN_CONTEXT = _CERT_CHAIN_CONTEXT -PCERT_CHAIN_CONTEXT = POINTER(_CERT_CHAIN_CONTEXT) -PCCERT_CHAIN_CONTEXT = POINTER(_CERT_CHAIN_CONTEXT) -_CERT_CHAIN_CONTEXT._fields_ = [ - ("cbSize", DWORD), - ("TrustStatus", CERT_TRUST_STATUS), - ("cChain", DWORD), - ("rgpChain", POINTER(PCERT_SIMPLE_CHAIN)), - ("cLowerQualityChainContext", DWORD), - ("rgpLowerQualityChainContext", POINTER(PCCERT_CHAIN_CONTEXT)), - ("fHasRevocationFreshnessTime", BOOL), - ("dwRevocationFreshnessTime", DWORD), - ("dwCreateFlags", DWORD), - ("ChainId", GUID), -] - -class _CERT_USAGE_MATCH(Structure): - _fields_ = [ - ("dwType", DWORD), - ("Usage", CERT_ENHKEY_USAGE), - ] -CERT_USAGE_MATCH = _CERT_USAGE_MATCH -PCERT_USAGE_MATCH = POINTER(_CERT_USAGE_MATCH) - -class _CERT_CHAIN_PARA(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("RequestedUsage", CERT_USAGE_MATCH), - ("RequestedIssuancePolicy", CERT_USAGE_MATCH), - ("dwUrlRetrievalTimeout", DWORD), - ("fCheckRevocationFreshnessTime", BOOL), - ("dwRevocationFreshnessTime", DWORD), - ("pftCacheResync", LPFILETIME), - ] -CERT_CHAIN_PARA = _CERT_CHAIN_PARA -PCERT_CHAIN_PARA = POINTER(_CERT_CHAIN_PARA) - -class _CERT_CHAIN_ENGINE_CONFIG(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("hRestrictedRoot", HCERTSTORE), - ("hRestrictedTrust", HCERTSTORE), - ("hRestrictedOther", HCERTSTORE), - ("cAdditionalStore", DWORD), - ("rghAdditionalStore", POINTER(HCERTSTORE)), - ("dwFlags", DWORD), - ("dwUrlRetrievalTimeout", DWORD), - ("MaximumCachedCertificates", DWORD), - ("CycleDetectionModulus", DWORD), - ] -CERT_CHAIN_ENGINE_CONFIG = _CERT_CHAIN_ENGINE_CONFIG -PCERT_CHAIN_ENGINE_CONFIG = POINTER(_CERT_CHAIN_ENGINE_CONFIG) - -class _SYSTEMTIME(Structure): - _fields_ = [ - ("wYear", WORD), - ("wMonth", WORD), - ("wDayOfWeek", WORD), - ("wDay", WORD), - ("wHour", WORD), - ("wMinute", WORD), - ("wSecond", WORD), - ("wMilliseconds", WORD), - ] -LPSYSTEMTIME = POINTER(_SYSTEMTIME) -SYSTEMTIME = _SYSTEMTIME -PSYSTEMTIME = POINTER(_SYSTEMTIME) - -class _CERT_EXTENSIONS(Structure): - _fields_ = [ - ("cExtension", DWORD), - ("rgExtension", PCERT_EXTENSION), - ] -PCERT_EXTENSIONS = POINTER(_CERT_EXTENSIONS) -CERT_EXTENSIONS = _CERT_EXTENSIONS - -class _CRYPT_KEY_PROV_PARAM(Structure): - _fields_ = [ - ("dwParam", DWORD), - ("pbData", POINTER(BYTE)), - ("cbData", DWORD), - ("dwFlags", DWORD), - ] -CRYPT_KEY_PROV_PARAM = _CRYPT_KEY_PROV_PARAM -PCRYPT_KEY_PROV_PARAM = POINTER(_CRYPT_KEY_PROV_PARAM) - -class _CRYPT_KEY_PROV_INFO(Structure): - _fields_ = [ - ("pwszContainerName", LPWSTR), - ("pwszProvName", LPWSTR), - ("dwProvType", DWORD), - ("dwFlags", DWORD), - ("cProvParam", DWORD), - ("rgProvParam", PCRYPT_KEY_PROV_PARAM), - ("dwKeySpec", DWORD), - ] -CRYPT_KEY_PROV_INFO = _CRYPT_KEY_PROV_INFO -PCRYPT_KEY_PROV_INFO = POINTER(_CRYPT_KEY_PROV_INFO) - -class _CRYPT_ENCRYPT_MESSAGE_PARA(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("dwMsgEncodingType", DWORD), - ("hCryptProv", HCRYPTPROV_LEGACY), - ("ContentEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("pvEncryptionAuxInfo", POINTER(VOID)), - ("dwFlags", DWORD), - ("dwInnerContentType", DWORD), - ] -PCRYPT_ENCRYPT_MESSAGE_PARA = POINTER(_CRYPT_ENCRYPT_MESSAGE_PARA) -CRYPT_ENCRYPT_MESSAGE_PARA = _CRYPT_ENCRYPT_MESSAGE_PARA - -class _CRYPT_DECRYPT_MESSAGE_PARA(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("dwMsgAndCertEncodingType", DWORD), - ("cCertStore", DWORD), - ("rghCertStore", POINTER(HCERTSTORE)), - ("dwFlags", DWORD), - ] -PCRYPT_DECRYPT_MESSAGE_PARA = POINTER(_CRYPT_DECRYPT_MESSAGE_PARA) -CRYPT_DECRYPT_MESSAGE_PARA = _CRYPT_DECRYPT_MESSAGE_PARA - -class _CERT_KEY_CONTEXT(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("hCryptProv", HCRYPTPROV), - ("dwKeySpec", DWORD), - ] -CERT_KEY_CONTEXT = _CERT_KEY_CONTEXT -PCERT_KEY_CONTEXT = POINTER(_CERT_KEY_CONTEXT) - -class _CRYPT_ENCODE_PARA(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("pfnAlloc", PVOID), - ("pfnFree", PVOID), - ] -PCRYPT_ENCODE_PARA = POINTER(_CRYPT_ENCODE_PARA) -CRYPT_ENCODE_PARA = _CRYPT_ENCODE_PARA - -class _TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO(Union): - _fields_ = [ - ("hKeyEncryptionKey", HCRYPTKEY), - ("pvKeyEncryptionKey", PVOID), - ] -TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO = _TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO - -class _CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("KeyEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("pvKeyEncryptionAuxInfo", PVOID), - ("hCryptProv", HCRYPTPROV), - ("dwKeyChoice", DWORD), - ("DUMMYUNIONNAME", TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO), - ("KeyId", CRYPT_DATA_BLOB), - ("Date", FILETIME), - ("pOtherAttr", PCRYPT_ATTRIBUTE_TYPE_VALUE), - ] -PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO = POINTER(_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO) -CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO = _CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO - -class _CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("KeyEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("pvKeyEncryptionAuxInfo", PVOID), - ("hCryptProv", HCRYPTPROV_LEGACY), - ("RecipientPublicKey", CRYPT_BIT_BLOB), - ("RecipientId", CERT_ID), - ] -PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO = POINTER(_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO) -CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO = _CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO - -class _CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("KeyEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("pvKeyEncryptionAuxInfo", PVOID), - ("hCryptProv", HCRYPTPROV_LEGACY), - ("RecipientPublicKey", CRYPT_BIT_BLOB), - ("RecipientId", CERT_ID), - ] -PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO = POINTER(_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO) -CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO = _CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO - -class _TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO(Union): - _fields_ = [ - ("pEphemeralAlgorithm", PCRYPT_ALGORITHM_IDENTIFIER), - ("pSenderId", PCERT_ID), - ] -TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO = _TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO - -class _CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("RecipientPublicKey", CRYPT_BIT_BLOB), - ("RecipientId", CERT_ID), - ("Date", FILETIME), - ("pOtherAttr", PCRYPT_ATTRIBUTE_TYPE_VALUE), - ] -PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO = POINTER(_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO) -CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO = _CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO - -class _CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("KeyEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("pvKeyEncryptionAuxInfo", PVOID), - ("KeyWrapAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("pvKeyWrapAuxInfo", PVOID), - ("hCryptProv", HCRYPTPROV_LEGACY), - ("dwKeySpec", DWORD), - ("dwKeyChoice", DWORD), - ("DUMMYUNIONNAME", TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO), - ("UserKeyingMaterial", CRYPT_DATA_BLOB), - ("cRecipientEncryptedKeys", DWORD), - ("rgpRecipientEncryptedKeys", POINTER(PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO)), - ] -PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO = POINTER(_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO) -CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO = _CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO - -class _TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION(Union): - _fields_ = [ - ("pKeyTrans", PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO), - ("pKeyAgree", PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO), - ("pMailList", PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO), - ] -TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION = _TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION - -class _CMSG_RECIPIENT_ENCODE_INFO(Structure): - _fields_ = [ - ("dwRecipientChoice", DWORD), - ("DUMMYUNIONNAME", TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION), - ] -CMSG_RECIPIENT_ENCODE_INFO = _CMSG_RECIPIENT_ENCODE_INFO -PCMSG_RECIPIENT_ENCODE_INFO = POINTER(_CMSG_RECIPIENT_ENCODE_INFO) - -class _CMSG_ENVELOPED_ENCODE_INFO(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("hCryptProv", HCRYPTPROV_LEGACY), - ("ContentEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), - ("pvEncryptionAuxInfo", PVOID), - ("cRecipients", DWORD), - ("rgpRecipients", POINTER(PCERT_INFO)), - ("rgCmsRecipients", PCMSG_RECIPIENT_ENCODE_INFO), - ("cCertEncoded", DWORD), - ("rgCertEncoded", PCERT_BLOB), - ("cCrlEncoded", DWORD), - ("rgCrlEncoded", PCRL_BLOB), - ("cAttrCertEncoded", DWORD), - ("rgAttrCertEncoded", PCERT_BLOB), - ("cUnprotectedAttr", DWORD), - ("rgUnprotectedAttr", PCRYPT_ATTRIBUTE), - ] -PCMSG_ENVELOPED_ENCODE_INFO = POINTER(_CMSG_ENVELOPED_ENCODE_INFO) -CMSG_ENVELOPED_ENCODE_INFO = _CMSG_ENVELOPED_ENCODE_INFO - -class _CMSG_STREAM_INFO(Structure): - _fields_ = [ - ("cbContent", DWORD), - ("pfnStreamOutput", PVOID), - ("pvArg", PVOID), - ] -CMSG_STREAM_INFO = _CMSG_STREAM_INFO -PCMSG_STREAM_INFO = POINTER(_CMSG_STREAM_INFO) - -class _TMPUNION_CMSG_CTRL_DECRYPT_PARA(Union): - _fields_ = [ - ("hCryptProv", HCRYPTPROV), - ("hNCryptKey", NCRYPT_KEY_HANDLE), - ] -TMPUNION_CMSG_CTRL_DECRYPT_PARA = _TMPUNION_CMSG_CTRL_DECRYPT_PARA - -class _CMSG_CTRL_DECRYPT_PARA(Structure): - _fields_ = [ - ("cbSize", DWORD), - ("DUMMYUNIONNAME", TMPUNION_CMSG_CTRL_DECRYPT_PARA), - ("dwKeySpec", DWORD), - ("dwRecipientIndex", DWORD), - ] -PCMSG_CTRL_DECRYPT_PARA = POINTER(_CMSG_CTRL_DECRYPT_PARA) -CMSG_CTRL_DECRYPT_PARA = _CMSG_CTRL_DECRYPT_PARA - -TASK_ACTION_EXEC = EnumValue("_TASK_ACTION_TYPE", "TASK_ACTION_EXEC", 0x0) -TASK_ACTION_COM_HANDLER = EnumValue("_TASK_ACTION_TYPE", "TASK_ACTION_COM_HANDLER", 0x5) -TASK_ACTION_SEND_EMAIL = EnumValue("_TASK_ACTION_TYPE", "TASK_ACTION_SEND_EMAIL", 0x6) -TASK_ACTION_SHOW_MESSAGE = EnumValue("_TASK_ACTION_TYPE", "TASK_ACTION_SHOW_MESSAGE", 0x7) -class _TASK_ACTION_TYPE(EnumType): - values = [TASK_ACTION_EXEC, TASK_ACTION_COM_HANDLER, TASK_ACTION_SEND_EMAIL, TASK_ACTION_SHOW_MESSAGE] - mapper = FlagMapper(*values) -TASK_ACTION_TYPE = _TASK_ACTION_TYPE - - -TASK_RUNLEVEL_LUA = EnumValue("_TASK_RUNLEVEL_TYPE", "TASK_RUNLEVEL_LUA", 0x0) -TASK_RUNLEVEL_HIGHEST = EnumValue("_TASK_RUNLEVEL_TYPE", "TASK_RUNLEVEL_HIGHEST", 0x1) -class _TASK_RUNLEVEL_TYPE(EnumType): - values = [TASK_RUNLEVEL_LUA, TASK_RUNLEVEL_HIGHEST] - mapper = FlagMapper(*values) -TASK_RUNLEVEL_TYPE = _TASK_RUNLEVEL_TYPE - - -TASK_LOGON_NONE = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_NONE", 0x0) -TASK_LOGON_PASSWORD = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_PASSWORD", 0x1) -TASK_LOGON_S4U = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_S4U", 0x2) -TASK_LOGON_INTERACTIVE_TOKEN = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_INTERACTIVE_TOKEN", 0x3) -TASK_LOGON_GROUP = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_GROUP", 0x4) -TASK_LOGON_SERVICE_ACCOUNT = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_SERVICE_ACCOUNT", 0x5) -TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD = EnumValue("_TASK_LOGON_TYPE", "TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD", 0x6) -class _TASK_LOGON_TYPE(EnumType): - values = [TASK_LOGON_NONE, TASK_LOGON_PASSWORD, TASK_LOGON_S4U, TASK_LOGON_INTERACTIVE_TOKEN, TASK_LOGON_GROUP, TASK_LOGON_SERVICE_ACCOUNT, TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD] - mapper = FlagMapper(*values) -TASK_LOGON_TYPE = _TASK_LOGON_TYPE - - -TASK_STATE_UNKNOWN = EnumValue("_TASK_STATE", "TASK_STATE_UNKNOWN", 0x0) -TASK_STATE_DISABLED = EnumValue("_TASK_STATE", "TASK_STATE_DISABLED", 0x1) -TASK_STATE_QUEUED = EnumValue("_TASK_STATE", "TASK_STATE_QUEUED", 0x2) -TASK_STATE_READY = EnumValue("_TASK_STATE", "TASK_STATE_READY", 0x3) -TASK_STATE_RUNNING = EnumValue("_TASK_STATE", "TASK_STATE_RUNNING", 0x4) -class _TASK_STATE(EnumType): - values = [TASK_STATE_UNKNOWN, TASK_STATE_DISABLED, TASK_STATE_QUEUED, TASK_STATE_READY, TASK_STATE_RUNNING] - mapper = FlagMapper(*values) -TASK_STATE = _TASK_STATE - - -TASK_INSTANCES_PARALLEL = EnumValue("_TASK_INSTANCES_POLICY", "TASK_INSTANCES_PARALLEL", 0x0) -TASK_INSTANCES_QUEUE = EnumValue("_TASK_INSTANCES_POLICY", "TASK_INSTANCES_QUEUE", 0x1) -TASK_INSTANCES_IGNORE_NEW = EnumValue("_TASK_INSTANCES_POLICY", "TASK_INSTANCES_IGNORE_NEW", 0x2) -TASK_INSTANCES_STOP_EXISTING = EnumValue("_TASK_INSTANCES_POLICY", "TASK_INSTANCES_STOP_EXISTING", 0x3) -class _TASK_INSTANCES_POLICY(EnumType): - values = [TASK_INSTANCES_PARALLEL, TASK_INSTANCES_QUEUE, TASK_INSTANCES_IGNORE_NEW, TASK_INSTANCES_STOP_EXISTING] - mapper = FlagMapper(*values) -TASK_INSTANCES_POLICY = _TASK_INSTANCES_POLICY - - -TASK_COMPATIBILITY_AT = EnumValue("_TASK_COMPATIBILITY", "TASK_COMPATIBILITY_AT", 0x0) -TASK_COMPATIBILITY_V1 = EnumValue("_TASK_COMPATIBILITY", "TASK_COMPATIBILITY_V1", 0x1) -TASK_COMPATIBILITY_V2 = EnumValue("_TASK_COMPATIBILITY", "TASK_COMPATIBILITY_V2", 0x2) -class _TASK_COMPATIBILITY(EnumType): - values = [TASK_COMPATIBILITY_AT, TASK_COMPATIBILITY_V1, TASK_COMPATIBILITY_V2] - mapper = FlagMapper(*values) -TASK_COMPATIBILITY = _TASK_COMPATIBILITY - - -TASK_TRIGGER_EVENT = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_EVENT", 0x0) -TASK_TRIGGER_TIME = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_TIME", 0x1) -TASK_TRIGGER_DAILY = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_DAILY", 0x2) -TASK_TRIGGER_WEEKLY = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_WEEKLY", 0x3) -TASK_TRIGGER_MONTHLY = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_MONTHLY", 0x4) -TASK_TRIGGER_MONTHLYDOW = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_MONTHLYDOW", 0x5) -TASK_TRIGGER_IDLE = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_IDLE", 0x6) -TASK_TRIGGER_REGISTRATION = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_REGISTRATION", 0x7) -TASK_TRIGGER_BOOT = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_BOOT", 0x8) -TASK_TRIGGER_LOGON = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_LOGON", 0x9) -TASK_TRIGGER_SESSION_STATE_CHANGE = EnumValue("_TASK_TRIGGER_TYPE2", "TASK_TRIGGER_SESSION_STATE_CHANGE", 0xb) -class _TASK_TRIGGER_TYPE2(EnumType): - values = [TASK_TRIGGER_EVENT, TASK_TRIGGER_TIME, TASK_TRIGGER_DAILY, TASK_TRIGGER_WEEKLY, TASK_TRIGGER_MONTHLY, TASK_TRIGGER_MONTHLYDOW, TASK_TRIGGER_IDLE, TASK_TRIGGER_REGISTRATION, TASK_TRIGGER_BOOT, TASK_TRIGGER_LOGON, TASK_TRIGGER_SESSION_STATE_CHANGE] - mapper = FlagMapper(*values) -TASK_TRIGGER_TYPE2 = _TASK_TRIGGER_TYPE2 - - -TASK_ENUM_HIDDEN = EnumValue("_TASK_ENUM_FLAGS", "TASK_ENUM_HIDDEN", 0x1) -class _TASK_ENUM_FLAGS(EnumType): - values = [TASK_ENUM_HIDDEN] - mapper = FlagMapper(*values) -TASK_ENUM_FLAGS = _TASK_ENUM_FLAGS - - -TASK_VALIDATE_ONLY = EnumValue("_TASK_CREATION", "TASK_VALIDATE_ONLY", 0x1) -TASK_CREATE = EnumValue("_TASK_CREATION", "TASK_CREATE", 0x2) -TASK_UPDATE = EnumValue("_TASK_CREATION", "TASK_UPDATE", 0x4) -TASK_CREATE_OR_UPDATE = EnumValue("_TASK_CREATION", "TASK_CREATE_OR_UPDATE", 0x6) -TASK_DISABLE = EnumValue("_TASK_CREATION", "TASK_DISABLE", 0x8) -TASK_DONT_ADD_PRINCIPAL_ACE = EnumValue("_TASK_CREATION", "TASK_DONT_ADD_PRINCIPAL_ACE", 0x10) -TASK_IGNORE_REGISTRATION_TRIGGERS = EnumValue("_TASK_CREATION", "TASK_IGNORE_REGISTRATION_TRIGGERS", 0x20) -class _TASK_CREATION(EnumType): - values = [TASK_VALIDATE_ONLY, TASK_CREATE, TASK_UPDATE, TASK_CREATE_OR_UPDATE, TASK_DISABLE, TASK_DONT_ADD_PRINCIPAL_ACE, TASK_IGNORE_REGISTRATION_TRIGGERS] - mapper = FlagMapper(*values) -TASK_CREATION = _TASK_CREATION - - -TASK_RUN_NO_FLAGS = EnumValue("TASK_RUN_FLAGS", "TASK_RUN_NO_FLAGS", 0x0) -TASK_RUN_AS_SELF = EnumValue("TASK_RUN_FLAGS", "TASK_RUN_AS_SELF", 0x1) -TASK_RUN_IGNORE_CONSTRAINTS = EnumValue("TASK_RUN_FLAGS", "TASK_RUN_IGNORE_CONSTRAINTS", 0x2) -TASK_RUN_USE_SESSION_ID = EnumValue("TASK_RUN_FLAGS", "TASK_RUN_USE_SESSION_ID", 0x4) -TASK_RUN_USER_SID = EnumValue("TASK_RUN_FLAGS", "TASK_RUN_USER_SID", 0x8) -class TASK_RUN_FLAGS(EnumType): - values = [TASK_RUN_NO_FLAGS, TASK_RUN_AS_SELF, TASK_RUN_IGNORE_CONSTRAINTS, TASK_RUN_USE_SESSION_ID, TASK_RUN_USER_SID] - mapper = FlagMapper(*values) - - -class tagRGBTRIPLE(Structure): - _fields_ = [ - ("rgbtBlue", BYTE), - ("rgbtGreen", BYTE), - ("rgbtRed", BYTE), - ] -NPRGBTRIPLE = POINTER(tagRGBTRIPLE) -LPRGBTRIPLE = POINTER(tagRGBTRIPLE) -RGBTRIPLE = tagRGBTRIPLE -PRGBTRIPLE = POINTER(tagRGBTRIPLE) - -class tagBITMAPFILEHEADER(Structure): - _pack_ = 2 - _fields_ = [ - ("bfType", WORD), - ("bfSize", DWORD), - ("bfReserved1", WORD), - ("bfReserved2", WORD), - ("bfOffBits", DWORD), - ] -BITMAPFILEHEADER = tagBITMAPFILEHEADER -PBITMAPFILEHEADER = POINTER(tagBITMAPFILEHEADER) -LPBITMAPFILEHEADER = POINTER(tagBITMAPFILEHEADER) - -class tagBITMAPCOREHEADER(Structure): - _fields_ = [ - ("bcSize", DWORD), - ("bcWidth", WORD), - ("bcHeight", WORD), - ("bcPlanes", WORD), - ("bcBitCount", WORD), - ] -LPBITMAPCOREHEADER = POINTER(tagBITMAPCOREHEADER) -PBITMAPCOREHEADER = POINTER(tagBITMAPCOREHEADER) -BITMAPCOREHEADER = tagBITMAPCOREHEADER - -class tagBITMAP(Structure): - _fields_ = [ - ("bmType", LONG), - ("bmWidth", LONG), - ("bmHeight", LONG), - ("bmWidthBytes", LONG), - ("bmPlanes", WORD), - ("bmBitsPixel", WORD), - ("bmBits", LPVOID), - ] -NPBITMAP = POINTER(tagBITMAP) -LPBITMAP = POINTER(tagBITMAP) -PBITMAP = POINTER(tagBITMAP) -BITMAP = tagBITMAP - -class tagBITMAPINFOHEADER(Structure): - _fields_ = [ - ("biSize", DWORD), - ("biWidth", LONG), - ("biHeight", LONG), - ("biPlanes", WORD), - ("biBitCount", WORD), - ("biCompression", DWORD), - ("biSizeImage", DWORD), - ("biXPelsPerMeter", LONG), - ("biYPelsPerMeter", LONG), - ("biClrUsed", DWORD), - ("biClrImportant", DWORD), - ] -BITMAPINFOHEADER = tagBITMAPINFOHEADER -PBITMAPINFOHEADER = POINTER(tagBITMAPINFOHEADER) -LPBITMAPINFOHEADER = POINTER(tagBITMAPINFOHEADER) - -class tagRGBQUAD(Structure): - _fields_ = [ - ("rgbBlue", BYTE), - ("rgbGreen", BYTE), - ("rgbRed", BYTE), - ("rgbReserved", BYTE), - ] -RGBQUAD = tagRGBQUAD - -class tagBITMAPINFO(Structure): - _fields_ = [ - ("bmiHeader", BITMAPINFOHEADER), - ("bmiColors", RGBQUAD * 1), - ] -LPBITMAPINFO = POINTER(tagBITMAPINFO) -PBITMAPINFO = POINTER(tagBITMAPINFO) -BITMAPINFO = tagBITMAPINFO - -class tagBITMAPCOREINFO(Structure): - _fields_ = [ - ("bmciHeader", BITMAPCOREHEADER), - ("bmciColors", RGBTRIPLE * 1), - ] -LPBITMAPCOREINFO = POINTER(tagBITMAPCOREINFO) -BITMAPCOREINFO = tagBITMAPCOREINFO -PBITMAPCOREINFO = POINTER(tagBITMAPCOREINFO) - -class tagWNDCLASSEXA(Structure): - _fields_ = [ - ("cbSize", UINT), - ("style", UINT), - ("lpfnWndProc", WNDPROC), - ("cbClsExtra", INT), - ("cbWndExtra", INT), - ("hInstance", HINSTANCE), - ("hIcon", HICON), - ("hCursor", HCURSOR), - ("hbrBackground", HBRUSH), - ("lpszMenuName", LPCSTR), - ("lpszClassName", LPCSTR), - ("hIconSm", HICON), - ] -PWNDCLASSEXA = POINTER(tagWNDCLASSEXA) -LPWNDCLASSEXA = POINTER(tagWNDCLASSEXA) -WNDCLASSEXA = tagWNDCLASSEXA - -class tagWNDCLASSEXW(Structure): - _fields_ = [ - ("cbSize", UINT), - ("style", UINT), - ("lpfnWndProc", WNDPROC), - ("cbClsExtra", INT), - ("cbWndExtra", INT), - ("hInstance", HINSTANCE), - ("hIcon", HICON), - ("hCursor", HCURSOR), - ("hbrBackground", HBRUSH), - ("lpszMenuName", LPWSTR), - ("lpszClassName", LPWSTR), - ("hIconSm", HICON), - ] -WNDCLASSEXW = tagWNDCLASSEXW -LPWNDCLASSEXW = POINTER(tagWNDCLASSEXW) -PWNDCLASSEXW = POINTER(tagWNDCLASSEXW) - -AclRevisionInformation = EnumValue("_ACL_INFORMATION_CLASS", "AclRevisionInformation", 0x1) -AclSizeInformation = EnumValue("_ACL_INFORMATION_CLASS", "AclSizeInformation", 0x2) -class _ACL_INFORMATION_CLASS(EnumType): - values = [AclRevisionInformation, AclSizeInformation] - mapper = FlagMapper(*values) -ACL_INFORMATION_CLASS = _ACL_INFORMATION_CLASS - - -class _ACL(Structure): - _fields_ = [ - ("AclRevision", BYTE), - ("Sbz1", BYTE), - ("AclSize", WORD), - ("AceCount", WORD), - ("Sbz2", WORD), - ] -PACL = POINTER(_ACL) -ACL = _ACL - -class _ACL_REVISION_INFORMATION(Structure): - _fields_ = [ - ("AclRevision", DWORD), - ] -PACL_REVISION_INFORMATION = POINTER(_ACL_REVISION_INFORMATION) -ACL_REVISION_INFORMATION = _ACL_REVISION_INFORMATION - -class _ACL_SIZE_INFORMATION(Structure): - _fields_ = [ - ("AceCount", DWORD), - ("AclBytesInUse", DWORD), - ("AclBytesFree", DWORD), - ] -PACL_SIZE_INFORMATION = POINTER(_ACL_SIZE_INFORMATION) -ACL_SIZE_INFORMATION = _ACL_SIZE_INFORMATION - -class _ACE_HEADER(Structure): - _fields_ = [ - ("AceType", BYTE), - ("AceFlags", BYTE), - ("AceSize", WORD), - ] -PACE_HEADER = POINTER(_ACE_HEADER) -ACE_HEADER = _ACE_HEADER - -class _ACCESS_ALLOWED_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -PACCESS_ALLOWED_ACE = POINTER(_ACCESS_ALLOWED_ACE) -ACCESS_ALLOWED_ACE = _ACCESS_ALLOWED_ACE - -class _ACCESS_ALLOWED_CALLBACK_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -PACCESS_ALLOWED_CALLBACK_ACE = POINTER(_ACCESS_ALLOWED_CALLBACK_ACE) -ACCESS_ALLOWED_CALLBACK_ACE = _ACCESS_ALLOWED_CALLBACK_ACE - -class _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("Flags", DWORD), - ("ObjectType", GUID), - ("InheritedObjectType", GUID), - ("SidStart", DWORD), - ] -PACCESS_ALLOWED_CALLBACK_OBJECT_ACE = POINTER(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE) -ACCESS_ALLOWED_CALLBACK_OBJECT_ACE = _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE - -class _ACCESS_DENIED_CALLBACK_OBJECT_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("Flags", DWORD), - ("ObjectType", GUID), - ("InheritedObjectType", GUID), - ("SidStart", DWORD), - ] -ACCESS_DENIED_CALLBACK_OBJECT_ACE = _ACCESS_DENIED_CALLBACK_OBJECT_ACE -PACCESS_DENIED_CALLBACK_OBJECT_ACE = POINTER(_ACCESS_DENIED_CALLBACK_OBJECT_ACE) - -class _ACCESS_ALLOWED_OBJECT_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("Flags", DWORD), - ("ObjectType", GUID), - ("InheritedObjectType", GUID), - ("SidStart", DWORD), - ] -PACCESS_ALLOWED_OBJECT_ACE = POINTER(_ACCESS_ALLOWED_OBJECT_ACE) -ACCESS_ALLOWED_OBJECT_ACE = _ACCESS_ALLOWED_OBJECT_ACE - -class _ACCESS_DENIED_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -ACCESS_DENIED_ACE = _ACCESS_DENIED_ACE -PACCESS_DENIED_ACE = POINTER(_ACCESS_DENIED_ACE) - -class _ACCESS_DENIED_CALLBACK_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -ACCESS_DENIED_CALLBACK_ACE = _ACCESS_DENIED_CALLBACK_ACE -PACCESS_DENIED_CALLBACK_ACE = POINTER(_ACCESS_DENIED_CALLBACK_ACE) - -class _ACCESS_DENIED_OBJECT_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("Flags", DWORD), - ("ObjectType", GUID), - ("InheritedObjectType", GUID), - ("SidStart", DWORD), - ] -ACCESS_DENIED_OBJECT_ACE = _ACCESS_DENIED_OBJECT_ACE -PACCESS_DENIED_OBJECT_ACE = POINTER(_ACCESS_DENIED_OBJECT_ACE) - -class _SYSTEM_MANDATORY_LABEL_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -SYSTEM_MANDATORY_LABEL_ACE = _SYSTEM_MANDATORY_LABEL_ACE -PSYSTEM_MANDATORY_LABEL_ACE = POINTER(_SYSTEM_MANDATORY_LABEL_ACE) - -class _SYSTEM_AUDIT_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -SYSTEM_AUDIT_ACE = _SYSTEM_AUDIT_ACE - -class _SYSTEM_ALARM_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -SYSTEM_ALARM_ACE = _SYSTEM_ALARM_ACE - -class _SYSTEM_RESOURCE_ATTRIBUTE_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -PSYSTEM_RESOURCE_ATTRIBUTE_ACE = POINTER(_SYSTEM_RESOURCE_ATTRIBUTE_ACE) -SYSTEM_RESOURCE_ATTRIBUTE_ACE = _SYSTEM_RESOURCE_ATTRIBUTE_ACE - -class _SYSTEM_SCOPED_POLICY_ID_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -SYSTEM_SCOPED_POLICY_ID_ACE = _SYSTEM_SCOPED_POLICY_ID_ACE -PSYSTEM_SCOPED_POLICY_ID_ACE = POINTER(_SYSTEM_SCOPED_POLICY_ID_ACE) - -class _SYSTEM_PROCESS_TRUST_LABEL_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -PSYSTEM_PROCESS_TRUST_LABEL_ACE = POINTER(_SYSTEM_PROCESS_TRUST_LABEL_ACE) -SYSTEM_PROCESS_TRUST_LABEL_ACE = _SYSTEM_PROCESS_TRUST_LABEL_ACE - -class _SYSTEM_AUDIT_OBJECT_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("Flags", DWORD), - ("ObjectType", GUID), - ("InheritedObjectType", GUID), - ("SidStart", DWORD), - ] -SYSTEM_AUDIT_OBJECT_ACE = _SYSTEM_AUDIT_OBJECT_ACE -PSYSTEM_AUDIT_OBJECT_ACE = POINTER(_SYSTEM_AUDIT_OBJECT_ACE) - -class _SYSTEM_ALARM_OBJECT_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("Flags", DWORD), - ("ObjectType", GUID), - ("InheritedObjectType", GUID), - ("SidStart", DWORD), - ] -SYSTEM_ALARM_OBJECT_ACE = _SYSTEM_ALARM_OBJECT_ACE -PSYSTEM_ALARM_OBJECT_ACE = POINTER(_SYSTEM_ALARM_OBJECT_ACE) - -class _SYSTEM_AUDIT_CALLBACK_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -PSYSTEM_AUDIT_CALLBACK_ACE = POINTER(_SYSTEM_AUDIT_CALLBACK_ACE) -SYSTEM_AUDIT_CALLBACK_ACE = _SYSTEM_AUDIT_CALLBACK_ACE - -class _SYSTEM_ALARM_CALLBACK_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("SidStart", DWORD), - ] -SYSTEM_ALARM_CALLBACK_ACE = _SYSTEM_ALARM_CALLBACK_ACE -PSYSTEM_ALARM_CALLBACK_ACE = POINTER(_SYSTEM_ALARM_CALLBACK_ACE) - -class _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("Flags", DWORD), - ("ObjectType", GUID), - ("InheritedObjectType", GUID), - ("SidStart", DWORD), - ] -PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE = POINTER(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE) -SYSTEM_AUDIT_CALLBACK_OBJECT_ACE = _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE - -class _SYSTEM_ALARM_CALLBACK_OBJECT_ACE(Structure): - _fields_ = [ - ("Header", ACE_HEADER), - ("Mask", ACCESS_MASK), - ("Flags", DWORD), - ("ObjectType", GUID), - ("InheritedObjectType", GUID), - ("SidStart", DWORD), - ] -PSYSTEM_ALARM_CALLBACK_OBJECT_ACE = POINTER(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE) -SYSTEM_ALARM_CALLBACK_OBJECT_ACE = _SYSTEM_ALARM_CALLBACK_OBJECT_ACE - -class _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION(Union): - _fields_ = [ - ("pInt64", DWORD * ANYSIZE_ARRAY), - ("pUint64", DWORD * ANYSIZE_ARRAY), - ("ppString", DWORD * ANYSIZE_ARRAY), - ("pFqbn", DWORD * ANYSIZE_ARRAY), - ("pOctetString", DWORD * ANYSIZE_ARRAY), - ] -CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION = _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION - -class _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1(Structure): - _fields_ = [ - ("Name", DWORD), - ("ValueType", WORD), - ("Reserved", WORD), - ("Flags", DWORD), - ("ValueCount", DWORD), - ("Values", CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION), - ] -PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 = POINTER(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1) -CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 = _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 - -class _CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE(Structure): - _fields_ = [ - ("Version", DWORD64), - ("Name", PWSTR), - ] -PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE = POINTER(_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE) -CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE = _CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE - -class _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE(Structure): - _fields_ = [ - ("pValue", PVOID), - ("ValueLength", DWORD), - ] -PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = POINTER(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE) -CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE - -class _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE(Structure): - _fields_ = [ - ("Length", DWORD), - ("OctetString", BYTE * ANYSIZE_ARRAY), - ] -PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE = POINTER(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE) -CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE = _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE - -class _CLAIM_SECURITY_ATTRIBUTE_V1_UNION(Union): - _fields_ = [ - ("pInt64", PLONG64), - ("pUint64", PDWORD64), - ("ppString", POINTER(PWSTR)), - ("pFqbn", PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE), - ("pOctetString", PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE), - ] -CLAIM_SECURITY_ATTRIBUTE_V1_UNION = _CLAIM_SECURITY_ATTRIBUTE_V1_UNION - -class _CLAIM_SECURITY_ATTRIBUTE_V1(Structure): - _fields_ = [ - ("Name", PWSTR), - ("ValueType", WORD), - ("Reserved", WORD), - ("Flags", DWORD), - ("ValueCount", DWORD), - ("Values", CLAIM_SECURITY_ATTRIBUTE_V1_UNION), - ] -CLAIM_SECURITY_ATTRIBUTE_V1 = _CLAIM_SECURITY_ATTRIBUTE_V1 -PCLAIM_SECURITY_ATTRIBUTE_V1 = POINTER(_CLAIM_SECURITY_ATTRIBUTE_V1) - -class _CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION(Union): - _fields_ = [ - ("pAttributeV1", PCLAIM_SECURITY_ATTRIBUTE_V1), - ] -CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION = _CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION - -class _CLAIM_SECURITY_ATTRIBUTES_INFORMATION(Structure): - _fields_ = [ - ("Version", WORD), - ("Reserved", WORD), - ("AttributeCount", DWORD), - ("Attribute", CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION), - ] -CLAIM_SECURITY_ATTRIBUTES_INFORMATION = _CLAIM_SECURITY_ATTRIBUTES_INFORMATION -PCLAIM_SECURITY_ATTRIBUTES_INFORMATION = POINTER(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION) - -class _SECURITY_DESCRIPTOR(Structure): - _fields_ = [ - ("Revision", BYTE), - ("Sbz1", BYTE), - ("Control", SECURITY_DESCRIPTOR_CONTROL), - ("Owner", PSID), - ("Group", PSID), - ("Sacl", PACL), - ("Dacl", PACL), - ] -PISECURITY_DESCRIPTOR = POINTER(_SECURITY_DESCRIPTOR) -SECURITY_DESCRIPTOR = _SECURITY_DESCRIPTOR - -BG_JOB_STATE_QUEUED = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_QUEUED", 0x0) -BG_JOB_STATE_CONNECTING = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_CONNECTING", 0x1) -BG_JOB_STATE_TRANSFERRING = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_TRANSFERRING", 0x2) -BG_JOB_STATE_SUSPENDED = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_SUSPENDED", 0x3) -BG_JOB_STATE_ERROR = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_ERROR", 0x4) -BG_JOB_STATE_TRANSIENT_ERROR = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_TRANSIENT_ERROR", 0x5) -BG_JOB_STATE_TRANSFERRED = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_TRANSFERRED", 0x6) -BG_JOB_STATE_ACKNOWLEDGED = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_ACKNOWLEDGED", 0x7) -BG_JOB_STATE_CANCELLED = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_CANCELLED", 0x8) -class _BG_JOB_STATE(EnumType): - values = [BG_JOB_STATE_QUEUED, BG_JOB_STATE_CONNECTING, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_SUSPENDED, BG_JOB_STATE_ERROR, BG_JOB_STATE_TRANSIENT_ERROR, BG_JOB_STATE_TRANSFERRED, BG_JOB_STATE_ACKNOWLEDGED, BG_JOB_STATE_CANCELLED] - mapper = FlagMapper(*values) -BG_JOB_STATE = _BG_JOB_STATE - - -BG_JOB_PROXY_USAGE_PRECONFIG = EnumValue("_BG_JOB_PROXY_USAGE", "BG_JOB_PROXY_USAGE_PRECONFIG", 0x0) -BG_JOB_PROXY_USAGE_NO_PROXY = EnumValue("_BG_JOB_PROXY_USAGE", "BG_JOB_PROXY_USAGE_NO_PROXY", 0x1) -BG_JOB_PROXY_USAGE_OVERRIDE = EnumValue("_BG_JOB_PROXY_USAGE", "BG_JOB_PROXY_USAGE_OVERRIDE", 0x2) -BG_JOB_PROXY_USAGE_AUTODETECT = EnumValue("_BG_JOB_PROXY_USAGE", "BG_JOB_PROXY_USAGE_AUTODETECT", 0x3) -class _BG_JOB_PROXY_USAGE(EnumType): - values = [BG_JOB_PROXY_USAGE_PRECONFIG, BG_JOB_PROXY_USAGE_NO_PROXY, BG_JOB_PROXY_USAGE_OVERRIDE, BG_JOB_PROXY_USAGE_AUTODETECT] - mapper = FlagMapper(*values) -BG_JOB_PROXY_USAGE = _BG_JOB_PROXY_USAGE - - -BG_JOB_PRIORITY_FOREGROUND = EnumValue("_BG_JOB_PRIORITY", "BG_JOB_PRIORITY_FOREGROUND", 0x0) -BG_JOB_PRIORITY_HIGH = EnumValue("_BG_JOB_PRIORITY", "BG_JOB_PRIORITY_HIGH", 0x1) -BG_JOB_PRIORITY_NORMAL = EnumValue("_BG_JOB_PRIORITY", "BG_JOB_PRIORITY_NORMAL", 0x2) -BG_JOB_PRIORITY_LOW = EnumValue("_BG_JOB_PRIORITY", "BG_JOB_PRIORITY_LOW", 0x3) -class _BG_JOB_PRIORITY(EnumType): - values = [BG_JOB_PRIORITY_FOREGROUND, BG_JOB_PRIORITY_HIGH, BG_JOB_PRIORITY_NORMAL, BG_JOB_PRIORITY_LOW] - mapper = FlagMapper(*values) -BG_JOB_PRIORITY = _BG_JOB_PRIORITY - - -BG_ERROR_CONTEXT_NONE = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_NONE", 0x0) -BG_ERROR_CONTEXT_UNKNOWN = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_UNKNOWN", 0x1) -BG_ERROR_CONTEXT_GENERAL_QUEUE_MANAGER = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_GENERAL_QUEUE_MANAGER", 0x2) -BG_ERROR_CONTEXT_QUEUE_MANAGER_NOTIFICATION = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_QUEUE_MANAGER_NOTIFICATION", 0x3) -BG_ERROR_CONTEXT_LOCAL_FILE = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_LOCAL_FILE", 0x4) -BG_ERROR_CONTEXT_REMOTE_FILE = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_REMOTE_FILE", 0x5) -BG_ERROR_CONTEXT_GENERAL_TRANSPORT = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_GENERAL_TRANSPORT", 0x6) -BG_ERROR_CONTEXT_REMOTE_APPLICATION = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_REMOTE_APPLICATION", 0x7) -class _BG_ERROR_CONTEXT(EnumType): - values = [BG_ERROR_CONTEXT_NONE, BG_ERROR_CONTEXT_UNKNOWN, BG_ERROR_CONTEXT_GENERAL_QUEUE_MANAGER, BG_ERROR_CONTEXT_QUEUE_MANAGER_NOTIFICATION, BG_ERROR_CONTEXT_LOCAL_FILE, BG_ERROR_CONTEXT_REMOTE_FILE, BG_ERROR_CONTEXT_GENERAL_TRANSPORT, BG_ERROR_CONTEXT_REMOTE_APPLICATION] - mapper = FlagMapper(*values) -BG_ERROR_CONTEXT = _BG_ERROR_CONTEXT - - -BG_JOB_TYPE_DOWNLOAD = EnumValue("_BG_JOB_TYPE", "BG_JOB_TYPE_DOWNLOAD", 0x0) -BG_JOB_TYPE_UPLOAD = EnumValue("_BG_JOB_TYPE", "BG_JOB_TYPE_UPLOAD", 0x1) -BG_JOB_TYPE_UPLOAD_REPLY = EnumValue("_BG_JOB_TYPE", "BG_JOB_TYPE_UPLOAD_REPLY", 0x2) -class _BG_JOB_TYPE(EnumType): - values = [BG_JOB_TYPE_DOWNLOAD, BG_JOB_TYPE_UPLOAD, BG_JOB_TYPE_UPLOAD_REPLY] - mapper = FlagMapper(*values) -BG_JOB_TYPE = _BG_JOB_TYPE - - -class _BG_FILE_PROGRESS(Structure): - _fields_ = [ - ("BytesTotal", UINT64), - ("BytesTransferred", UINT64), - ("Completed", BOOL), - ] -BG_FILE_PROGRESS = _BG_FILE_PROGRESS - -class _BG_JOB_PROGRESS(Structure): - _fields_ = [ - ("BytesTotal", UINT64), - ("BytesTransferred", UINT64), - ("FilesTotal", ULONG), - ("FilesTransferred", ULONG), - ] -BG_JOB_PROGRESS = _BG_JOB_PROGRESS - -class _BG_FILE_INFO(Structure): - _fields_ = [ - ("RemoteName", LPWSTR), - ("LocalName", LPWSTR), - ] -BG_FILE_INFO = _BG_FILE_INFO - -class _BG_JOB_TIMES(Structure): - _fields_ = [ - ("CreationTime", FILETIME), - ("ModificationTime", FILETIME), - ("TransferCompletionTime", FILETIME), - ] -BG_JOB_TIMES = _BG_JOB_TIMES - -class _SHITEMID(Structure): - _fields_ = [ - ("cb", USHORT), - ("abID", BYTE * 1), - ] -SHITEMID = _SHITEMID - -class _ITEMIDLIST(Structure): - _fields_ = [ - ("mkid", SHITEMID), - ] -ITEMIDLIST = _ITEMIDLIST -PCIDLIST_ABSOLUTE = POINTER(_ITEMIDLIST) -PIDLIST_ABSOLUTE = POINTER(_ITEMIDLIST) - -ProcessDEPPolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessDEPPolicy", 0x0) -ProcessASLRPolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessASLRPolicy", 0x1) -ProcessDynamicCodePolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessDynamicCodePolicy", 0x2) -ProcessStrictHandleCheckPolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessStrictHandleCheckPolicy", 0x3) -ProcessSystemCallDisablePolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessSystemCallDisablePolicy", 0x4) -ProcessMitigationOptionsMask = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessMitigationOptionsMask", 0x5) -ProcessExtensionPointDisablePolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessExtensionPointDisablePolicy", 0x6) -ProcessReserved1Policy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessReserved1Policy", 0x7) -ProcessSignaturePolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessSignaturePolicy", 0x8) -MaxProcessMitigationPolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "MaxProcessMitigationPolicy", 0x9) -class _PROCESS_MITIGATION_POLICY(EnumType): - values = [ProcessDEPPolicy, ProcessASLRPolicy, ProcessDynamicCodePolicy, ProcessStrictHandleCheckPolicy, ProcessSystemCallDisablePolicy, ProcessMitigationOptionsMask, ProcessExtensionPointDisablePolicy, ProcessReserved1Policy, ProcessSignaturePolicy, MaxProcessMitigationPolicy] - mapper = FlagMapper(*values) -PROCESS_MITIGATION_POLICY = _PROCESS_MITIGATION_POLICY -PPROCESS_MITIGATION_POLICY = POINTER(_PROCESS_MITIGATION_POLICY) - - -class _ANON_PROCESS_MITIGATION_DEP_POLICY_BITFIELD(Structure): - _fields_ = [ - ("Enable", DWORD, 1), - ("DisableAtlThunkEmulation", DWORD, 1), - ("ReservedFlags", DWORD, 30), - ] - - -class _ANON_PROCESS_MITIGATION_DEP_POLICY_UNION(Union): - _anonymous_ = ("anon",) - _fields_ = [ - ("Flags", DWORD), - ("anon", _ANON_PROCESS_MITIGATION_DEP_POLICY_BITFIELD), - ] - - -class _PROCESS_MITIGATION_DEP_POLICY(Structure): - _anonymous_ = ("anon",) - _fields_ = [ - ("anon", _ANON_PROCESS_MITIGATION_DEP_POLICY_UNION), - ("Permanent", BOOLEAN), - ] -PPROCESS_MITIGATION_DEP_POLICY = POINTER(_PROCESS_MITIGATION_DEP_POLICY) -PROCESS_MITIGATION_DEP_POLICY = _PROCESS_MITIGATION_DEP_POLICY - -class _ANON_PROCESS_MITIGATION_ASLR_POLICY_BITFIELD(Structure): - _fields_ = [ - ("EnableBottomUpRandomization", DWORD, 1), - ("EnableForceRelocateImages", DWORD, 1), - ("EnableHighEntropy", DWORD, 1), - ("DisallowStrippedImages", DWORD, 1), - ("ReservedFlags", DWORD, 28), - ] - - -class _ANON_PROCESS_MITIGATION_ASLR_POLICY_UNION(Union): - _anonymous_ = ("anon",) - _fields_ = [ - ("Flags", DWORD), - ("anon", _ANON_PROCESS_MITIGATION_ASLR_POLICY_BITFIELD), - ] - - -class _PROCESS_MITIGATION_ASLR_POLICY(Structure): - _anonymous_ = ("anon",) - _fields_ = [ - ("anon", _ANON_PROCESS_MITIGATION_ASLR_POLICY_UNION), - ] -PPROCESS_MITIGATION_ASLR_POLICY = POINTER(_PROCESS_MITIGATION_ASLR_POLICY) -PROCESS_MITIGATION_ASLR_POLICY = _PROCESS_MITIGATION_ASLR_POLICY - -class _ANON_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_BITFIELD(Structure): - _fields_ = [ - ("ProhibitDynamicCode", DWORD, 1), - ("AllowThreadOptOut", DWORD, 1), - ("AllowRemoteDowngrade", DWORD, 1), - ("ReservedFlags", DWORD, 30), - ] - - -class _ANON_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_UNION(Union): - _anonymous_ = ("anon",) - _fields_ = [ - ("Flags", DWORD), - ("anon", _ANON_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_BITFIELD), - ] - - -class _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY(Structure): - _anonymous_ = ("anon",) - _fields_ = [ - ("anon", _ANON_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_UNION), - ] -PROCESS_MITIGATION_DYNAMIC_CODE_POLICY = _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY -PPROCESS_MITIGATION_DYNAMIC_CODE_POLICY = POINTER(_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY) - -class _ANON_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_BITFIELD(Structure): - _fields_ = [ - ("RaiseExceptionOnInvalidHandleReference", DWORD, 1), - ("HandleExceptionsPermanentlyEnabled", DWORD, 1), - ("ReservedFlags", DWORD, 30), - ] - - -class _ANON_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_UNION(Union): - _anonymous_ = ("ANON_STRUCT",) - _fields_ = [ - ("Flags", DWORD), - ("ANON_STRUCT", _ANON_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_BITFIELD), - ] - - -class _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY(Structure): - _anonymous_ = ("anon",) - _fields_ = [ - ("anon", _ANON_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_UNION), - ] -PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY = _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY -PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY = POINTER(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY) - -class _ANON_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_BITFIELD(Structure): - _fields_ = [ - ("DisallowWin32kSystemCalls", DWORD, 1), - ("ReservedFlags", DWORD, 31), - ] - - -class _ANON_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_UNION(Union): - _anonymous_ = ("ANON_STRUCT",) - _fields_ = [ - ("Flags", DWORD), - ("ANON_STRUCT", _ANON_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_BITFIELD), - ] - - -class _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY(Structure): - _anonymous_ = ("anon",) - _fields_ = [ - ("anon", _ANON_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_UNION), - ] -PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY = POINTER(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY) -PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY = _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY - -class _ANON_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_BITFIELD(Structure): - _fields_ = [ - ("DisableExtensionPoints", DWORD, 1), - ("ReservedFlags", DWORD, 31), - ] - - -class _ANON_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_UNION(Union): - _anonymous_ = ("ANON_STRUCT",) - _fields_ = [ - ("Flags", DWORD), - ("ANON_STRUCT", _ANON_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_BITFIELD), - ] - - -class _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY(Structure): - _anonymous_ = ("anon",) - _fields_ = [ - ("anon", _ANON_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_UNION), - ] -PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY = _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY -PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY = POINTER(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY) - -class _ANON_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_BITFIELD(Structure): - _fields_ = [ - ("EnableControlFlowGuard", DWORD, 1), - ("EnableExportSuppression", DWORD, 1), - ("StrictMode", DWORD, 1), - ("ReservedFlags", DWORD, 29), - ] - - -class _ANON_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_UNION(Union): - _anonymous_ = ("ANON_STRUCT",) - _fields_ = [ - ("Flags", DWORD), - ("ANON_STRUCT", _ANON_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_BITFIELD), - ] - - -class _PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY(Structure): - _anonymous_ = ("anon",) - _fields_ = [ - ("anon", _ANON_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_UNION), - ] -PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY = POINTER(_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY) -PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY = _PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY - -class _ANON_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_BITFIELD(Structure): - _fields_ = [ - ("MicrosoftSignedOnly", DWORD, 1), - ("StoreSignedOnly", DWORD, 1), - ("MitigationOptIn", DWORD, 1), - ("ReservedFlags", DWORD, 29), - ] - - -class _ANON_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_UNION(Union): - _anonymous_ = ("ANON_STRUCT",) - _fields_ = [ - ("Flags", DWORD), - ("ANON_STRUCT", _ANON_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_BITFIELD), - ] - - -class _PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY(Structure): - _anonymous_ = ("anon",) - _fields_ = [ - ("anon", _ANON_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_UNION), - ] -PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY = POINTER(_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY) -PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY = _PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY - -class _ANON_PROCESS_MITIGATION_IMAGE_LOAD_POLICY_BITFIELD(Structure): - _fields_ = [ - ("NoRemoteImages", DWORD, 1), - ("NoLowMandatoryLabelImages", DWORD, 1), - ("PreferSystem32Images", DWORD, 1), - ("ReservedFlags", DWORD, 29), - ] - - -class _ANON_PROCESS_MITIGATION_IMAGE_LOAD_POLICY_UNION(Union): - _anonymous_ = ("ANON_STRUCT",) - _fields_ = [ - ("Flags", DWORD), - ("ANON_STRUCT", _ANON_PROCESS_MITIGATION_IMAGE_LOAD_POLICY_BITFIELD), - ] - - -class _PROCESS_MITIGATION_IMAGE_LOAD_POLICY(Structure): - _anonymous_ = ("anon",) - _fields_ = [ - ("anon", _ANON_PROCESS_MITIGATION_IMAGE_LOAD_POLICY_UNION), - ] -PPROCESS_MITIGATION_IMAGE_LOAD_POLICY = POINTER(_PROCESS_MITIGATION_IMAGE_LOAD_POLICY) -PROCESS_MITIGATION_IMAGE_LOAD_POLICY = _PROCESS_MITIGATION_IMAGE_LOAD_POLICY - -EvtVarTypeNull = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeNull", 0x0) -EvtVarTypeString = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeString", 0x1) -EvtVarTypeAnsiString = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeAnsiString", 0x2) -EvtVarTypeSByte = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeSByte", 0x3) -EvtVarTypeByte = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeByte", 0x4) -EvtVarTypeInt16 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeInt16", 0x5) -EvtVarTypeUInt16 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeUInt16", 0x6) -EvtVarTypeInt32 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeInt32", 0x7) -EvtVarTypeUInt32 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeUInt32", 0x8) -EvtVarTypeInt64 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeInt64", 0x9) -EvtVarTypeUInt64 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeUInt64", 0xa) -EvtVarTypeSingle = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeSingle", 0xb) -EvtVarTypeDouble = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeDouble", 0xc) -EvtVarTypeBoolean = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeBoolean", 0xd) -EvtVarTypeBinary = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeBinary", 0xe) -EvtVarTypeGuid = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeGuid", 0xf) -EvtVarTypeSizeT = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeSizeT", 0x10) -EvtVarTypeFileTime = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeFileTime", 0x11) -EvtVarTypeSysTime = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeSysTime", 0x12) -EvtVarTypeSid = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeSid", 0x13) -EvtVarTypeHexInt32 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeHexInt32", 0x14) -EvtVarTypeHexInt64 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeHexInt64", 0x15) -EvtVarTypeEvtHandle = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeEvtHandle", 0x20) -EvtVarTypeEvtXml = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeEvtXml", 0x23) -class _EVT_VARIANT_TYPE(EnumType): - values = [EvtVarTypeNull, EvtVarTypeString, EvtVarTypeAnsiString, EvtVarTypeSByte, EvtVarTypeByte, EvtVarTypeInt16, EvtVarTypeUInt16, EvtVarTypeInt32, EvtVarTypeUInt32, EvtVarTypeInt64, EvtVarTypeUInt64, EvtVarTypeSingle, EvtVarTypeDouble, EvtVarTypeBoolean, EvtVarTypeBinary, EvtVarTypeGuid, EvtVarTypeSizeT, EvtVarTypeFileTime, EvtVarTypeSysTime, EvtVarTypeSid, EvtVarTypeHexInt32, EvtVarTypeHexInt64, EvtVarTypeEvtHandle, EvtVarTypeEvtXml] - mapper = FlagMapper(*values) -EVT_VARIANT_TYPE = _EVT_VARIANT_TYPE - - -EvtRenderContextValues = EnumValue("_EVT_RENDER_CONTEXT_FLAGS", "EvtRenderContextValues", 0x0) -EvtRenderContextSystem = EnumValue("_EVT_RENDER_CONTEXT_FLAGS", "EvtRenderContextSystem", 0x1) -EvtRenderContextUser = EnumValue("_EVT_RENDER_CONTEXT_FLAGS", "EvtRenderContextUser", 0x2) -class _EVT_RENDER_CONTEXT_FLAGS(EnumType): - values = [EvtRenderContextValues, EvtRenderContextSystem, EvtRenderContextUser] - mapper = FlagMapper(*values) -EVT_RENDER_CONTEXT_FLAGS = _EVT_RENDER_CONTEXT_FLAGS - - -EvtSystemProviderName = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemProviderName", 0x0) -EvtSystemProviderGuid = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemProviderGuid", 0x1) -EvtSystemEventID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemEventID", 0x2) -EvtSystemQualifiers = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemQualifiers", 0x3) -EvtSystemLevel = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemLevel", 0x4) -EvtSystemTask = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemTask", 0x5) -EvtSystemOpcode = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemOpcode", 0x6) -EvtSystemKeywords = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemKeywords", 0x7) -EvtSystemTimeCreated = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemTimeCreated", 0x8) -EvtSystemEventRecordId = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemEventRecordId", 0x9) -EvtSystemActivityID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemActivityID", 0xa) -EvtSystemRelatedActivityID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemRelatedActivityID", 0xb) -EvtSystemProcessID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemProcessID", 0xc) -EvtSystemThreadID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemThreadID", 0xd) -EvtSystemChannel = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemChannel", 0xe) -EvtSystemComputer = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemComputer", 0xf) -EvtSystemUserID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemUserID", 0x10) -EvtSystemVersion = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemVersion", 0x11) -EvtSystemPropertyIdEND = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemPropertyIdEND", 0x12) -class _EVT_SYSTEM_PROPERTY_ID(EnumType): - values = [EvtSystemProviderName, EvtSystemProviderGuid, EvtSystemEventID, EvtSystemQualifiers, EvtSystemLevel, EvtSystemTask, EvtSystemOpcode, EvtSystemKeywords, EvtSystemTimeCreated, EvtSystemEventRecordId, EvtSystemActivityID, EvtSystemRelatedActivityID, EvtSystemProcessID, EvtSystemThreadID, EvtSystemChannel, EvtSystemComputer, EvtSystemUserID, EvtSystemVersion, EvtSystemPropertyIdEND] - mapper = FlagMapper(*values) -EVT_SYSTEM_PROPERTY_ID = _EVT_SYSTEM_PROPERTY_ID - - -EvtRenderEventValues = EnumValue("_EVT_RENDER_FLAGS", "EvtRenderEventValues", 0x0) -EvtRenderEventXml = EnumValue("_EVT_RENDER_FLAGS", "EvtRenderEventXml", 0x1) -EvtRenderBookmark = EnumValue("_EVT_RENDER_FLAGS", "EvtRenderBookmark", 0x2) -class _EVT_RENDER_FLAGS(EnumType): - values = [EvtRenderEventValues, EvtRenderEventXml, EvtRenderBookmark] - mapper = FlagMapper(*values) -EVT_RENDER_FLAGS = _EVT_RENDER_FLAGS - - -EvtQueryChannelPath = EnumValue("_EVT_QUERY_FLAGS", "EvtQueryChannelPath", 0x1) -EvtQueryFilePath = EnumValue("_EVT_QUERY_FLAGS", "EvtQueryFilePath", 0x2) -EvtQueryForwardDirection = EnumValue("_EVT_QUERY_FLAGS", "EvtQueryForwardDirection", 0x100) -EvtQueryReverseDirection = EnumValue("_EVT_QUERY_FLAGS", "EvtQueryReverseDirection", 0x200) -EvtQueryTolerateQueryErrors = EnumValue("_EVT_QUERY_FLAGS", "EvtQueryTolerateQueryErrors", 0x1000) -class _EVT_QUERY_FLAGS(EnumType): - values = [EvtQueryChannelPath, EvtQueryFilePath, EvtQueryForwardDirection, EvtQueryReverseDirection, EvtQueryTolerateQueryErrors] - mapper = FlagMapper(*values) -EVT_QUERY_FLAGS = _EVT_QUERY_FLAGS - - -EvtLogCreationTime = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogCreationTime", 0x0) -EvtLogLastAccessTime = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogLastAccessTime", 0x1) -EvtLogLastWriteTime = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogLastWriteTime", 0x2) -EvtLogFileSize = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogFileSize", 0x3) -EvtLogAttributes = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogAttributes", 0x4) -EvtLogNumberOfLogRecords = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogNumberOfLogRecords", 0x5) -EvtLogOldestRecordNumber = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogOldestRecordNumber", 0x6) -EvtLogFull = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogFull", 0x7) -class _EVT_LOG_PROPERTY_ID(EnumType): - values = [EvtLogCreationTime, EvtLogLastAccessTime, EvtLogLastWriteTime, EvtLogFileSize, EvtLogAttributes, EvtLogNumberOfLogRecords, EvtLogOldestRecordNumber, EvtLogFull] - mapper = FlagMapper(*values) -EVT_LOG_PROPERTY_ID = _EVT_LOG_PROPERTY_ID - - -EvtOpenChannelPath = EnumValue("_EVT_OPEN_LOG_FLAGS", "EvtOpenChannelPath", 0x1) -EvtOpenFilePath = EnumValue("_EVT_OPEN_LOG_FLAGS", "EvtOpenFilePath", 0x2) -class _EVT_OPEN_LOG_FLAGS(EnumType): - values = [EvtOpenChannelPath, EvtOpenFilePath] - mapper = FlagMapper(*values) -EVT_OPEN_LOG_FLAGS = _EVT_OPEN_LOG_FLAGS - - -EvtChannelConfigEnabled = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigEnabled", 0x0) -EvtChannelConfigIsolation = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigIsolation", 0x1) -EvtChannelConfigType = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigType", 0x2) -EvtChannelConfigOwningPublisher = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigOwningPublisher", 0x3) -EvtChannelConfigClassicEventlog = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigClassicEventlog", 0x4) -EvtChannelConfigAccess = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigAccess", 0x5) -EvtChannelLoggingConfigRetention = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelLoggingConfigRetention", 0x6) -EvtChannelLoggingConfigAutoBackup = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelLoggingConfigAutoBackup", 0x7) -EvtChannelLoggingConfigMaxSize = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelLoggingConfigMaxSize", 0x8) -EvtChannelLoggingConfigLogFilePath = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelLoggingConfigLogFilePath", 0x9) -EvtChannelPublishingConfigLevel = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigLevel", 0xa) -EvtChannelPublishingConfigKeywords = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigKeywords", 0xb) -EvtChannelPublishingConfigControlGuid = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigControlGuid", 0xc) -EvtChannelPublishingConfigBufferSize = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigBufferSize", 0xd) -EvtChannelPublishingConfigMinBuffers = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigMinBuffers", 0xe) -EvtChannelPublishingConfigMaxBuffers = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigMaxBuffers", 0xf) -EvtChannelPublishingConfigLatency = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigLatency", 0x10) -EvtChannelPublishingConfigClockType = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigClockType", 0x11) -EvtChannelPublishingConfigSidType = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigSidType", 0x12) -EvtChannelPublisherList = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublisherList", 0x13) -EvtChannelPublishingConfigFileMax = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigFileMax", 0x14) -EvtChannelConfigPropertyIdEND = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigPropertyIdEND", 0x15) -class _EVT_CHANNEL_CONFIG_PROPERTY_ID(EnumType): - values = [EvtChannelConfigEnabled, EvtChannelConfigIsolation, EvtChannelConfigType, EvtChannelConfigOwningPublisher, EvtChannelConfigClassicEventlog, EvtChannelConfigAccess, EvtChannelLoggingConfigRetention, EvtChannelLoggingConfigAutoBackup, EvtChannelLoggingConfigMaxSize, EvtChannelLoggingConfigLogFilePath, EvtChannelPublishingConfigLevel, EvtChannelPublishingConfigKeywords, EvtChannelPublishingConfigControlGuid, EvtChannelPublishingConfigBufferSize, EvtChannelPublishingConfigMinBuffers, EvtChannelPublishingConfigMaxBuffers, EvtChannelPublishingConfigLatency, EvtChannelPublishingConfigClockType, EvtChannelPublishingConfigSidType, EvtChannelPublisherList, EvtChannelPublishingConfigFileMax, EvtChannelConfigPropertyIdEND] - mapper = FlagMapper(*values) -EVT_CHANNEL_CONFIG_PROPERTY_ID = _EVT_CHANNEL_CONFIG_PROPERTY_ID - - -EvtChannelTypeAdmin = EnumValue("_EVT_CHANNEL_TYPE", "EvtChannelTypeAdmin", 0x0) -EvtChannelTypeOperational = EnumValue("_EVT_CHANNEL_TYPE", "EvtChannelTypeOperational", 0x1) -EvtChannelTypeAnalytic = EnumValue("_EVT_CHANNEL_TYPE", "EvtChannelTypeAnalytic", 0x2) -EvtChannelTypeDebug = EnumValue("_EVT_CHANNEL_TYPE", "EvtChannelTypeDebug", 0x3) -class _EVT_CHANNEL_TYPE(EnumType): - values = [EvtChannelTypeAdmin, EvtChannelTypeOperational, EvtChannelTypeAnalytic, EvtChannelTypeDebug] - mapper = FlagMapper(*values) -EVT_CHANNEL_TYPE = _EVT_CHANNEL_TYPE - - -EvtChannelIsolationTypeApplication = EnumValue("_EVT_CHANNEL_ISOLATION_TYPE", "EvtChannelIsolationTypeApplication", 0x0) -EvtChannelIsolationTypeSystem = EnumValue("_EVT_CHANNEL_ISOLATION_TYPE", "EvtChannelIsolationTypeSystem", 0x1) -EvtChannelIsolationTypeCustom = EnumValue("_EVT_CHANNEL_ISOLATION_TYPE", "EvtChannelIsolationTypeCustom", 0x2) -class _EVT_CHANNEL_ISOLATION_TYPE(EnumType): - values = [EvtChannelIsolationTypeApplication, EvtChannelIsolationTypeSystem, EvtChannelIsolationTypeCustom] - mapper = FlagMapper(*values) -EVT_CHANNEL_ISOLATION_TYPE = _EVT_CHANNEL_ISOLATION_TYPE - - -EventMetadataEventID = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventID", 0x0) -EventMetadataEventVersion = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventVersion", 0x1) -EventMetadataEventChannel = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventChannel", 0x2) -EventMetadataEventLevel = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventLevel", 0x3) -EventMetadataEventOpcode = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventOpcode", 0x4) -EventMetadataEventTask = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventTask", 0x5) -EventMetadataEventKeyword = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventKeyword", 0x6) -EventMetadataEventMessageID = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventMessageID", 0x7) -EventMetadataEventTemplate = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventTemplate", 0x8) -EvtEventMetadataPropertyIdEND = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EvtEventMetadataPropertyIdEND", 0x9) -class _EVT_EVENT_METADATA_PROPERTY_ID(EnumType): - values = [EventMetadataEventID, EventMetadataEventVersion, EventMetadataEventChannel, EventMetadataEventLevel, EventMetadataEventOpcode, EventMetadataEventTask, EventMetadataEventKeyword, EventMetadataEventMessageID, EventMetadataEventTemplate, EvtEventMetadataPropertyIdEND] - mapper = FlagMapper(*values) -EVT_EVENT_METADATA_PROPERTY_ID = _EVT_EVENT_METADATA_PROPERTY_ID - - -EvtPublisherMetadataPublisherGuid = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataPublisherGuid", 0x0) -EvtPublisherMetadataResourceFilePath = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataResourceFilePath", 0x1) -EvtPublisherMetadataParameterFilePath = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataParameterFilePath", 0x2) -EvtPublisherMetadataMessageFilePath = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataMessageFilePath", 0x3) -EvtPublisherMetadataHelpLink = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataHelpLink", 0x4) -EvtPublisherMetadataPublisherMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataPublisherMessageID", 0x5) -EvtPublisherMetadataChannelReferences = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferences", 0x6) -EvtPublisherMetadataChannelReferencePath = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferencePath", 0x7) -EvtPublisherMetadataChannelReferenceIndex = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferenceIndex", 0x8) -EvtPublisherMetadataChannelReferenceID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferenceID", 0x9) -EvtPublisherMetadataChannelReferenceFlags = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferenceFlags", 0xa) -EvtPublisherMetadataChannelReferenceMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferenceMessageID", 0xb) -EvtPublisherMetadataLevels = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataLevels", 0xc) -EvtPublisherMetadataLevelName = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataLevelName", 0xd) -EvtPublisherMetadataLevelValue = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataLevelValue", 0xe) -EvtPublisherMetadataLevelMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataLevelMessageID", 0xf) -EvtPublisherMetadataTasks = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataTasks", 0x10) -EvtPublisherMetadataTaskName = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataTaskName", 0x11) -EvtPublisherMetadataTaskEventGuid = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataTaskEventGuid", 0x12) -EvtPublisherMetadataTaskValue = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataTaskValue", 0x13) -EvtPublisherMetadataTaskMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataTaskMessageID", 0x14) -EvtPublisherMetadataOpcodes = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataOpcodes", 0x15) -EvtPublisherMetadataOpcodeName = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataOpcodeName", 0x16) -EvtPublisherMetadataOpcodeValue = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataOpcodeValue", 0x17) -EvtPublisherMetadataOpcodeMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataOpcodeMessageID", 0x18) -EvtPublisherMetadataKeywords = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataKeywords", 0x19) -EvtPublisherMetadataKeywordName = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataKeywordName", 0x1a) -EvtPublisherMetadataKeywordValue = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataKeywordValue", 0x1b) -EvtPublisherMetadataKeywordMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataKeywordMessageID", 0x1c) -EvtPublisherMetadataPropertyIdEND = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataPropertyIdEND", 0x1d) -class _EVT_PUBLISHER_METADATA_PROPERTY_ID(EnumType): - values = [EvtPublisherMetadataPublisherGuid, EvtPublisherMetadataResourceFilePath, EvtPublisherMetadataParameterFilePath, EvtPublisherMetadataMessageFilePath, EvtPublisherMetadataHelpLink, EvtPublisherMetadataPublisherMessageID, EvtPublisherMetadataChannelReferences, EvtPublisherMetadataChannelReferencePath, EvtPublisherMetadataChannelReferenceIndex, EvtPublisherMetadataChannelReferenceID, EvtPublisherMetadataChannelReferenceFlags, EvtPublisherMetadataChannelReferenceMessageID, EvtPublisherMetadataLevels, EvtPublisherMetadataLevelName, EvtPublisherMetadataLevelValue, EvtPublisherMetadataLevelMessageID, EvtPublisherMetadataTasks, EvtPublisherMetadataTaskName, EvtPublisherMetadataTaskEventGuid, EvtPublisherMetadataTaskValue, EvtPublisherMetadataTaskMessageID, EvtPublisherMetadataOpcodes, EvtPublisherMetadataOpcodeName, EvtPublisherMetadataOpcodeValue, EvtPublisherMetadataOpcodeMessageID, EvtPublisherMetadataKeywords, EvtPublisherMetadataKeywordName, EvtPublisherMetadataKeywordValue, EvtPublisherMetadataKeywordMessageID, EvtPublisherMetadataPropertyIdEND] - mapper = FlagMapper(*values) -EVT_PUBLISHER_METADATA_PROPERTY_ID = _EVT_PUBLISHER_METADATA_PROPERTY_ID - - -EvtFormatMessageEvent = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageEvent", 0x1) -EvtFormatMessageLevel = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageLevel", 0x2) -EvtFormatMessageTask = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageTask", 0x3) -EvtFormatMessageOpcode = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageOpcode", 0x4) -EvtFormatMessageKeyword = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageKeyword", 0x5) -EvtFormatMessageChannel = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageChannel", 0x6) -EvtFormatMessageProvider = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageProvider", 0x7) -EvtFormatMessageId = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageId", 0x8) -EvtFormatMessageXml = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageXml", 0x9) -class _EVT_FORMAT_MESSAGE_FLAGS(EnumType): - values = [EvtFormatMessageEvent, EvtFormatMessageLevel, EvtFormatMessageTask, EvtFormatMessageOpcode, EvtFormatMessageKeyword, EvtFormatMessageChannel, EvtFormatMessageProvider, EvtFormatMessageId, EvtFormatMessageXml] - mapper = FlagMapper(*values) -EVT_FORMAT_MESSAGE_FLAGS = _EVT_FORMAT_MESSAGE_FLAGS - - -class _EVENTLOGRECORD(Structure): - _fields_ = [ - ("Length", DWORD), - ("Reserved", DWORD), - ("RecordNumber", DWORD), - ("TimeGenerated", DWORD), - ("TimeWritten", DWORD), - ("EventID", DWORD), - ("EventType", WORD), - ("NumStrings", WORD), - ("EventCategory", WORD), - ("ReservedFlags", WORD), - ("ClosingRecordNumber", DWORD), - ("StringOffset", DWORD), - ("UserSidLength", DWORD), - ("UserSidOffset", DWORD), - ("DataLength", DWORD), - ("DataOffset", DWORD), - ] -PEVENTLOGRECORD = POINTER(_EVENTLOGRECORD) -EVENTLOGRECORD = _EVENTLOGRECORD - -class _EVENTLOG_FULL_INFORMATION(Structure): - _fields_ = [ - ("dwFull", DWORD), - ] -EVENTLOG_FULL_INFORMATION = _EVENTLOG_FULL_INFORMATION -LPEVENTLOG_FULL_INFORMATION = POINTER(_EVENTLOG_FULL_INFORMATION) - -class _ANON_evt_variant_sub_union(Union): - _fields_ = [ - ("BooleanVal", BOOL), - ("SByteVal", INT8), - ("Int16Val", INT16), - ("Int32Val", INT32), - ("Int64Val", INT64), - ("ByteVal", UINT8), - ("UInt16Val", UINT16), - ("UInt32Val", UINT32), - ("UInt64Val", UINT64), - ("SingleVal", FLOAT), - ("DoubleVal", DOUBLE), - ("FileTimeVal", ULONGLONG), - ("SysTimeVal", POINTER(SYSTEMTIME)), - ("GuidVal", POINTER(GUID)), - ("StringVal", LPCWSTR), - ("AnsiStringVal", LPCSTR), - ("BinaryVal", PBYTE), - ("SidVal", PSID), - ("SizeTVal", SIZE_T), - ("EvtHandleVal", EVT_HANDLE), - ("BooleanArr", POINTER(BOOL)), - ("SByteArr", POINTER(INT8)), - ("Int16Arr", POINTER(INT16)), - ("Int32Arr", POINTER(INT32)), - ("Int64Arr", POINTER(INT64)), - ("ByteArr", POINTER(UINT8)), - ("UInt16Arr", POINTER(UINT16)), - ("UInt32Arr", POINTER(UINT32)), - ("UInt64Arr", POINTER(UINT64)), - ("SingleArr", POINTER(FLOAT)), - ("DoubleArr", POINTER(DOUBLE)), - ("FileTimeArr", POINTER(FILETIME)), - ("SysTimeArr", POINTER(SYSTEMTIME)), - ("GuidArr", POINTER(GUID)), - ("StringArr", POINTER(LPWSTR)), - ("AnsiStringArr", POINTER(LPSTR)), - ("SidArr", POINTER(PSID)), - ("SizeTArr", POINTER(SIZE_T)), - ("XmlVal", LPCWSTR), - ("XmlValArr", POINTER(LPCWSTR)), - ] - - -class _EVT_VARIANT(Structure): - _anonymous_ = ("_VARIANT_VALUE",) - _fields_ = [ - ("_VARIANT_VALUE", _ANON_evt_variant_sub_union), - ("Count", DWORD), - ("Type", DWORD), - ] -PEVT_VARIANT = POINTER(_EVT_VARIANT) -EVT_VARIANT = _EVT_VARIANT - + def tag(self): + return SymTagEnum.mapper[self.Tag] +SYMBOL_INFO = _SYMBOL_INFO +PSYMBOL_INFO = POINTER(_SYMBOL_INFO) CALLFRAME_COPY_NESTED = EnumValue("_CALLFRAME_COPY", "CALLFRAME_COPY_NESTED", 0x1) CALLFRAME_COPY_INDEPENDENT = EnumValue("_CALLFRAME_COPY", "CALLFRAME_COPY_INDEPENDENT", 0x2) class _CALLFRAME_COPY(EnumType): @@ -3745,21 +1469,6 @@ THREAD_INFORMATION_CLASS = _THREAD_INFORMATION_CLASS PTHREAD_INFORMATION_CLASS = POINTER(_THREAD_INFORMATION_CLASS) -TCP_TABLE_BASIC_LISTENER = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_BASIC_LISTENER", 0x0) -TCP_TABLE_BASIC_CONNECTIONS = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_BASIC_CONNECTIONS", 0x1) -TCP_TABLE_BASIC_ALL = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_BASIC_ALL", 0x2) -TCP_TABLE_OWNER_PID_LISTENER = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_PID_LISTENER", 0x3) -TCP_TABLE_OWNER_PID_CONNECTIONS = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_PID_CONNECTIONS", 0x4) -TCP_TABLE_OWNER_PID_ALL = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_PID_ALL", 0x5) -TCP_TABLE_OWNER_MODULE_LISTENER = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_MODULE_LISTENER", 0x6) -TCP_TABLE_OWNER_MODULE_CONNECTIONS = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_MODULE_CONNECTIONS", 0x7) -TCP_TABLE_OWNER_MODULE_ALL = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_MODULE_ALL", 0x8) -class _TCP_TABLE_CLASS(EnumType): - values = [TCP_TABLE_BASIC_LISTENER, TCP_TABLE_BASIC_CONNECTIONS, TCP_TABLE_BASIC_ALL, TCP_TABLE_OWNER_PID_LISTENER, TCP_TABLE_OWNER_PID_CONNECTIONS, TCP_TABLE_OWNER_PID_ALL, TCP_TABLE_OWNER_MODULE_LISTENER, TCP_TABLE_OWNER_MODULE_CONNECTIONS, TCP_TABLE_OWNER_MODULE_ALL] - mapper = FlagMapper(*values) -TCP_TABLE_CLASS = _TCP_TABLE_CLASS - - VT_EMPTY = EnumValue("_VARENUM", "VT_EMPTY", 0x0) VT_NULL = EnumValue("_VARENUM", "VT_NULL", 0x1) VT_I2 = EnumValue("_VARENUM", "VT_I2", 0x2) @@ -3846,33 +1555,6 @@ class NET_FW_PROFILE_TYPE2_(EnumType): NET_FW_PROFILE_TYPE2 = NET_FW_PROFILE_TYPE2_ -MIB_TCP_STATE_CLOSED = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_CLOSED", 0x1) -MIB_TCP_STATE_LISTEN = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_LISTEN", 0x2) -MIB_TCP_STATE_SYN_SENT = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_SYN_SENT", 0x3) -MIB_TCP_STATE_SYN_RCVD = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_SYN_RCVD", 0x4) -MIB_TCP_STATE_ESTAB = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_ESTAB", 0x5) -MIB_TCP_STATE_FIN_WAIT1 = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_FIN_WAIT1", 0x6) -MIB_TCP_STATE_FIN_WAIT2 = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_FIN_WAIT2", 0x7) -MIB_TCP_STATE_CLOSE_WAIT = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_CLOSE_WAIT", 0x8) -MIB_TCP_STATE_CLOSING = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_CLOSING", 0x9) -MIB_TCP_STATE_LAST_ACK = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_LAST_ACK", 0xa) -MIB_TCP_STATE_TIME_WAIT = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_TIME_WAIT", 0xb) -MIB_TCP_STATE_DELETE_TCB = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_DELETE_TCB", 0xc) -class _MIB_TCP_STATE(EnumType): - values = [MIB_TCP_STATE_CLOSED, MIB_TCP_STATE_LISTEN, MIB_TCP_STATE_SYN_SENT, MIB_TCP_STATE_SYN_RCVD, MIB_TCP_STATE_ESTAB, MIB_TCP_STATE_FIN_WAIT1, MIB_TCP_STATE_FIN_WAIT2, MIB_TCP_STATE_CLOSE_WAIT, MIB_TCP_STATE_CLOSING, MIB_TCP_STATE_LAST_ACK, MIB_TCP_STATE_TIME_WAIT, MIB_TCP_STATE_DELETE_TCB] - mapper = FlagMapper(*values) -MIB_TCP_STATE = _MIB_TCP_STATE - - -NET_FW_IP_PROTOCOL_TCP = EnumValue("NET_FW_IP_PROTOCOL_", "NET_FW_IP_PROTOCOL_TCP", 0x6) -NET_FW_IP_PROTOCOL_UDP = EnumValue("NET_FW_IP_PROTOCOL_", "NET_FW_IP_PROTOCOL_UDP", 0x11) -NET_FW_IP_PROTOCOL_ANY = EnumValue("NET_FW_IP_PROTOCOL_", "NET_FW_IP_PROTOCOL_ANY", 0x100) -class NET_FW_IP_PROTOCOL_(EnumType): - values = [NET_FW_IP_PROTOCOL_TCP, NET_FW_IP_PROTOCOL_UDP, NET_FW_IP_PROTOCOL_ANY] - mapper = FlagMapper(*values) -NET_FW_IP_PROTOCOL = NET_FW_IP_PROTOCOL_ - - TokenPrimary = EnumValue("tagTOKEN_TYPE", "TokenPrimary", 0x1) TokenImpersonation = EnumValue("tagTOKEN_TYPE", "TokenImpersonation", 0x2) class tagTOKEN_TYPE(EnumType): @@ -4025,58 +1707,6 @@ class _SECTION_INHERIT(EnumType): SECTION_INHERIT = _SECTION_INHERIT -IF_OPER_STATUS_NON_OPERATIONAL = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_NON_OPERATIONAL", 0x0) -IF_OPER_STATUS_UNREACHABLE = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_UNREACHABLE", 0x1) -IF_OPER_STATUS_DISCONNECTED = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_DISCONNECTED", 0x2) -IF_OPER_STATUS_CONNECTING = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_CONNECTING", 0x3) -IF_OPER_STATUS_CONNECTED = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_CONNECTED", 0x4) -IF_OPER_STATUS_OPERATIONAL = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_OPERATIONAL", 0x5) -class _INTERNAL_IF_OPER_STATUS(EnumType): - values = [IF_OPER_STATUS_NON_OPERATIONAL, IF_OPER_STATUS_UNREACHABLE, IF_OPER_STATUS_DISCONNECTED, IF_OPER_STATUS_CONNECTING, IF_OPER_STATUS_CONNECTED, IF_OPER_STATUS_OPERATIONAL] - mapper = FlagMapper(*values) -INTERNAL_IF_OPER_STATUS = _INTERNAL_IF_OPER_STATUS - - -TI_GET_SYMTAG = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_SYMTAG", 0x0) -TI_GET_SYMNAME = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_SYMNAME", 0x1) -TI_GET_LENGTH = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_LENGTH", 0x2) -TI_GET_TYPE = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_TYPE", 0x3) -TI_GET_TYPEID = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_TYPEID", 0x4) -TI_GET_BASETYPE = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_BASETYPE", 0x5) -TI_GET_ARRAYINDEXTYPEID = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_ARRAYINDEXTYPEID", 0x6) -TI_FINDCHILDREN = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_FINDCHILDREN", 0x7) -TI_GET_DATAKIND = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_DATAKIND", 0x8) -TI_GET_ADDRESSOFFSET = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_ADDRESSOFFSET", 0x9) -TI_GET_OFFSET = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_OFFSET", 0xa) -TI_GET_VALUE = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VALUE", 0xb) -TI_GET_COUNT = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_COUNT", 0xc) -TI_GET_CHILDRENCOUNT = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_CHILDRENCOUNT", 0xd) -TI_GET_BITPOSITION = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_BITPOSITION", 0xe) -TI_GET_VIRTUALBASECLASS = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VIRTUALBASECLASS", 0xf) -TI_GET_VIRTUALTABLESHAPEID = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VIRTUALTABLESHAPEID", 0x10) -TI_GET_VIRTUALBASEPOINTEROFFSET = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VIRTUALBASEPOINTEROFFSET", 0x11) -TI_GET_CLASSPARENTID = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_CLASSPARENTID", 0x12) -TI_GET_NESTED = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_NESTED", 0x13) -TI_GET_SYMINDEX = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_SYMINDEX", 0x14) -TI_GET_LEXICALPARENT = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_LEXICALPARENT", 0x15) -TI_GET_ADDRESS = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_ADDRESS", 0x16) -TI_GET_THISADJUST = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_THISADJUST", 0x17) -TI_GET_UDTKIND = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_UDTKIND", 0x18) -TI_IS_EQUIV_TO = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_IS_EQUIV_TO", 0x19) -TI_GET_CALLING_CONVENTION = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_CALLING_CONVENTION", 0x1a) -TI_IS_CLOSE_EQUIV_TO = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_IS_CLOSE_EQUIV_TO", 0x1b) -TI_GTIEX_REQS_VALID = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GTIEX_REQS_VALID", 0x1c) -TI_GET_VIRTUALBASEOFFSET = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VIRTUALBASEOFFSET", 0x1d) -TI_GET_VIRTUALBASEDISPINDEX = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_VIRTUALBASEDISPINDEX", 0x1e) -TI_GET_IS_REFERENCE = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_IS_REFERENCE", 0x1f) -TI_GET_INDIRECTVIRTUALBASECLASS = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "TI_GET_INDIRECTVIRTUALBASECLASS", 0x20) -IMAGEHLP_SYMBOL_TYPE_INFO_MAX = EnumValue("_IMAGEHLP_SYMBOL_TYPE_INFO", "IMAGEHLP_SYMBOL_TYPE_INFO_MAX", 0x21) -class _IMAGEHLP_SYMBOL_TYPE_INFO(EnumType): - values = [TI_GET_SYMTAG, TI_GET_SYMNAME, TI_GET_LENGTH, TI_GET_TYPE, TI_GET_TYPEID, TI_GET_BASETYPE, TI_GET_ARRAYINDEXTYPEID, TI_FINDCHILDREN, TI_GET_DATAKIND, TI_GET_ADDRESSOFFSET, TI_GET_OFFSET, TI_GET_VALUE, TI_GET_COUNT, TI_GET_CHILDRENCOUNT, TI_GET_BITPOSITION, TI_GET_VIRTUALBASECLASS, TI_GET_VIRTUALTABLESHAPEID, TI_GET_VIRTUALBASEPOINTEROFFSET, TI_GET_CLASSPARENTID, TI_GET_NESTED, TI_GET_SYMINDEX, TI_GET_LEXICALPARENT, TI_GET_ADDRESS, TI_GET_THISADJUST, TI_GET_UDTKIND, TI_IS_EQUIV_TO, TI_GET_CALLING_CONVENTION, TI_IS_CLOSE_EQUIV_TO, TI_GTIEX_REQS_VALID, TI_GET_VIRTUALBASEOFFSET, TI_GET_VIRTUALBASEDISPINDEX, TI_GET_IS_REFERENCE, TI_GET_INDIRECTVIRTUALBASECLASS, IMAGEHLP_SYMBOL_TYPE_INFO_MAX] - mapper = FlagMapper(*values) -IMAGEHLP_SYMBOL_TYPE_INFO = _IMAGEHLP_SYMBOL_TYPE_INFO - - ProcessBasicInformation = EnumValue("_PROCESSINFOCLASS", "ProcessBasicInformation", 0x0) ProcessWow64Information = EnumValue("_PROCESSINFOCLASS", "ProcessWow64Information", 0x1a) class _PROCESSINFOCLASS(EnumType): @@ -4288,8 +1918,21 @@ class _ANON_PEB_UNION_2(Union): ] +class _ANON__PEB_SUB_UNION_1(Union): + _fields_ = [ + ("KernelCallbackTable", PVOID), + ("UserSharedInfoPtr", PVOID), + ] + + +class _ANON__PEB_SUB_UNION_2(Union): + _fields_ = [ + ("ImageProcessAffinityMask", PVOID), + ("ActiveProcessAffinityMask", PVOID), + ] + class _PEB(Structure): - _anonymous_ = ("_SYSTEM_DEPENDENT_02","_SYSTEM_DEPENDENT_03","anon_union_1","_SYSTEM_DEPENDENT_06","_SYSTEM_DEPENDENT_07","anon_union_2") + _anonymous_ = ("_SYSTEM_DEPENDENT_02","_SYSTEM_DEPENDENT_03","anon_01","_SYSTEM_DEPENDENT_06","_SYSTEM_DEPENDENT_07","anon_02") _fields_ = [ ("Reserved1", BYTE * 2), ("BeingDebugged", BYTE), @@ -4304,7 +1947,7 @@ class _PEB(Structure): ("_SYSTEM_DEPENDENT_02", _ANON_PEB_SYSTEM_DEPENDENT_02), ("_SYSTEM_DEPENDENT_03", _ANON_PEB_SYSTEM_DEPENDENT_03), ("_SYSTEM_DEPENDENT_04", PVOID), - ("anon_union_1", _ANON_PEB_UNION_1), + ("anon_01", _ANON__PEB_SUB_UNION_1), ("SystemReserved", DWORD), ("_SYSTEM_DEPENDENT_05", DWORD), ("_SYSTEM_DEPENDENT_06", _ANON_PEB_SYSTEM_DEPENDENT_06), @@ -4339,7 +1982,7 @@ class _PEB(Structure): ("ImageSubsystem", DWORD), ("ImageSubsystemMajorVersion", DWORD), ("ImageSubsystemMinorVersion", PVOID), - ("anon_union_2", _ANON_PEB_UNION_2), + ("anon_02", _ANON__PEB_SUB_UNION_2), ("GdiHandleBuffer", PVOID * 26), ("GdiHandleBuffer2", BYTE * 32), ("PostProcessInitRoutine", PVOID), @@ -5287,170 +2930,6 @@ class _OVERLAPPED(Structure): LPOVERLAPPED = POINTER(_OVERLAPPED) OVERLAPPED = _OVERLAPPED -class _MIB_IPADDRROW_XP(Structure): - _fields_ = [ - ("dwAddr", DWORD), - ("dwIndex", IF_INDEX), - ("dwMask", DWORD), - ("dwBCastAddr", DWORD), - ("dwReasmSize", DWORD), - ("unused1", USHORT), - ("wType", USHORT), - ] -MIB_IPADDRROW = _MIB_IPADDRROW_XP -PMIB_IPADDRROW_XP = POINTER(_MIB_IPADDRROW_XP) -MIB_IPADDRROW_XP = _MIB_IPADDRROW_XP - -class _MIB_IPADDRTABLE(Structure): - _fields_ = [ - ("dwNumEntries", DWORD), - ("table", MIB_IPADDRROW * ANY_SIZE), - ] -PMIB_IPADDRTABLE = POINTER(_MIB_IPADDRTABLE) -MIB_IPADDRTABLE = _MIB_IPADDRTABLE - -class _MIB_IFROW(Structure): - _fields_ = [ - ("wszName", WCHAR * MAX_INTERFACE_NAME_LEN), - ("dwIndex", IF_INDEX), - ("dwType", IFTYPE), - ("dwMtu", DWORD), - ("dwSpeed", DWORD), - ("dwPhysAddrLen", DWORD), - ("bPhysAddr", BYTE * MAXLEN_PHYSADDR), - ("dwAdminStatus", DWORD), - ("dwOperStatus", INTERNAL_IF_OPER_STATUS), - ("dwLastChange", DWORD), - ("dwInOctets", DWORD), - ("dwInUcastPkts", DWORD), - ("dwInNUcastPkts", DWORD), - ("dwInDiscards", DWORD), - ("dwInErrors", DWORD), - ("dwInUnknownProtos", DWORD), - ("dwOutOctets", DWORD), - ("dwOutUcastPkts", DWORD), - ("dwOutNUcastPkts", DWORD), - ("dwOutDiscards", DWORD), - ("dwOutErrors", DWORD), - ("dwOutQLen", DWORD), - ("dwDescrLen", DWORD), - ("bDescr", UCHAR * MAXLEN_IFDESCR), - ] -PMIB_IFROW = POINTER(_MIB_IFROW) -MIB_IFROW = _MIB_IFROW - -class _MIB_IFTABLE(Structure): - _fields_ = [ - ("dwNumEntries", DWORD), - ("table", MIB_IFROW * ANY_SIZE), - ] -PMIB_IFTABLE = POINTER(_MIB_IFTABLE) -MIB_IFTABLE = _MIB_IFTABLE - -class _MIB_TCPROW_OWNER_PID(Structure): - _fields_ = [ - ("dwState", DWORD), - ("dwLocalAddr", DWORD), - ("dwLocalPort", DWORD), - ("dwRemoteAddr", DWORD), - ("dwRemotePort", DWORD), - ("dwOwningPid", DWORD), - ] -MIB_TCPROW_OWNER_PID = _MIB_TCPROW_OWNER_PID -PMIB_TCPROW_OWNER_PID = POINTER(_MIB_TCPROW_OWNER_PID) - -class _MIB_TCPTABLE_OWNER_PID(Structure): - _fields_ = [ - ("dwNumEntries", DWORD), - ("table", MIB_TCPROW_OWNER_PID * ANY_SIZE), - ] -MIB_TCPTABLE_OWNER_PID = _MIB_TCPTABLE_OWNER_PID -PMIB_TCPTABLE_OWNER_PID = POINTER(_MIB_TCPTABLE_OWNER_PID) - -class _MIB_UDPROW_OWNER_PID(Structure): - _fields_ = [ - ("dwLocalAddr", DWORD), - ("dwLocalPort", DWORD), - ("dwOwningPid", DWORD), - ] -MIB_UDPROW_OWNER_PID = _MIB_UDPROW_OWNER_PID -PMIB_UDPROW_OWNER_PID = POINTER(_MIB_UDPROW_OWNER_PID) - -class _MIB_UDPTABLE_OWNER_PID(Structure): - _fields_ = [ - ("dwNumEntries", DWORD), - ("table", MIB_UDPROW_OWNER_PID * ANY_SIZE), - ] -MIB_UDPTABLE_OWNER_PID = _MIB_UDPTABLE_OWNER_PID -PMIB_UDPTABLE_OWNER_PID = POINTER(_MIB_UDPTABLE_OWNER_PID) - -class _MIB_UDP6ROW_OWNER_PID(Structure): - _fields_ = [ - ("ucLocalAddr", UCHAR * 16), - ("dwLocalScopeId", DWORD), - ("dwLocalPort", DWORD), - ("dwOwningPid", DWORD), - ] -MIB_UDP6ROW_OWNER_PID = _MIB_UDP6ROW_OWNER_PID -PMIB_UDP6ROW_OWNER_PID = POINTER(_MIB_UDP6ROW_OWNER_PID) - -class _MIB_UDP6TABLE_OWNER_PID(Structure): - _fields_ = [ - ("dwNumEntries", DWORD), - ("table", MIB_UDP6ROW_OWNER_PID * ANY_SIZE), - ] -PMIB_UDP6TABLE_OWNER_PID = POINTER(_MIB_UDP6TABLE_OWNER_PID) -MIB_UDP6TABLE_OWNER_PID = _MIB_UDP6TABLE_OWNER_PID - -class _MIB_TCP6ROW_OWNER_PID(Structure): - _fields_ = [ - ("ucLocalAddr", UCHAR * 16), - ("dwLocalScopeId", DWORD), - ("dwLocalPort", DWORD), - ("ucRemoteAddr", UCHAR * 16), - ("dwRemoteScopeId", DWORD), - ("dwRemotePort", DWORD), - ("dwState", DWORD), - ("dwOwningPid", DWORD), - ] -MIB_TCP6ROW_OWNER_PID = _MIB_TCP6ROW_OWNER_PID -PMIB_TCP6ROW_OWNER_PID = POINTER(_MIB_TCP6ROW_OWNER_PID) - -class _MIB_TCP6TABLE_OWNER_PID(Structure): - _fields_ = [ - ("dwNumEntries", DWORD), - ("table", MIB_TCP6ROW_OWNER_PID * ANY_SIZE), - ] -MIB_TCP6TABLE_OWNER_PID = _MIB_TCP6TABLE_OWNER_PID -PMIB_TCP6TABLE_OWNER_PID = POINTER(_MIB_TCP6TABLE_OWNER_PID) - -class _MIB_TCPROW(Structure): - _fields_ = [ - ("dwState", DWORD), - ("dwLocalAddr", DWORD), - ("dwLocalPort", DWORD), - ("dwRemoteAddr", DWORD), - ("dwRemotePort", DWORD), - ] -MIB_TCPROW = _MIB_TCPROW -PMIB_TCPROW = POINTER(_MIB_TCPROW) - -class _IP_ADAPTER_INDEX_MAP(Structure): - _fields_ = [ - ("Index", ULONG), - ("Name", WCHAR * MAX_ADAPTER_NAME), - ] -PIP_ADAPTER_INDEX_MAP = POINTER(_IP_ADAPTER_INDEX_MAP) -IP_ADAPTER_INDEX_MAP = _IP_ADAPTER_INDEX_MAP - -class _IP_INTERFACE_INFO(Structure): - _fields_ = [ - ("NumAdapters", LONG), - ("Adapter", IP_ADAPTER_INDEX_MAP * 1), - ] -PIP_INTERFACE_INFO = POINTER(_IP_INTERFACE_INFO) -IP_INTERFACE_INFO = _IP_INTERFACE_INFO - # Self referencing struct tricks class _EXCEPTION_RECORD(Structure): pass PEXCEPTION_RECORD = POINTER(_EXCEPTION_RECORD) @@ -5563,27 +3042,6 @@ class _DEBUG_PROCESSOR_IDENTIFICATION_ALL(Union): PDEBUG_PROCESSOR_IDENTIFICATION_ALL = POINTER(_DEBUG_PROCESSOR_IDENTIFICATION_ALL) DEBUG_PROCESSOR_IDENTIFICATION_ALL = _DEBUG_PROCESSOR_IDENTIFICATION_ALL -class _SYMBOL_INFO(Structure): - _fields_ = [ - ("SizeOfStruct", ULONG), - ("TypeIndex", ULONG), - ("Reserved", ULONG64 * 2), - ("Index", ULONG), - ("Size", ULONG), - ("ModBase", ULONG64), - ("Flags", ULONG), - ("Value", ULONG64), - ("Address", ULONG64), - ("Register", ULONG), - ("Scope", ULONG), - ("Tag", ULONG), - ("NameLen", ULONG), - ("MaxNameLen", ULONG), - ("Name", CHAR * 1), - ] -SYMBOL_INFO = _SYMBOL_INFO -PSYMBOL_INFO = POINTER(_SYMBOL_INFO) - class _MODLOAD_DATA(Structure): _fields_ = [ ("ssize", DWORD), @@ -5983,6 +3441,24 @@ class _OBJECT_ATTRIBUTES(Structure): POBJECT_ATTRIBUTES = POINTER(_OBJECT_ATTRIBUTES) OBJECT_ATTRIBUTES = _OBJECT_ATTRIBUTES +class _OBJECT_ATTRIBUTES(_OBJECT_ATTRIBUTES): + @classmethod + def from_string(cls, path, attributes=OBJ_CASE_INSENSITIVE): # Directly on constructor ? + self = cls() + self.Length = ctypes.sizeof(self) + self.RootDirectory = 0 + self.ObjectName = ctypes.pointer(LSA_UNICODE_STRING.from_string(path)) + self.Attributes = attributes + self.SecurityDescriptor = 0 + self.SecurityQualityOfService = 0 + return self + + def __repr__(self): + if not self.ObjectName: + return super(_OBJECT_ATTRIBUTES, self).__repr__() + return """<{0} ObjectName="{1}">""".format(type(self).__name__, self.ObjectName[0].str) +POBJECT_ATTRIBUTES = POINTER(_OBJECT_ATTRIBUTES) +OBJECT_ATTRIBUTES = _OBJECT_ATTRIBUTES class _TMP_UNION_IO_STATUS_BLOCK(Union): _fields_ = [ ("Status", NTSTATUS), @@ -6072,6 +3548,17 @@ class _SYSTEM_HANDLE(Structure): ] SYSTEM_HANDLE = _SYSTEM_HANDLE +class _SYSTEM_HANDLE64(Structure): + _fields_ = [ + ("dwProcessId", DWORD), + ("bObjectType", BYTE), + ("bFlags", BYTE), + ("wValue", WORD), + ("pAddress", ULONG64), + ("GrantedAccess", DWORD), + ] +SYSTEM_HANDLE64 = _SYSTEM_HANDLE64 + class _SYSTEM_HANDLE_INFORMATION(Structure): _fields_ = [ ("HandleCount", ULONG), @@ -6080,6 +3567,14 @@ class _SYSTEM_HANDLE_INFORMATION(Structure): PSYSTEM_HANDLE_INFORMATION = POINTER(_SYSTEM_HANDLE_INFORMATION) SYSTEM_HANDLE_INFORMATION = _SYSTEM_HANDLE_INFORMATION +class _SYSTEM_HANDLE_INFORMATION64(Structure): + _fields_ = [ + ("HandleCount", ULONG), + ("Handles", SYSTEM_HANDLE64 * 1), + ] +SYSTEM_HANDLE_INFORMATION64 = _SYSTEM_HANDLE_INFORMATION64 +PSYSTEM_HANDLE_INFORMATION64 = POINTER(_SYSTEM_HANDLE_INFORMATION64) + class __PUBLIC_OBJECT_TYPE_INFORMATION(Structure): _fields_ = [ ("TypeName", UNICODE_STRING), @@ -6458,303 +3953,23 @@ class _PROCESS_MEMORY_COUNTERS_EX(Structure): ] PROCESS_MEMORY_COUNTERS_EX = _PROCESS_MEMORY_COUNTERS_EX -TokenInvalid = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenInvalid", 0x0) -TokenUser = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenUser", 0x1) -TokenGroups = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenGroups", 0x2) -TokenPrivileges = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenPrivileges", 0x3) -TokenOwner = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenOwner", 0x4) -TokenPrimaryGroup = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenPrimaryGroup", 0x5) -TokenDefaultDacl = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenDefaultDacl", 0x6) -TokenSource = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSource", 0x7) -TokenType = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenType", 0x8) -TokenImpersonationLevel = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenImpersonationLevel", 0x9) -TokenStatistics = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenStatistics", 0xa) -TokenRestrictedSids = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenRestrictedSids", 0xb) -TokenSessionId = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSessionId", 0xc) -TokenGroupsAndPrivileges = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenGroupsAndPrivileges", 0xd) -TokenSessionReference = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSessionReference", 0xe) -TokenSandBoxInert = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSandBoxInert", 0xf) -TokenAuditPolicy = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenAuditPolicy", 0x10) -TokenOrigin = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenOrigin", 0x11) -TokenElevationType = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenElevationType", 0x12) -TokenLinkedToken = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenLinkedToken", 0x13) -TokenElevation = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenElevation", 0x14) -TokenHasRestrictions = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenHasRestrictions", 0x15) -TokenAccessInformation = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenAccessInformation", 0x16) -TokenVirtualizationAllowed = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenVirtualizationAllowed", 0x17) -TokenVirtualizationEnabled = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenVirtualizationEnabled", 0x18) -TokenIntegrityLevel = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenIntegrityLevel", 0x19) -TokenUIAccess = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenUIAccess", 0x1a) -TokenMandatoryPolicy = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenMandatoryPolicy", 0x1b) -TokenLogonSid = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenLogonSid", 0x1c) -TokenIsAppContainer = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenIsAppContainer", 0x1d) -TokenCapabilities = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenCapabilities", 0x1e) -TokenAppContainerSid = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenAppContainerSid", 0x1f) -TokenAppContainerNumber = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenAppContainerNumber", 0x20) -TokenUserClaimAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenUserClaimAttributes", 0x21) -TokenDeviceClaimAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenDeviceClaimAttributes", 0x22) -TokenRestrictedUserClaimAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenRestrictedUserClaimAttributes", 0x23) -TokenRestrictedDeviceClaimAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenRestrictedDeviceClaimAttributes", 0x24) -TokenDeviceGroups = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenDeviceGroups", 0x25) -TokenRestrictedDeviceGroups = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenRestrictedDeviceGroups", 0x26) -TokenSecurityAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSecurityAttributes", 0x27) -TokenIsRestricted = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenIsRestricted", 0x28) -TokenProcessTrustLevel = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenProcessTrustLevel", 0x29) -TokenPrivateNameSpace = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenPrivateNameSpace", 0x2a) -TokenSingletonAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSingletonAttributes", 0x2b) -TokenBnoIsolation = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenBnoIsolation", 0x2c) -TokenChildProcessFlags = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenChildProcessFlags", 0x2d) -MaxTokenInfoClass = EnumValue("_TOKEN_INFORMATION_CLASS", "MaxTokenInfoClass", 0x2e) -class _TOKEN_INFORMATION_CLASS(EnumType): - values = [TokenInvalid, TokenUser, TokenGroups, TokenPrivileges, TokenOwner, TokenPrimaryGroup, TokenDefaultDacl, TokenSource, TokenType, TokenImpersonationLevel, TokenStatistics, TokenRestrictedSids, TokenSessionId, TokenGroupsAndPrivileges, TokenSessionReference, TokenSandBoxInert, TokenAuditPolicy, TokenOrigin, TokenElevationType, TokenLinkedToken, TokenElevation, TokenHasRestrictions, TokenAccessInformation, TokenVirtualizationAllowed, TokenVirtualizationEnabled, TokenIntegrityLevel, TokenUIAccess, TokenMandatoryPolicy, TokenLogonSid, TokenIsAppContainer, TokenCapabilities, TokenAppContainerSid, TokenAppContainerNumber, TokenUserClaimAttributes, TokenDeviceClaimAttributes, TokenRestrictedUserClaimAttributes, TokenRestrictedDeviceClaimAttributes, TokenDeviceGroups, TokenRestrictedDeviceGroups, TokenSecurityAttributes, TokenIsRestricted, TokenProcessTrustLevel, TokenPrivateNameSpace, TokenSingletonAttributes, TokenBnoIsolation, TokenChildProcessFlags, MaxTokenInfoClass] - mapper = FlagMapper(*values) -TOKEN_INFORMATION_CLASS = _TOKEN_INFORMATION_CLASS -PTOKEN_INFORMATION_CLASS = POINTER(_TOKEN_INFORMATION_CLASS) - - -TokenElevationTypeDefault = EnumValue("_TOKEN_ELEVATION_TYPE", "TokenElevationTypeDefault", 0x1) -TokenElevationTypeFull = EnumValue("_TOKEN_ELEVATION_TYPE", "TokenElevationTypeFull", 0x2) -TokenElevationTypeLimited = EnumValue("_TOKEN_ELEVATION_TYPE", "TokenElevationTypeLimited", 0x3) -class _TOKEN_ELEVATION_TYPE(EnumType): - values = [TokenElevationTypeDefault, TokenElevationTypeFull, TokenElevationTypeLimited] - mapper = FlagMapper(*values) -TOKEN_ELEVATION_TYPE = _TOKEN_ELEVATION_TYPE -PTOKEN_ELEVATION_TYPE = POINTER(_TOKEN_ELEVATION_TYPE) - - -class _TOKEN_PRIVILEGES(Structure): +class _FILETIME(Structure): _fields_ = [ - ("PrivilegeCount", DWORD), - ("Privileges", LUID_AND_ATTRIBUTES * ANYSIZE_ARRAY), + ("dwLowDateTime", DWORD), + ("dwHighDateTime", DWORD), ] -TOKEN_PRIVILEGES = _TOKEN_PRIVILEGES -PTOKEN_PRIVILEGES = POINTER(_TOKEN_PRIVILEGES) +LPFILETIME = POINTER(_FILETIME) +PFILETIME = POINTER(_FILETIME) +FILETIME = _FILETIME -class _TOKEN_ELEVATION(Structure): - _fields_ = [ - ("TokenIsElevated", DWORD), - ] -TOKEN_ELEVATION = _TOKEN_ELEVATION -PTOKEN_ELEVATION = POINTER(_TOKEN_ELEVATION) - -class _SID_AND_ATTRIBUTES(Structure): - _fields_ = [ - ("Sid", PSID), - ("Attributes", DWORD), - ] -SID_AND_ATTRIBUTES = _SID_AND_ATTRIBUTES -PSID_AND_ATTRIBUTES = POINTER(_SID_AND_ATTRIBUTES) - -_INITIAL_SID_AND_ATTRIBUTES = _SID_AND_ATTRIBUTES -class _SID_AND_ATTRIBUTES(_INITIAL_SID_AND_ATTRIBUTES): - pass - - # Only in TOKEN_GROUPS - # attributes = FlagExatractor(_INITIAL_SID_AND_ATTRIBUTES.Attributes, - # (SE_GROUP_MANDATORY, - # SE_GROUP_ENABLED_BY_DEFAULT, - # SE_GROUP_ENABLED, - # SE_GROUP_OWNER, - # SE_GROUP_USE_FOR_DENY_ONLY, - # SE_GROUP_INTEGRITY, - # SE_GROUP_INTEGRITY_ENABLED, - # SE_GROUP_LOGON_ID, - # SE_GROUP_RESOURCE)) -SID_AND_ATTRIBUTES = _SID_AND_ATTRIBUTES -PSID_AND_ATTRIBUTES = POINTER(_SID_AND_ATTRIBUTES) -class _TOKEN_MANDATORY_LABEL(Structure): - _fields_ = [ - ("Label", SID_AND_ATTRIBUTES), - ] -TOKEN_MANDATORY_LABEL = _TOKEN_MANDATORY_LABEL -PTOKEN_MANDATORY_LABEL = POINTER(_TOKEN_MANDATORY_LABEL) - -class _TOKEN_USER(Structure): - _fields_ = [ - ("User", SID_AND_ATTRIBUTES), - ] -PTOKEN_USER = POINTER(_TOKEN_USER) -TOKEN_USER = _TOKEN_USER - -class _TOKEN_DEFAULT_DACL(Structure): - _fields_ = [ - ("DefaultDacl", PACL), - ] -TOKEN_DEFAULT_DACL = _TOKEN_DEFAULT_DACL -PTOKEN_DEFAULT_DACL = POINTER(_TOKEN_DEFAULT_DACL) - -class _TOKEN_GROUPS(Structure): - _fields_ = [ - ("GroupCount", DWORD), - ("Groups", SID_AND_ATTRIBUTES * ANYSIZE_ARRAY), - ] -TOKEN_GROUPS = _TOKEN_GROUPS -PTOKEN_GROUPS = POINTER(_TOKEN_GROUPS) - -class _TOKEN_OWNER(Structure): - _fields_ = [ - ("Owner", PSID), - ] -TOKEN_OWNER = _TOKEN_OWNER -PTOKEN_OWNER = POINTER(_TOKEN_OWNER) - -class _TOKEN_PRIMARY_GROUP(Structure): - _fields_ = [ - ("PrimaryGroup", PSID), - ] -PTOKEN_PRIMARY_GROUP = POINTER(_TOKEN_PRIMARY_GROUP) -TOKEN_PRIMARY_GROUP = _TOKEN_PRIMARY_GROUP - -class _TOKEN_SOURCE(Structure): - _fields_ = [ - ("SourceName", CHAR * TOKEN_SOURCE_LENGTH), - ("SourceIdentifier", LUID), - ] -PTOKEN_SOURCE = POINTER(_TOKEN_SOURCE) -TOKEN_SOURCE = _TOKEN_SOURCE - -class _TOKEN_STATISTICS(Structure): - _fields_ = [ - ("TokenId", LUID), - ("AuthenticationId", LUID), - ("ExpirationTime", LARGE_INTEGER), - ("TokenType", TOKEN_TYPE), - ("ImpersonationLevel", SECURITY_IMPERSONATION_LEVEL), - ("DynamicCharged", DWORD), - ("DynamicAvailable", DWORD), - ("GroupCount", DWORD), - ("PrivilegeCount", DWORD), - ("ModifiedId", LUID), - ] -PTOKEN_STATISTICS = POINTER(_TOKEN_STATISTICS) -TOKEN_STATISTICS = _TOKEN_STATISTICS - -class _TOKEN_ORIGIN(Structure): - _fields_ = [ - ("OriginatingLogonSession", LUID), - ] -TOKEN_ORIGIN = _TOKEN_ORIGIN -PTOKEN_ORIGIN = POINTER(_TOKEN_ORIGIN) - -class _TOKEN_LINKED_TOKEN(Structure): - _fields_ = [ - ("LinkedToken", HANDLE), - ] -PTOKEN_LINKED_TOKEN = POINTER(_TOKEN_LINKED_TOKEN) -TOKEN_LINKED_TOKEN = _TOKEN_LINKED_TOKEN - -class _TOKEN_MANDATORY_POLICY(Structure): - _fields_ = [ - ("Policy", DWORD), - ] -TOKEN_MANDATORY_POLICY = _TOKEN_MANDATORY_POLICY -PTOKEN_MANDATORY_POLICY = POINTER(_TOKEN_MANDATORY_POLICY) - -class _SID_AND_ATTRIBUTES_HASH(Structure): - _fields_ = [ - ("SidCount", DWORD), - ("SidAttr", PSID_AND_ATTRIBUTES), - ("Hash", SID_HASH_ENTRY * SID_HASH_SIZE), - ] -SID_AND_ATTRIBUTES_HASH = _SID_AND_ATTRIBUTES_HASH -PSID_AND_ATTRIBUTES_HASH = POINTER(_SID_AND_ATTRIBUTES_HASH) - -class _TOKEN_APPCONTAINER_INFORMATION(Structure): - _fields_ = [ - ("TokenAppContainer", PSID), - ] -PTOKEN_APPCONTAINER_INFORMATION = POINTER(_TOKEN_APPCONTAINER_INFORMATION) -TOKEN_APPCONTAINER_INFORMATION = _TOKEN_APPCONTAINER_INFORMATION - -class _TOKEN_ACCESS_INFORMATION(Structure): - _fields_ = [ - ("SidHash", PSID_AND_ATTRIBUTES_HASH), - ("RestrictedSidHash", PSID_AND_ATTRIBUTES_HASH), - ("Privileges", PTOKEN_PRIVILEGES), - ("AuthenticationId", LUID), - ("TokenType", TOKEN_TYPE), - ("ImpersonationLevel", SECURITY_IMPERSONATION_LEVEL), - ("MandatoryPolicy", TOKEN_MANDATORY_POLICY), - ("Flags", DWORD), - ("AppContainerNumber", DWORD), - ("PackageSid", PSID), - ("CapabilitiesHash", PSID_AND_ATTRIBUTES_HASH), - ("TrustLevelSid", PSID), - ("SecurityAttributes", PSECURITY_ATTRIBUTES_OPAQUE), - ] -PTOKEN_ACCESS_INFORMATION = POINTER(_TOKEN_ACCESS_INFORMATION) -TOKEN_ACCESS_INFORMATION = _TOKEN_ACCESS_INFORMATION - -class _TOKEN_GROUPS_AND_PRIVILEGES(Structure): - _fields_ = [ - ("SidCount", DWORD), - ("SidLength", DWORD), - ("Sids", PSID_AND_ATTRIBUTES), - ("RestrictedSidCount", DWORD), - ("RestrictedSidLength", DWORD), - ("RestrictedSids", PSID_AND_ATTRIBUTES), - ("PrivilegeCount", DWORD), - ("PrivilegeLength", DWORD), - ("Privileges", PLUID_AND_ATTRIBUTES), - ("AuthenticationId", LUID), - ] -TOKEN_GROUPS_AND_PRIVILEGES = _TOKEN_GROUPS_AND_PRIVILEGES -PTOKEN_GROUPS_AND_PRIVILEGES = POINTER(_TOKEN_GROUPS_AND_PRIVILEGES) - -class _TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE(Structure): - _fields_ = [ - ("Version", ULONG64), - ("Name", UNICODE_STRING), - ] -PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE = POINTER(_TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE) -TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE = _TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE - -class _TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE(Structure): - _fields_ = [ - ("pValue", PVOID), - ("ValueLength", ULONG), - ] -PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = POINTER(_TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE) -TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = _TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE - -class _TOKEN_SECURITY_ATTRIBUTE_V1_UNION(Union): - _fields_ = [ - ("pInt64", PLONG64), - ("pUint64", PULONG64), - ("pString", PUNICODE_STRING), - ("pFqbn", PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE), - ("pOctetString", PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE), - ] -TOKEN_SECURITY_ATTRIBUTE_V1_UNION = _TOKEN_SECURITY_ATTRIBUTE_V1_UNION - -class _TOKEN_SECURITY_ATTRIBUTE_V1(Structure): - _fields_ = [ - ("Name", UNICODE_STRING), - ("ValueType", USHORT), - ("Reserved", USHORT), - ("Flags", ULONG), - ("ValueCount", ULONG), - ("Values", TOKEN_SECURITY_ATTRIBUTE_V1_UNION), - ] -TOKEN_SECURITY_ATTRIBUTE_V1 = _TOKEN_SECURITY_ATTRIBUTE_V1 -PTOKEN_SECURITY_ATTRIBUTE_V1 = POINTER(_TOKEN_SECURITY_ATTRIBUTE_V1) - -class _TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION(Union): - _fields_ = [ - ("pAttributeV1", PTOKEN_SECURITY_ATTRIBUTE_V1), - ] -TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION = _TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION - -class _TOKEN_SECURITY_ATTRIBUTES_INFORMATION(Structure): - _fields_ = [ - ("Version", USHORT), - ("Reserved", USHORT), - ("AttributeCount", ULONG), - ("Attribute", TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION), - ] -PTOKEN_SECURITY_ATTRIBUTES_INFORMATION = POINTER(_TOKEN_SECURITY_ATTRIBUTES_INFORMATION) -TOKEN_SECURITY_ATTRIBUTES_INFORMATION = _TOKEN_SECURITY_ATTRIBUTES_INFORMATION +INITIAL_FILETIME = FILETIME +class _FILETIME(INITIAL_FILETIME): + def __int__(self): + return (self.dwHighDateTime << 32) + self.dwLowDateTime +LPFILETIME = POINTER(_FILETIME) +PFILETIME = POINTER(_FILETIME) +FILETIME = _FILETIME AlpcBasicInformation = EnumValue("_ALPC_PORT_INFORMATION_CLASS", "AlpcBasicInformation", 0x0) AlpcPortInformation = EnumValue("_ALPC_PORT_INFORMATION_CLASS", "AlpcPortInformation", 0x1) AlpcAssociateCompletionPortInformation = EnumValue("_ALPC_PORT_INFORMATION_CLASS", "AlpcAssociateCompletionPortInformation", 0x2) @@ -7139,6 +4354,2978 @@ class _LOCALTHIS(Structure): ] LOCALTHIS = _LOCALTHIS +AclRevisionInformation = EnumValue("_ACL_INFORMATION_CLASS", "AclRevisionInformation", 0x1) +AclSizeInformation = EnumValue("_ACL_INFORMATION_CLASS", "AclSizeInformation", 0x2) +class _ACL_INFORMATION_CLASS(EnumType): + values = [AclRevisionInformation, AclSizeInformation] + mapper = FlagMapper(*values) +ACL_INFORMATION_CLASS = _ACL_INFORMATION_CLASS + + +class _ACL(Structure): + _fields_ = [ + ("AclRevision", BYTE), + ("Sbz1", BYTE), + ("AclSize", WORD), + ("AceCount", WORD), + ("Sbz2", WORD), + ] +PACL = POINTER(_ACL) +ACL = _ACL + +class _ACL_REVISION_INFORMATION(Structure): + _fields_ = [ + ("AclRevision", DWORD), + ] +PACL_REVISION_INFORMATION = POINTER(_ACL_REVISION_INFORMATION) +ACL_REVISION_INFORMATION = _ACL_REVISION_INFORMATION + +class _ACL_SIZE_INFORMATION(Structure): + _fields_ = [ + ("AceCount", DWORD), + ("AclBytesInUse", DWORD), + ("AclBytesFree", DWORD), + ] +PACL_SIZE_INFORMATION = POINTER(_ACL_SIZE_INFORMATION) +ACL_SIZE_INFORMATION = _ACL_SIZE_INFORMATION + +class _ACE_HEADER(Structure): + _fields_ = [ + ("AceType", BYTE), + ("AceFlags", BYTE), + ("AceSize", WORD), + ] +PACE_HEADER = POINTER(_ACE_HEADER) +ACE_HEADER = _ACE_HEADER + +class _ACCESS_ALLOWED_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +PACCESS_ALLOWED_ACE = POINTER(_ACCESS_ALLOWED_ACE) +ACCESS_ALLOWED_ACE = _ACCESS_ALLOWED_ACE + +class _ACCESS_ALLOWED_CALLBACK_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +PACCESS_ALLOWED_CALLBACK_ACE = POINTER(_ACCESS_ALLOWED_CALLBACK_ACE) +ACCESS_ALLOWED_CALLBACK_ACE = _ACCESS_ALLOWED_CALLBACK_ACE + +class _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("Flags", DWORD), + ("ObjectType", GUID), + ("InheritedObjectType", GUID), + ("SidStart", DWORD), + ] +PACCESS_ALLOWED_CALLBACK_OBJECT_ACE = POINTER(_ACCESS_ALLOWED_CALLBACK_OBJECT_ACE) +ACCESS_ALLOWED_CALLBACK_OBJECT_ACE = _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE + +class _ACCESS_DENIED_CALLBACK_OBJECT_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("Flags", DWORD), + ("ObjectType", GUID), + ("InheritedObjectType", GUID), + ("SidStart", DWORD), + ] +ACCESS_DENIED_CALLBACK_OBJECT_ACE = _ACCESS_DENIED_CALLBACK_OBJECT_ACE +PACCESS_DENIED_CALLBACK_OBJECT_ACE = POINTER(_ACCESS_DENIED_CALLBACK_OBJECT_ACE) + +class _ACCESS_ALLOWED_OBJECT_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("Flags", DWORD), + ("ObjectType", GUID), + ("InheritedObjectType", GUID), + ("SidStart", DWORD), + ] +PACCESS_ALLOWED_OBJECT_ACE = POINTER(_ACCESS_ALLOWED_OBJECT_ACE) +ACCESS_ALLOWED_OBJECT_ACE = _ACCESS_ALLOWED_OBJECT_ACE + +class _ACCESS_DENIED_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +ACCESS_DENIED_ACE = _ACCESS_DENIED_ACE +PACCESS_DENIED_ACE = POINTER(_ACCESS_DENIED_ACE) + +class _ACCESS_DENIED_CALLBACK_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +ACCESS_DENIED_CALLBACK_ACE = _ACCESS_DENIED_CALLBACK_ACE +PACCESS_DENIED_CALLBACK_ACE = POINTER(_ACCESS_DENIED_CALLBACK_ACE) + +class _ACCESS_DENIED_OBJECT_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("Flags", DWORD), + ("ObjectType", GUID), + ("InheritedObjectType", GUID), + ("SidStart", DWORD), + ] +ACCESS_DENIED_OBJECT_ACE = _ACCESS_DENIED_OBJECT_ACE +PACCESS_DENIED_OBJECT_ACE = POINTER(_ACCESS_DENIED_OBJECT_ACE) + +class _SYSTEM_MANDATORY_LABEL_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +SYSTEM_MANDATORY_LABEL_ACE = _SYSTEM_MANDATORY_LABEL_ACE +PSYSTEM_MANDATORY_LABEL_ACE = POINTER(_SYSTEM_MANDATORY_LABEL_ACE) + +class _SYSTEM_AUDIT_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +SYSTEM_AUDIT_ACE = _SYSTEM_AUDIT_ACE + +class _SYSTEM_ALARM_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +SYSTEM_ALARM_ACE = _SYSTEM_ALARM_ACE + +class _SYSTEM_RESOURCE_ATTRIBUTE_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +PSYSTEM_RESOURCE_ATTRIBUTE_ACE = POINTER(_SYSTEM_RESOURCE_ATTRIBUTE_ACE) +SYSTEM_RESOURCE_ATTRIBUTE_ACE = _SYSTEM_RESOURCE_ATTRIBUTE_ACE + +class _SYSTEM_SCOPED_POLICY_ID_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +SYSTEM_SCOPED_POLICY_ID_ACE = _SYSTEM_SCOPED_POLICY_ID_ACE +PSYSTEM_SCOPED_POLICY_ID_ACE = POINTER(_SYSTEM_SCOPED_POLICY_ID_ACE) + +class _SYSTEM_PROCESS_TRUST_LABEL_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +PSYSTEM_PROCESS_TRUST_LABEL_ACE = POINTER(_SYSTEM_PROCESS_TRUST_LABEL_ACE) +SYSTEM_PROCESS_TRUST_LABEL_ACE = _SYSTEM_PROCESS_TRUST_LABEL_ACE + +class _SYSTEM_AUDIT_OBJECT_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("Flags", DWORD), + ("ObjectType", GUID), + ("InheritedObjectType", GUID), + ("SidStart", DWORD), + ] +SYSTEM_AUDIT_OBJECT_ACE = _SYSTEM_AUDIT_OBJECT_ACE +PSYSTEM_AUDIT_OBJECT_ACE = POINTER(_SYSTEM_AUDIT_OBJECT_ACE) + +class _SYSTEM_ALARM_OBJECT_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("Flags", DWORD), + ("ObjectType", GUID), + ("InheritedObjectType", GUID), + ("SidStart", DWORD), + ] +SYSTEM_ALARM_OBJECT_ACE = _SYSTEM_ALARM_OBJECT_ACE +PSYSTEM_ALARM_OBJECT_ACE = POINTER(_SYSTEM_ALARM_OBJECT_ACE) + +class _SYSTEM_AUDIT_CALLBACK_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +PSYSTEM_AUDIT_CALLBACK_ACE = POINTER(_SYSTEM_AUDIT_CALLBACK_ACE) +SYSTEM_AUDIT_CALLBACK_ACE = _SYSTEM_AUDIT_CALLBACK_ACE + +class _SYSTEM_ALARM_CALLBACK_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("SidStart", DWORD), + ] +SYSTEM_ALARM_CALLBACK_ACE = _SYSTEM_ALARM_CALLBACK_ACE +PSYSTEM_ALARM_CALLBACK_ACE = POINTER(_SYSTEM_ALARM_CALLBACK_ACE) + +class _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("Flags", DWORD), + ("ObjectType", GUID), + ("InheritedObjectType", GUID), + ("SidStart", DWORD), + ] +PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE = POINTER(_SYSTEM_AUDIT_CALLBACK_OBJECT_ACE) +SYSTEM_AUDIT_CALLBACK_OBJECT_ACE = _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE + +class _SYSTEM_ALARM_CALLBACK_OBJECT_ACE(Structure): + _fields_ = [ + ("Header", ACE_HEADER), + ("Mask", ACCESS_MASK), + ("Flags", DWORD), + ("ObjectType", GUID), + ("InheritedObjectType", GUID), + ("SidStart", DWORD), + ] +PSYSTEM_ALARM_CALLBACK_OBJECT_ACE = POINTER(_SYSTEM_ALARM_CALLBACK_OBJECT_ACE) +SYSTEM_ALARM_CALLBACK_OBJECT_ACE = _SYSTEM_ALARM_CALLBACK_OBJECT_ACE + +class _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION(Union): + _fields_ = [ + ("pInt64", DWORD * ANYSIZE_ARRAY), + ("pUint64", DWORD * ANYSIZE_ARRAY), + ("ppString", DWORD * ANYSIZE_ARRAY), + ("pFqbn", DWORD * ANYSIZE_ARRAY), + ("pOctetString", DWORD * ANYSIZE_ARRAY), + ] +CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION = _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION + +class _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1(Structure): + _fields_ = [ + ("Name", DWORD), + ("ValueType", WORD), + ("Reserved", WORD), + ("Flags", DWORD), + ("ValueCount", DWORD), + ("Values", CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_UNION), + ] +PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 = POINTER(_CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1) +CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 = _CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 + +class _CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE(Structure): + _fields_ = [ + ("Version", DWORD64), + ("Name", PWSTR), + ] +PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE = POINTER(_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE) +CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE = _CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE + +class _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE(Structure): + _fields_ = [ + ("pValue", PVOID), + ("ValueLength", DWORD), + ] +PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = POINTER(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE) +CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE + +class _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE(Structure): + _fields_ = [ + ("Length", DWORD), + ("OctetString", BYTE * ANYSIZE_ARRAY), + ] +PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE = POINTER(_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE) +CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE = _CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_RELATIVE + +class _CLAIM_SECURITY_ATTRIBUTE_V1_UNION(Union): + _fields_ = [ + ("pInt64", PLONG64), + ("pUint64", PDWORD64), + ("ppString", POINTER(PWSTR)), + ("pFqbn", PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE), + ("pOctetString", PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE), + ] +CLAIM_SECURITY_ATTRIBUTE_V1_UNION = _CLAIM_SECURITY_ATTRIBUTE_V1_UNION + +class _CLAIM_SECURITY_ATTRIBUTE_V1(Structure): + _fields_ = [ + ("Name", PWSTR), + ("ValueType", WORD), + ("Reserved", WORD), + ("Flags", DWORD), + ("ValueCount", DWORD), + ("Values", CLAIM_SECURITY_ATTRIBUTE_V1_UNION), + ] +CLAIM_SECURITY_ATTRIBUTE_V1 = _CLAIM_SECURITY_ATTRIBUTE_V1 +PCLAIM_SECURITY_ATTRIBUTE_V1 = POINTER(_CLAIM_SECURITY_ATTRIBUTE_V1) + +class _CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION(Union): + _fields_ = [ + ("pAttributeV1", PCLAIM_SECURITY_ATTRIBUTE_V1), + ] +CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION = _CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION + +class _CLAIM_SECURITY_ATTRIBUTES_INFORMATION(Structure): + _fields_ = [ + ("Version", WORD), + ("Reserved", WORD), + ("AttributeCount", DWORD), + ("Attribute", CLAIM_SECURITY_ATTRIBUTES_INFORMATION_UNION), + ] +CLAIM_SECURITY_ATTRIBUTES_INFORMATION = _CLAIM_SECURITY_ATTRIBUTES_INFORMATION +PCLAIM_SECURITY_ATTRIBUTES_INFORMATION = POINTER(_CLAIM_SECURITY_ATTRIBUTES_INFORMATION) + +class _SECURITY_DESCRIPTOR(Structure): + _fields_ = [ + ("Revision", BYTE), + ("Sbz1", BYTE), + ("Control", SECURITY_DESCRIPTOR_CONTROL), + ("Owner", PSID), + ("Group", PSID), + ("Sacl", PACL), + ("Dacl", PACL), + ] +PISECURITY_DESCRIPTOR = POINTER(_SECURITY_DESCRIPTOR) +SECURITY_DESCRIPTOR = _SECURITY_DESCRIPTOR + +class _GENERIC_MAPPING(Structure): + _fields_ = [ + ("GenericRead", ACCESS_MASK), + ("GenericWrite", ACCESS_MASK), + ("GenericExecute", ACCESS_MASK), + ("GenericAll", ACCESS_MASK), + ] +PGENERIC_MAPPING = POINTER(_GENERIC_MAPPING) +GENERIC_MAPPING = _GENERIC_MAPPING + +class _PRIVILEGE_SET(Structure): + _fields_ = [ + ("PrivilegeCount", DWORD), + ("Control", DWORD), + ("Privilege", LUID_AND_ATTRIBUTES * ANYSIZE_ARRAY), + ] +PRIVILEGE_SET = _PRIVILEGE_SET +PPRIVILEGE_SET = POINTER(_PRIVILEGE_SET) + +TokenInvalid = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenInvalid", 0x0) +TokenUser = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenUser", 0x1) +TokenGroups = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenGroups", 0x2) +TokenPrivileges = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenPrivileges", 0x3) +TokenOwner = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenOwner", 0x4) +TokenPrimaryGroup = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenPrimaryGroup", 0x5) +TokenDefaultDacl = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenDefaultDacl", 0x6) +TokenSource = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSource", 0x7) +TokenType = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenType", 0x8) +TokenImpersonationLevel = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenImpersonationLevel", 0x9) +TokenStatistics = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenStatistics", 0xa) +TokenRestrictedSids = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenRestrictedSids", 0xb) +TokenSessionId = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSessionId", 0xc) +TokenGroupsAndPrivileges = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenGroupsAndPrivileges", 0xd) +TokenSessionReference = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSessionReference", 0xe) +TokenSandBoxInert = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSandBoxInert", 0xf) +TokenAuditPolicy = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenAuditPolicy", 0x10) +TokenOrigin = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenOrigin", 0x11) +TokenElevationType = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenElevationType", 0x12) +TokenLinkedToken = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenLinkedToken", 0x13) +TokenElevation = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenElevation", 0x14) +TokenHasRestrictions = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenHasRestrictions", 0x15) +TokenAccessInformation = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenAccessInformation", 0x16) +TokenVirtualizationAllowed = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenVirtualizationAllowed", 0x17) +TokenVirtualizationEnabled = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenVirtualizationEnabled", 0x18) +TokenIntegrityLevel = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenIntegrityLevel", 0x19) +TokenUIAccess = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenUIAccess", 0x1a) +TokenMandatoryPolicy = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenMandatoryPolicy", 0x1b) +TokenLogonSid = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenLogonSid", 0x1c) +TokenIsAppContainer = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenIsAppContainer", 0x1d) +TokenCapabilities = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenCapabilities", 0x1e) +TokenAppContainerSid = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenAppContainerSid", 0x1f) +TokenAppContainerNumber = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenAppContainerNumber", 0x20) +TokenUserClaimAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenUserClaimAttributes", 0x21) +TokenDeviceClaimAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenDeviceClaimAttributes", 0x22) +TokenRestrictedUserClaimAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenRestrictedUserClaimAttributes", 0x23) +TokenRestrictedDeviceClaimAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenRestrictedDeviceClaimAttributes", 0x24) +TokenDeviceGroups = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenDeviceGroups", 0x25) +TokenRestrictedDeviceGroups = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenRestrictedDeviceGroups", 0x26) +TokenSecurityAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSecurityAttributes", 0x27) +TokenIsRestricted = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenIsRestricted", 0x28) +TokenProcessTrustLevel = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenProcessTrustLevel", 0x29) +TokenPrivateNameSpace = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenPrivateNameSpace", 0x2a) +TokenSingletonAttributes = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenSingletonAttributes", 0x2b) +TokenBnoIsolation = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenBnoIsolation", 0x2c) +TokenChildProcessFlags = EnumValue("_TOKEN_INFORMATION_CLASS", "TokenChildProcessFlags", 0x2d) +MaxTokenInfoClass = EnumValue("_TOKEN_INFORMATION_CLASS", "MaxTokenInfoClass", 0x2e) +class _TOKEN_INFORMATION_CLASS(EnumType): + values = [TokenInvalid, TokenUser, TokenGroups, TokenPrivileges, TokenOwner, TokenPrimaryGroup, TokenDefaultDacl, TokenSource, TokenType, TokenImpersonationLevel, TokenStatistics, TokenRestrictedSids, TokenSessionId, TokenGroupsAndPrivileges, TokenSessionReference, TokenSandBoxInert, TokenAuditPolicy, TokenOrigin, TokenElevationType, TokenLinkedToken, TokenElevation, TokenHasRestrictions, TokenAccessInformation, TokenVirtualizationAllowed, TokenVirtualizationEnabled, TokenIntegrityLevel, TokenUIAccess, TokenMandatoryPolicy, TokenLogonSid, TokenIsAppContainer, TokenCapabilities, TokenAppContainerSid, TokenAppContainerNumber, TokenUserClaimAttributes, TokenDeviceClaimAttributes, TokenRestrictedUserClaimAttributes, TokenRestrictedDeviceClaimAttributes, TokenDeviceGroups, TokenRestrictedDeviceGroups, TokenSecurityAttributes, TokenIsRestricted, TokenProcessTrustLevel, TokenPrivateNameSpace, TokenSingletonAttributes, TokenBnoIsolation, TokenChildProcessFlags, MaxTokenInfoClass] + mapper = FlagMapper(*values) +TOKEN_INFORMATION_CLASS = _TOKEN_INFORMATION_CLASS +PTOKEN_INFORMATION_CLASS = POINTER(_TOKEN_INFORMATION_CLASS) + + +TokenElevationTypeDefault = EnumValue("_TOKEN_ELEVATION_TYPE", "TokenElevationTypeDefault", 0x1) +TokenElevationTypeFull = EnumValue("_TOKEN_ELEVATION_TYPE", "TokenElevationTypeFull", 0x2) +TokenElevationTypeLimited = EnumValue("_TOKEN_ELEVATION_TYPE", "TokenElevationTypeLimited", 0x3) +class _TOKEN_ELEVATION_TYPE(EnumType): + values = [TokenElevationTypeDefault, TokenElevationTypeFull, TokenElevationTypeLimited] + mapper = FlagMapper(*values) +TOKEN_ELEVATION_TYPE = _TOKEN_ELEVATION_TYPE +PTOKEN_ELEVATION_TYPE = POINTER(_TOKEN_ELEVATION_TYPE) + + +class _TOKEN_PRIVILEGES(Structure): + _fields_ = [ + ("PrivilegeCount", DWORD), + ("Privileges", LUID_AND_ATTRIBUTES * ANYSIZE_ARRAY), + ] +TOKEN_PRIVILEGES = _TOKEN_PRIVILEGES +PTOKEN_PRIVILEGES = POINTER(_TOKEN_PRIVILEGES) + +class _TOKEN_ELEVATION(Structure): + _fields_ = [ + ("TokenIsElevated", DWORD), + ] +TOKEN_ELEVATION = _TOKEN_ELEVATION +PTOKEN_ELEVATION = POINTER(_TOKEN_ELEVATION) + +class _SID_AND_ATTRIBUTES(Structure): + _fields_ = [ + ("Sid", PSID), + ("Attributes", DWORD), + ] +SID_AND_ATTRIBUTES = _SID_AND_ATTRIBUTES +PSID_AND_ATTRIBUTES = POINTER(_SID_AND_ATTRIBUTES) + +_INITIAL_SID_AND_ATTRIBUTES = _SID_AND_ATTRIBUTES +class _SID_AND_ATTRIBUTES(_INITIAL_SID_AND_ATTRIBUTES): + pass + + # Only in TOKEN_GROUPS + # attributes = FlagExatractor(_INITIAL_SID_AND_ATTRIBUTES.Attributes, + # (SE_GROUP_MANDATORY, + # SE_GROUP_ENABLED_BY_DEFAULT, + # SE_GROUP_ENABLED, + # SE_GROUP_OWNER, + # SE_GROUP_USE_FOR_DENY_ONLY, + # SE_GROUP_INTEGRITY, + # SE_GROUP_INTEGRITY_ENABLED, + # SE_GROUP_LOGON_ID, + # SE_GROUP_RESOURCE)) +SID_AND_ATTRIBUTES = _SID_AND_ATTRIBUTES +PSID_AND_ATTRIBUTES = POINTER(_SID_AND_ATTRIBUTES) +class _TOKEN_MANDATORY_LABEL(Structure): + _fields_ = [ + ("Label", SID_AND_ATTRIBUTES), + ] +TOKEN_MANDATORY_LABEL = _TOKEN_MANDATORY_LABEL +PTOKEN_MANDATORY_LABEL = POINTER(_TOKEN_MANDATORY_LABEL) + +class _TOKEN_USER(Structure): + _fields_ = [ + ("User", SID_AND_ATTRIBUTES), + ] +PTOKEN_USER = POINTER(_TOKEN_USER) +TOKEN_USER = _TOKEN_USER + +class _TOKEN_DEFAULT_DACL(Structure): + _fields_ = [ + ("DefaultDacl", PACL), + ] +TOKEN_DEFAULT_DACL = _TOKEN_DEFAULT_DACL +PTOKEN_DEFAULT_DACL = POINTER(_TOKEN_DEFAULT_DACL) + +class _TOKEN_GROUPS(Structure): + _fields_ = [ + ("GroupCount", DWORD), + ("Groups", SID_AND_ATTRIBUTES * ANYSIZE_ARRAY), + ] +TOKEN_GROUPS = _TOKEN_GROUPS +PTOKEN_GROUPS = POINTER(_TOKEN_GROUPS) + +class _TOKEN_OWNER(Structure): + _fields_ = [ + ("Owner", PSID), + ] +TOKEN_OWNER = _TOKEN_OWNER +PTOKEN_OWNER = POINTER(_TOKEN_OWNER) + +class _TOKEN_PRIMARY_GROUP(Structure): + _fields_ = [ + ("PrimaryGroup", PSID), + ] +PTOKEN_PRIMARY_GROUP = POINTER(_TOKEN_PRIMARY_GROUP) +TOKEN_PRIMARY_GROUP = _TOKEN_PRIMARY_GROUP + +class _TOKEN_SOURCE(Structure): + _fields_ = [ + ("SourceName", CHAR * TOKEN_SOURCE_LENGTH), + ("SourceIdentifier", LUID), + ] +PTOKEN_SOURCE = POINTER(_TOKEN_SOURCE) +TOKEN_SOURCE = _TOKEN_SOURCE + +class _TOKEN_STATISTICS(Structure): + _fields_ = [ + ("TokenId", LUID), + ("AuthenticationId", LUID), + ("ExpirationTime", LARGE_INTEGER), + ("TokenType", TOKEN_TYPE), + ("ImpersonationLevel", SECURITY_IMPERSONATION_LEVEL), + ("DynamicCharged", DWORD), + ("DynamicAvailable", DWORD), + ("GroupCount", DWORD), + ("PrivilegeCount", DWORD), + ("ModifiedId", LUID), + ] +PTOKEN_STATISTICS = POINTER(_TOKEN_STATISTICS) +TOKEN_STATISTICS = _TOKEN_STATISTICS + +class _TOKEN_ORIGIN(Structure): + _fields_ = [ + ("OriginatingLogonSession", LUID), + ] +TOKEN_ORIGIN = _TOKEN_ORIGIN +PTOKEN_ORIGIN = POINTER(_TOKEN_ORIGIN) + +class _TOKEN_LINKED_TOKEN(Structure): + _fields_ = [ + ("LinkedToken", HANDLE), + ] +PTOKEN_LINKED_TOKEN = POINTER(_TOKEN_LINKED_TOKEN) +TOKEN_LINKED_TOKEN = _TOKEN_LINKED_TOKEN + +class _TOKEN_MANDATORY_POLICY(Structure): + _fields_ = [ + ("Policy", DWORD), + ] +TOKEN_MANDATORY_POLICY = _TOKEN_MANDATORY_POLICY +PTOKEN_MANDATORY_POLICY = POINTER(_TOKEN_MANDATORY_POLICY) + +class _SID_AND_ATTRIBUTES_HASH(Structure): + _fields_ = [ + ("SidCount", DWORD), + ("SidAttr", PSID_AND_ATTRIBUTES), + ("Hash", SID_HASH_ENTRY * SID_HASH_SIZE), + ] +SID_AND_ATTRIBUTES_HASH = _SID_AND_ATTRIBUTES_HASH +PSID_AND_ATTRIBUTES_HASH = POINTER(_SID_AND_ATTRIBUTES_HASH) + +class _TOKEN_APPCONTAINER_INFORMATION(Structure): + _fields_ = [ + ("TokenAppContainer", PSID), + ] +PTOKEN_APPCONTAINER_INFORMATION = POINTER(_TOKEN_APPCONTAINER_INFORMATION) +TOKEN_APPCONTAINER_INFORMATION = _TOKEN_APPCONTAINER_INFORMATION + +class _TOKEN_ACCESS_INFORMATION(Structure): + _fields_ = [ + ("SidHash", PSID_AND_ATTRIBUTES_HASH), + ("RestrictedSidHash", PSID_AND_ATTRIBUTES_HASH), + ("Privileges", PTOKEN_PRIVILEGES), + ("AuthenticationId", LUID), + ("TokenType", TOKEN_TYPE), + ("ImpersonationLevel", SECURITY_IMPERSONATION_LEVEL), + ("MandatoryPolicy", TOKEN_MANDATORY_POLICY), + ("Flags", DWORD), + ("AppContainerNumber", DWORD), + ("PackageSid", PSID), + ("CapabilitiesHash", PSID_AND_ATTRIBUTES_HASH), + ("TrustLevelSid", PSID), + ("SecurityAttributes", PSECURITY_ATTRIBUTES_OPAQUE), + ] +PTOKEN_ACCESS_INFORMATION = POINTER(_TOKEN_ACCESS_INFORMATION) +TOKEN_ACCESS_INFORMATION = _TOKEN_ACCESS_INFORMATION + +class _TOKEN_GROUPS_AND_PRIVILEGES(Structure): + _fields_ = [ + ("SidCount", DWORD), + ("SidLength", DWORD), + ("Sids", PSID_AND_ATTRIBUTES), + ("RestrictedSidCount", DWORD), + ("RestrictedSidLength", DWORD), + ("RestrictedSids", PSID_AND_ATTRIBUTES), + ("PrivilegeCount", DWORD), + ("PrivilegeLength", DWORD), + ("Privileges", PLUID_AND_ATTRIBUTES), + ("AuthenticationId", LUID), + ] +TOKEN_GROUPS_AND_PRIVILEGES = _TOKEN_GROUPS_AND_PRIVILEGES +PTOKEN_GROUPS_AND_PRIVILEGES = POINTER(_TOKEN_GROUPS_AND_PRIVILEGES) + +class _TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE(Structure): + _fields_ = [ + ("Version", ULONG64), + ("Name", UNICODE_STRING), + ] +PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE = POINTER(_TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE) +TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE = _TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE + +class _TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE(Structure): + _fields_ = [ + ("pValue", PVOID), + ("ValueLength", ULONG), + ] +PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = POINTER(_TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE) +TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = _TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE + +class _TOKEN_SECURITY_ATTRIBUTE_V1_UNION(Union): + _fields_ = [ + ("pInt64", PLONG64), + ("pUint64", PULONG64), + ("pString", PUNICODE_STRING), + ("pFqbn", PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE), + ("pOctetString", PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE), + ] +TOKEN_SECURITY_ATTRIBUTE_V1_UNION = _TOKEN_SECURITY_ATTRIBUTE_V1_UNION + +class _TOKEN_SECURITY_ATTRIBUTE_V1(Structure): + _fields_ = [ + ("Name", UNICODE_STRING), + ("ValueType", USHORT), + ("Reserved", USHORT), + ("Flags", ULONG), + ("ValueCount", ULONG), + ("Values", TOKEN_SECURITY_ATTRIBUTE_V1_UNION), + ] +TOKEN_SECURITY_ATTRIBUTE_V1 = _TOKEN_SECURITY_ATTRIBUTE_V1 +PTOKEN_SECURITY_ATTRIBUTE_V1 = POINTER(_TOKEN_SECURITY_ATTRIBUTE_V1) + +class _TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION(Union): + _fields_ = [ + ("pAttributeV1", PTOKEN_SECURITY_ATTRIBUTE_V1), + ] +TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION = _TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION + +class _TOKEN_SECURITY_ATTRIBUTES_INFORMATION(Structure): + _fields_ = [ + ("Version", USHORT), + ("Reserved", USHORT), + ("AttributeCount", ULONG), + ("Attribute", TOKEN_SECURITY_ATTRIBUTES_INFORMATION_UNION), + ] +PTOKEN_SECURITY_ATTRIBUTES_INFORMATION = POINTER(_TOKEN_SECURITY_ATTRIBUTES_INFORMATION) +TOKEN_SECURITY_ATTRIBUTES_INFORMATION = _TOKEN_SECURITY_ATTRIBUTES_INFORMATION + +BG_JOB_STATE_QUEUED = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_QUEUED", 0x0) +BG_JOB_STATE_CONNECTING = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_CONNECTING", 0x1) +BG_JOB_STATE_TRANSFERRING = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_TRANSFERRING", 0x2) +BG_JOB_STATE_SUSPENDED = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_SUSPENDED", 0x3) +BG_JOB_STATE_ERROR = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_ERROR", 0x4) +BG_JOB_STATE_TRANSIENT_ERROR = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_TRANSIENT_ERROR", 0x5) +BG_JOB_STATE_TRANSFERRED = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_TRANSFERRED", 0x6) +BG_JOB_STATE_ACKNOWLEDGED = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_ACKNOWLEDGED", 0x7) +BG_JOB_STATE_CANCELLED = EnumValue("_BG_JOB_STATE", "BG_JOB_STATE_CANCELLED", 0x8) +class _BG_JOB_STATE(EnumType): + values = [BG_JOB_STATE_QUEUED, BG_JOB_STATE_CONNECTING, BG_JOB_STATE_TRANSFERRING, BG_JOB_STATE_SUSPENDED, BG_JOB_STATE_ERROR, BG_JOB_STATE_TRANSIENT_ERROR, BG_JOB_STATE_TRANSFERRED, BG_JOB_STATE_ACKNOWLEDGED, BG_JOB_STATE_CANCELLED] + mapper = FlagMapper(*values) +BG_JOB_STATE = _BG_JOB_STATE + + +BG_JOB_PROXY_USAGE_PRECONFIG = EnumValue("_BG_JOB_PROXY_USAGE", "BG_JOB_PROXY_USAGE_PRECONFIG", 0x0) +BG_JOB_PROXY_USAGE_NO_PROXY = EnumValue("_BG_JOB_PROXY_USAGE", "BG_JOB_PROXY_USAGE_NO_PROXY", 0x1) +BG_JOB_PROXY_USAGE_OVERRIDE = EnumValue("_BG_JOB_PROXY_USAGE", "BG_JOB_PROXY_USAGE_OVERRIDE", 0x2) +BG_JOB_PROXY_USAGE_AUTODETECT = EnumValue("_BG_JOB_PROXY_USAGE", "BG_JOB_PROXY_USAGE_AUTODETECT", 0x3) +class _BG_JOB_PROXY_USAGE(EnumType): + values = [BG_JOB_PROXY_USAGE_PRECONFIG, BG_JOB_PROXY_USAGE_NO_PROXY, BG_JOB_PROXY_USAGE_OVERRIDE, BG_JOB_PROXY_USAGE_AUTODETECT] + mapper = FlagMapper(*values) +BG_JOB_PROXY_USAGE = _BG_JOB_PROXY_USAGE + + +BG_JOB_PRIORITY_FOREGROUND = EnumValue("_BG_JOB_PRIORITY", "BG_JOB_PRIORITY_FOREGROUND", 0x0) +BG_JOB_PRIORITY_HIGH = EnumValue("_BG_JOB_PRIORITY", "BG_JOB_PRIORITY_HIGH", 0x1) +BG_JOB_PRIORITY_NORMAL = EnumValue("_BG_JOB_PRIORITY", "BG_JOB_PRIORITY_NORMAL", 0x2) +BG_JOB_PRIORITY_LOW = EnumValue("_BG_JOB_PRIORITY", "BG_JOB_PRIORITY_LOW", 0x3) +class _BG_JOB_PRIORITY(EnumType): + values = [BG_JOB_PRIORITY_FOREGROUND, BG_JOB_PRIORITY_HIGH, BG_JOB_PRIORITY_NORMAL, BG_JOB_PRIORITY_LOW] + mapper = FlagMapper(*values) +BG_JOB_PRIORITY = _BG_JOB_PRIORITY + + +BG_ERROR_CONTEXT_NONE = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_NONE", 0x0) +BG_ERROR_CONTEXT_UNKNOWN = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_UNKNOWN", 0x1) +BG_ERROR_CONTEXT_GENERAL_QUEUE_MANAGER = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_GENERAL_QUEUE_MANAGER", 0x2) +BG_ERROR_CONTEXT_QUEUE_MANAGER_NOTIFICATION = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_QUEUE_MANAGER_NOTIFICATION", 0x3) +BG_ERROR_CONTEXT_LOCAL_FILE = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_LOCAL_FILE", 0x4) +BG_ERROR_CONTEXT_REMOTE_FILE = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_REMOTE_FILE", 0x5) +BG_ERROR_CONTEXT_GENERAL_TRANSPORT = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_GENERAL_TRANSPORT", 0x6) +BG_ERROR_CONTEXT_REMOTE_APPLICATION = EnumValue("_BG_ERROR_CONTEXT", "BG_ERROR_CONTEXT_REMOTE_APPLICATION", 0x7) +class _BG_ERROR_CONTEXT(EnumType): + values = [BG_ERROR_CONTEXT_NONE, BG_ERROR_CONTEXT_UNKNOWN, BG_ERROR_CONTEXT_GENERAL_QUEUE_MANAGER, BG_ERROR_CONTEXT_QUEUE_MANAGER_NOTIFICATION, BG_ERROR_CONTEXT_LOCAL_FILE, BG_ERROR_CONTEXT_REMOTE_FILE, BG_ERROR_CONTEXT_GENERAL_TRANSPORT, BG_ERROR_CONTEXT_REMOTE_APPLICATION] + mapper = FlagMapper(*values) +BG_ERROR_CONTEXT = _BG_ERROR_CONTEXT + + +BG_JOB_TYPE_DOWNLOAD = EnumValue("_BG_JOB_TYPE", "BG_JOB_TYPE_DOWNLOAD", 0x0) +BG_JOB_TYPE_UPLOAD = EnumValue("_BG_JOB_TYPE", "BG_JOB_TYPE_UPLOAD", 0x1) +BG_JOB_TYPE_UPLOAD_REPLY = EnumValue("_BG_JOB_TYPE", "BG_JOB_TYPE_UPLOAD_REPLY", 0x2) +class _BG_JOB_TYPE(EnumType): + values = [BG_JOB_TYPE_DOWNLOAD, BG_JOB_TYPE_UPLOAD, BG_JOB_TYPE_UPLOAD_REPLY] + mapper = FlagMapper(*values) +BG_JOB_TYPE = _BG_JOB_TYPE + + +class _BG_FILE_PROGRESS(Structure): + _fields_ = [ + ("BytesTotal", UINT64), + ("BytesTransferred", UINT64), + ("Completed", BOOL), + ] +BG_FILE_PROGRESS = _BG_FILE_PROGRESS + +class _BG_JOB_PROGRESS(Structure): + _fields_ = [ + ("BytesTotal", UINT64), + ("BytesTransferred", UINT64), + ("FilesTotal", ULONG), + ("FilesTransferred", ULONG), + ] +BG_JOB_PROGRESS = _BG_JOB_PROGRESS + +class _BG_FILE_INFO(Structure): + _fields_ = [ + ("RemoteName", LPWSTR), + ("LocalName", LPWSTR), + ] +BG_FILE_INFO = _BG_FILE_INFO + +class _BG_JOB_TIMES(Structure): + _fields_ = [ + ("CreationTime", FILETIME), + ("ModificationTime", FILETIME), + ("TransferCompletionTime", FILETIME), + ] +BG_JOB_TIMES = _BG_JOB_TIMES + +class _API_SET_VALUE_ENTRY(Structure): + _fields_ = [ + ("Flags", ULONG), + ("NameOffset", ULONG), + ("NameLength", ULONG), + ("ValueOffset", ULONG), + ("ValueLength", ULONG), + ] +API_SET_VALUE_ENTRY = _API_SET_VALUE_ENTRY +PAPI_SET_VALUE_ENTRY = POINTER(_API_SET_VALUE_ENTRY) + +class _API_SET_NAMESPACE_ENTRY(Structure): + _fields_ = [ + ("Flags", ULONG), + ("NameOffset", ULONG), + ("NameLength", ULONG), + ("AliasOffset", ULONG), + ("AliasLength", ULONG), + ("DataOffset", ULONG), + ] +PAPI_SET_NAMESPACE_ENTRY = POINTER(_API_SET_NAMESPACE_ENTRY) +API_SET_NAMESPACE_ENTRY = _API_SET_NAMESPACE_ENTRY + +class _API_SET_NAMESPACE_ARRAY(Structure): + _fields_ = [ + ("Version", ULONG), + ("Size", ULONG), + ("Flags", ULONG), + ("Count", ULONG), + ("Array", API_SET_NAMESPACE_ENTRY * ANYSIZE_ARRAY), + ] +PAPI_SET_NAMESPACE_ARRAY = POINTER(_API_SET_NAMESPACE_ARRAY) +API_SET_NAMESPACE_ARRAY = _API_SET_NAMESPACE_ARRAY + +class _API_SET_VALUE_ENTRY_V2(Structure): + _fields_ = [ + ("NameOffset", ULONG), + ("NameLength", ULONG), + ("ValueOffset", ULONG), + ("ValueLength", ULONG), + ] +PAPI_SET_VALUE_ENTRY_V2 = POINTER(_API_SET_VALUE_ENTRY_V2) +API_SET_VALUE_ENTRY_V2 = _API_SET_VALUE_ENTRY_V2 + +class _API_SET_VALUE_ARRAY_V2(Structure): + _fields_ = [ + ("Count", ULONG), + ("Array", API_SET_VALUE_ENTRY_V2 * ANYSIZE_ARRAY), + ] +API_SET_VALUE_ARRAY_V2 = _API_SET_VALUE_ARRAY_V2 +PAPI_SET_VALUE_ARRAY_V2 = POINTER(_API_SET_VALUE_ARRAY_V2) + +class _API_SET_NAMESPACE_ENTRY_V2(Structure): + _fields_ = [ + ("NameOffset", ULONG), + ("NameLength", ULONG), + ("DataOffset", ULONG), + ] +PAPI_SET_NAMESPACE_ENTRY_V2 = POINTER(_API_SET_NAMESPACE_ENTRY_V2) +API_SET_NAMESPACE_ENTRY_V2 = _API_SET_NAMESPACE_ENTRY_V2 + +class _API_SET_NAMESPACE_ARRAY_V2(Structure): + _fields_ = [ + ("Version", ULONG), + ("Count", ULONG), + ("Array", API_SET_NAMESPACE_ENTRY_V2 * ANYSIZE_ARRAY), + ] +API_SET_NAMESPACE_ARRAY_V2 = _API_SET_NAMESPACE_ARRAY_V2 +PAPI_SET_NAMESPACE_ARRAY_V2 = POINTER(_API_SET_NAMESPACE_ARRAY_V2) + +class _API_SET_VALUE_ARRAY_V4(Structure): + _fields_ = [ + ("GuessFlags", ULONG), + ("Count", ULONG), + ("Array", API_SET_VALUE_ENTRY_V2 * ANYSIZE_ARRAY), + ] +API_SET_VALUE_ARRAY_V4 = _API_SET_VALUE_ARRAY_V4 +PAPI_SET_VALUE_ARRAY_V2 = POINTER(_API_SET_VALUE_ARRAY_V4) + +class _API_SET_NAMESPACE_ARRAY_V4(Structure): + _fields_ = [ + ("Version", ULONG), + ("Size", ULONG), + ("Flags", ULONG), + ("Count", ULONG), + ("Array", API_SET_NAMESPACE_ENTRY * ANYSIZE_ARRAY), + ] +API_SET_NAMESPACE_ARRAY_V4 = _API_SET_NAMESPACE_ARRAY_V4 +PAPI_SET_NAMESPACE_ARRAY_V4 = POINTER(_API_SET_NAMESPACE_ARRAY_V4) + +class _API_SET_NAMESPACE_ENTRY_V4(Structure): + _fields_ = [ + ("Flags", ULONG), + ("NameOffset", ULONG), + ("NameLength", ULONG), + ("AliasOffset", ULONG), + ("AliasLength", ULONG), + ("DataOffset", ULONG), + ] +PAPI_SET_NAMESPACE_ENTRY_V4 = POINTER(_API_SET_NAMESPACE_ENTRY_V4) +API_SET_NAMESPACE_ENTRY_V4 = _API_SET_NAMESPACE_ENTRY_V4 + +class _API_SET_NAMESPACE_ENTRY_V6(Structure): + _fields_ = [ + ("Flags", ULONG), + ("NameOffset", ULONG), + ("NameLength", ULONG), + ("HashedLength", ULONG), + ("ValueOffset", ULONG), + ("ValueCount", ULONG), + ] +API_SET_NAMESPACE_ENTRY_V6 = _API_SET_NAMESPACE_ENTRY_V6 + +class _API_SET_NAMESPACE_V6(Structure): + _fields_ = [ + ("Version", ULONG), + ("Size", ULONG), + ("Flags", ULONG), + ("Count", ULONG), + ("EntryOffset", ULONG), + ("HashOffset", ULONG), + ("HashFactor", ULONG), + ] +API_SET_NAMESPACE_V6 = _API_SET_NAMESPACE_V6 + +class _CERT_STRONG_SIGN_SERIALIZED_INFO(Structure): + _fields_ = [ + ("dwFlags", DWORD), + ("pwszCNGSignHashAlgids", LPWSTR), + ("pwszCNGPubKeyMinBitLengths", LPWSTR), + ] +CERT_STRONG_SIGN_SERIALIZED_INFO = _CERT_STRONG_SIGN_SERIALIZED_INFO +PCERT_STRONG_SIGN_SERIALIZED_INFO = POINTER(_CERT_STRONG_SIGN_SERIALIZED_INFO) + +class TMP_CERT_STRONG_SIGN_PARA_UNION_TYPE(Union): + _fields_ = [ + ("pvInfo", PVOID), + ("pSerializedInfo", PCERT_STRONG_SIGN_SERIALIZED_INFO), + ("pszOID", LPSTR), + ] + + +class _CERT_STRONG_SIGN_PARA(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("dwInfoChoice", DWORD), + ("tmp_union", TMP_CERT_STRONG_SIGN_PARA_UNION_TYPE), + ] +CERT_STRONG_SIGN_PARA = _CERT_STRONG_SIGN_PARA +PCCERT_STRONG_SIGN_PARA = POINTER(_CERT_STRONG_SIGN_PARA) +PCERT_STRONG_SIGN_PARA = POINTER(_CERT_STRONG_SIGN_PARA) + +class _CRYPTOAPI_BLOB(Structure): + _fields_ = [ + ("cbData", DWORD), + ("pbData", POINTER(BYTE)), + ] +CRYPT_INTEGER_BLOB = _CRYPTOAPI_BLOB +PCRYPT_DATA_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_OBJID_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_DER_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRL_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_UINT_BLOB = POINTER(_CRYPTOAPI_BLOB) +CERT_NAME_BLOB = _CRYPTOAPI_BLOB +PCRYPT_DIGEST_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_INTEGER_BLOB = POINTER(_CRYPTOAPI_BLOB) +CERT_RDN_VALUE_BLOB = _CRYPTOAPI_BLOB +PCERT_NAME_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_HASH_BLOB = POINTER(_CRYPTOAPI_BLOB) +CRYPT_DATA_BLOB = _CRYPTOAPI_BLOB +DATA_BLOB = _CRYPTOAPI_BLOB +CRYPT_UINT_BLOB = _CRYPTOAPI_BLOB +PCERT_RDN_VALUE_BLOB = POINTER(_CRYPTOAPI_BLOB) +CRYPT_HASH_BLOB = _CRYPTOAPI_BLOB +CRL_BLOB = _CRYPTOAPI_BLOB +PCERT_BLOB = POINTER(_CRYPTOAPI_BLOB) +CRYPT_DIGEST_BLOB = _CRYPTOAPI_BLOB +CRYPT_OBJID_BLOB = _CRYPTOAPI_BLOB +CERT_BLOB = _CRYPTOAPI_BLOB +CRYPT_DER_BLOB = _CRYPTOAPI_BLOB +PDATA_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_ATTR_BLOB = POINTER(_CRYPTOAPI_BLOB) +CRYPT_ATTR_BLOB = _CRYPTOAPI_BLOB + +class _CRYPTOAPI_BLOB(_CRYPTOAPI_BLOB): + @classmethod + def from_string(cls, buf): + self = cls() + self.cbData = len(buf) + self.pbData = (BYTE * self.cbData)(*bytearray(buf)) + return self + + @property + def data(self): + return bytearray(self.pbData[:self.cbData]) +CRYPT_INTEGER_BLOB = _CRYPTOAPI_BLOB +PCRYPT_DATA_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_OBJID_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_DER_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRL_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_UINT_BLOB = POINTER(_CRYPTOAPI_BLOB) +CERT_NAME_BLOB = _CRYPTOAPI_BLOB +PCRYPT_DIGEST_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_INTEGER_BLOB = POINTER(_CRYPTOAPI_BLOB) +CERT_RDN_VALUE_BLOB = _CRYPTOAPI_BLOB +PCERT_NAME_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_HASH_BLOB = POINTER(_CRYPTOAPI_BLOB) +CRYPT_DATA_BLOB = _CRYPTOAPI_BLOB +DATA_BLOB = _CRYPTOAPI_BLOB +CRYPT_UINT_BLOB = _CRYPTOAPI_BLOB +PCERT_RDN_VALUE_BLOB = POINTER(_CRYPTOAPI_BLOB) +CRYPT_HASH_BLOB = _CRYPTOAPI_BLOB +CRL_BLOB = _CRYPTOAPI_BLOB +PCERT_BLOB = POINTER(_CRYPTOAPI_BLOB) +CRYPT_DIGEST_BLOB = _CRYPTOAPI_BLOB +CRYPT_OBJID_BLOB = _CRYPTOAPI_BLOB +CERT_BLOB = _CRYPTOAPI_BLOB +CRYPT_DER_BLOB = _CRYPTOAPI_BLOB +PDATA_BLOB = POINTER(_CRYPTOAPI_BLOB) +PCRYPT_ATTR_BLOB = POINTER(_CRYPTOAPI_BLOB) +CRYPT_ATTR_BLOB = _CRYPTOAPI_BLOB +class CRYPTCATATTRIBUTE_(Structure): + _fields_ = [ + ("cbStruct", DWORD), + ("pwszReferenceTag", LPWSTR), + ("dwAttrTypeAndAction", DWORD), + ("cbValue", DWORD), + ("pbValue", POINTER(BYTE)), + ("dwReserved", DWORD), + ] +CRYPTCATATTRIBUTE = CRYPTCATATTRIBUTE_ +PCRYPTCATATTRIBUTE = POINTER(CRYPTCATATTRIBUTE_) + +class _CRYPT_ATTRIBUTE_TYPE_VALUE(Structure): + _fields_ = [ + ("pszObjId", LPSTR), + ("Value", CRYPT_OBJID_BLOB), + ] +CRYPT_ATTRIBUTE_TYPE_VALUE = _CRYPT_ATTRIBUTE_TYPE_VALUE +PCRYPT_ATTRIBUTE_TYPE_VALUE = POINTER(_CRYPT_ATTRIBUTE_TYPE_VALUE) + +class _CRYPT_ALGORITHM_IDENTIFIER(Structure): + _fields_ = [ + ("pszObjId", LPSTR), + ("Parameters", CRYPT_OBJID_BLOB), + ] +CRYPT_ALGORITHM_IDENTIFIER = _CRYPT_ALGORITHM_IDENTIFIER +PCRYPT_ALGORITHM_IDENTIFIER = POINTER(_CRYPT_ALGORITHM_IDENTIFIER) + +class SIP_INDIRECT_DATA_(Structure): + _fields_ = [ + ("Data", CRYPT_ATTRIBUTE_TYPE_VALUE), + ("DigestAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("Digest", CRYPT_HASH_BLOB), + ] +SIP_INDIRECT_DATA = SIP_INDIRECT_DATA_ +PSIP_INDIRECT_DATA = POINTER(SIP_INDIRECT_DATA_) + +class CRYPTCATMEMBER_(Structure): + _fields_ = [ + ("cbStruct", DWORD), + ("pwszReferenceTag", LPWSTR), + ("pwszFileName", LPWSTR), + ("gSubjectType", GUID), + ("fdwMemberFlags", DWORD), + ("pIndirectData", POINTER(SIP_INDIRECT_DATA)), + ("dwCertVersion", DWORD), + ("dwReserved", DWORD), + ("hReserved", HANDLE), + ("sEncodedIndirectData", CRYPT_ATTR_BLOB), + ("sEncodedMemberInfo", CRYPT_ATTR_BLOB), + ] +CRYPTCATMEMBER = CRYPTCATMEMBER_ +PCRYPTCATMEMBER = POINTER(CRYPTCATMEMBER_) + +class WINTRUST_FILE_INFO_(Structure): + _fields_ = [ + ("cbStruct", DWORD), + ("pcwszFilePath", LPCWSTR), + ("hFile", HANDLE), + ("pgKnownSubject", POINTER(GUID)), + ] +WINTRUST_FILE_INFO = WINTRUST_FILE_INFO_ +PWINTRUST_FILE_INFO = POINTER(WINTRUST_FILE_INFO_) + +class _CRYPT_ATTRIBUTE(Structure): + _fields_ = [ + ("pszObjId", LPSTR), + ("cValue", DWORD), + ("rgValue", PCRYPT_ATTR_BLOB), + ] +PCRYPT_ATTRIBUTE = POINTER(_CRYPT_ATTRIBUTE) +CRYPT_ATTRIBUTE = _CRYPT_ATTRIBUTE + +OLD_CRYPT_ATTRIBUTE = _CRYPT_ATTRIBUTE + +class _CRYPT_ATTRIBUTE(_CRYPT_ATTRIBUTE): + @property + def count(self): # __len__ ? + return self.cValue + + @property + def values(self): + return self.rgValue[:self.cValue] + + @property + def objid(self): + # SZOID_MAPPER defined in the generated structures template.py + return SZOID_MAPPER[self.pszObjId] + + def __repr__(self): + # return """<{0} pszObjId={1!r} Values={2}>""".format(type(self).__name__, self.objid, self.cValue) + if not self.pszObjId in SZOID_MAPPER: + return """<{0} pszObjId="{1}" Values={2}>""".format(type(self).__name__, self.pszObjId, self.cValue) + flag = SZOID_MAPPER[self.pszObjId] + return """<{0} pszObjId="{1}" ({2}) Values={3}>""".format(type(self).__name__, flag, flag.name, self.cValue) +PCRYPT_ATTRIBUTE = POINTER(_CRYPT_ATTRIBUTE) +CRYPT_ATTRIBUTE = _CRYPT_ATTRIBUTE +class _CTL_ENTRY(Structure): + _fields_ = [ + ("SubjectIdentifier", CRYPT_DATA_BLOB), + ("cAttribute", DWORD), + ("rgAttribute", PCRYPT_ATTRIBUTE), + ] +PCTL_ENTRY = POINTER(_CTL_ENTRY) +CTL_ENTRY = _CTL_ENTRY + +class _CRYPT_ATTRIBUTE(Structure): + _fields_ = [ + ("pszObjId", LPSTR), + ("cValue", DWORD), + ("rgValue", PCRYPT_ATTR_BLOB), + ] +PCRYPT_ATTRIBUTE = POINTER(_CRYPT_ATTRIBUTE) +CRYPT_ATTRIBUTE = _CRYPT_ATTRIBUTE + +OLD_CRYPT_ATTRIBUTE = _CRYPT_ATTRIBUTE + +class _CRYPT_ATTRIBUTE(_CRYPT_ATTRIBUTE): + @property + def count(self): # __len__ ? + return self.cValue + + @property + def values(self): + return self.rgValue[:self.cValue] + + @property + def objid(self): + # SZOID_MAPPER defined in the generated structures template.py + return SZOID_MAPPER[self.pszObjId] + + def __repr__(self): + # return """<{0} pszObjId={1!r} Values={2}>""".format(type(self).__name__, self.objid, self.cValue) + if not self.pszObjId in SZOID_MAPPER: + return """<{0} pszObjId="{1}" Values={2}>""".format(type(self).__name__, self.pszObjId, self.cValue) + flag = SZOID_MAPPER[self.pszObjId] + return """<{0} pszObjId="{1}" ({2}) Values={3}>""".format(type(self).__name__, flag, flag.name, self.cValue) +PCRYPT_ATTRIBUTE = POINTER(_CRYPT_ATTRIBUTE) +CRYPT_ATTRIBUTE = _CRYPT_ATTRIBUTE +class _CRYPT_ATTRIBUTES(Structure): + _fields_ = [ + ("cAttr", DWORD), + ("rgAttr", PCRYPT_ATTRIBUTE), + ] +CRYPT_ATTRIBUTES = _CRYPT_ATTRIBUTES +PCRYPT_ATTRIBUTES = POINTER(_CRYPT_ATTRIBUTES) + +OLD_CRYPT_ATTRIBUTES = _CRYPT_ATTRIBUTES +class _CRYPT_ATTRIBUTES(_CRYPT_ATTRIBUTES): + @property + def count(self): # __len__ ? + return self.cAttr + + @property + def attributes(self): + return self.rgAttr[:self.cAttr] + + def __getitem__(self, oid): + return [x for x in self.attributes if x.pszObjId == oid] + + def __repr__(self): + return """<{0} Attributes={1}>""".format(type(self).__name__, self.cAttr) +CRYPT_ATTRIBUTES = _CRYPT_ATTRIBUTES +PCRYPT_ATTRIBUTES = POINTER(_CRYPT_ATTRIBUTES) +class _CERT_EXTENSION(Structure): + _fields_ = [ + ("pszObjId", LPSTR), + ("fCritical", BOOL), + ("Value", CRYPT_OBJID_BLOB), + ] +CERT_EXTENSION = _CERT_EXTENSION +PCERT_EXTENSION = POINTER(_CERT_EXTENSION) + +class _CRL_ENTRY(Structure): + _fields_ = [ + ("SerialNumber", CRYPT_INTEGER_BLOB), + ("RevocationDate", FILETIME), + ("cExtension", DWORD), + ("rgExtension", PCERT_EXTENSION), + ] +CRL_ENTRY = _CRL_ENTRY +PCRL_ENTRY = POINTER(_CRL_ENTRY) + +class _CRL_INFO(Structure): + _fields_ = [ + ("dwVersion", DWORD), + ("SignatureAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("Issuer", CERT_NAME_BLOB), + ("ThisUpdate", FILETIME), + ("NextUpdate", FILETIME), + ("cCRLEntry", DWORD), + ("rgCRLEntry", PCRL_ENTRY), + ("cExtension", DWORD), + ("rgExtension", PCERT_EXTENSION), + ] +CRL_INFO = _CRL_INFO +PCRL_INFO = POINTER(_CRL_INFO) + +class _CRL_CONTEXT(Structure): + _fields_ = [ + ("dwCertEncodingType", DWORD), + ("pbCrlEncoded", POINTER(BYTE)), + ("cbCrlEncoded", DWORD), + ("pCrlInfo", PCRL_INFO), + ("hCertStore", HCERTSTORE), + ] +PCCRL_CONTEXT = POINTER(_CRL_CONTEXT) +CRL_CONTEXT = _CRL_CONTEXT +PCRL_CONTEXT = POINTER(_CRL_CONTEXT) + +class _CMSG_SIGNER_INFO(Structure): + _fields_ = [ + ("dwVersion", DWORD), + ("Issuer", CERT_NAME_BLOB), + ("SerialNumber", CRYPT_INTEGER_BLOB), + ("HashAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("HashEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("EncryptedHash", CRYPT_DATA_BLOB), + ("AuthAttrs", CRYPT_ATTRIBUTES), + ("UnauthAttrs", CRYPT_ATTRIBUTES), + ] +CMSG_SIGNER_INFO = _CMSG_SIGNER_INFO +PCMSG_SIGNER_INFO = POINTER(_CMSG_SIGNER_INFO) + +class _CTL_USAGE(Structure): + _fields_ = [ + ("cUsageIdentifier", DWORD), + ("rgpszUsageIdentifier", POINTER(LPSTR)), + ] +CERT_ENHKEY_USAGE = _CTL_USAGE +PCTL_USAGE = POINTER(_CTL_USAGE) +CTL_USAGE = _CTL_USAGE +PCERT_ENHKEY_USAGE = POINTER(_CTL_USAGE) + +class _CTL_INFO(Structure): + _fields_ = [ + ("dwVersion", DWORD), + ("SubjectUsage", CTL_USAGE), + ("ListIdentifier", CRYPT_DATA_BLOB), + ("SequenceNumber", CRYPT_INTEGER_BLOB), + ("ThisUpdate", FILETIME), + ("NextUpdate", FILETIME), + ("SubjectAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("cCTLEntry", DWORD), + ("rgCTLEntry", PCTL_ENTRY), + ("cExtension", DWORD), + ("rgExtension", PCERT_EXTENSION), + ] +CTL_INFO = _CTL_INFO +PCTL_INFO = POINTER(_CTL_INFO) + +class _CTL_CONTEXT(Structure): + _fields_ = [ + ("dwMsgAndCertEncodingType", DWORD), + ("pbCtlEncoded", POINTER(BYTE)), + ("cbCtlEncoded", DWORD), + ("pCtlInfo", PCTL_INFO), + ("hCertStore", HCERTSTORE), + ("hCryptMsg", HCRYPTMSG), + ("pbCtlContent", POINTER(BYTE)), + ("cbCtlContent", DWORD), + ] +PCTL_CONTEXT = POINTER(_CTL_CONTEXT) +CTL_CONTEXT = _CTL_CONTEXT +PCCTL_CONTEXT = POINTER(_CTL_CONTEXT) + +class WINTRUST_CATALOG_INFO_(Structure): + _fields_ = [ + ("cbStruct", DWORD), + ("dwCatalogVersion", DWORD), + ("pcwszCatalogFilePath", LPCWSTR), + ("pcwszMemberTag", LPCWSTR), + ("pcwszMemberFilePath", LPCWSTR), + ("hMemberFile", HANDLE), + ("pbCalculatedFileHash", POINTER(BYTE)), + ("cbCalculatedFileHash", DWORD), + ("pcCatalogContext", PCCTL_CONTEXT), + ] +PWINTRUST_CATALOG_INFO = POINTER(WINTRUST_CATALOG_INFO_) +WINTRUST_CATALOG_INFO = WINTRUST_CATALOG_INFO_ + +class WINTRUST_BLOB_INFO_(Structure): + _fields_ = [ + ("cbStruct", DWORD), + ("gSubject", GUID), + ("pcwszDisplayName", LPCWSTR), + ("cbMemObject", DWORD), + ("pbMemObject", POINTER(BYTE)), + ("cbMemSignedMsg", DWORD), + ("pbMemSignedMsg", POINTER(BYTE)), + ] +PWINTRUST_BLOB_INFO = POINTER(WINTRUST_BLOB_INFO_) +WINTRUST_BLOB_INFO = WINTRUST_BLOB_INFO_ + +class _CRYPT_BIT_BLOB(Structure): + _fields_ = [ + ("cbData", DWORD), + ("pbData", POINTER(BYTE)), + ("cUnusedBits", DWORD), + ] +CRYPT_BIT_BLOB = _CRYPT_BIT_BLOB +PCRYPT_BIT_BLOB = POINTER(_CRYPT_BIT_BLOB) + +class _CRYPT_BIT_BLOB(_CRYPT_BIT_BLOB): + @property + def data(self): + return bytearray(self.pbData[:self.cbData]) +CRYPT_BIT_BLOB = _CRYPT_BIT_BLOB +PCRYPT_BIT_BLOB = POINTER(_CRYPT_BIT_BLOB) +class _CERT_PUBLIC_KEY_INFO(Structure): + _fields_ = [ + ("Algorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("PublicKey", CRYPT_BIT_BLOB), + ] +PCERT_PUBLIC_KEY_INFO = POINTER(_CERT_PUBLIC_KEY_INFO) +CERT_PUBLIC_KEY_INFO = _CERT_PUBLIC_KEY_INFO + +class _CERT_INFO(Structure): + _fields_ = [ + ("dwVersion", DWORD), + ("SerialNumber", CRYPT_INTEGER_BLOB), + ("SignatureAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("Issuer", CERT_NAME_BLOB), + ("NotBefore", FILETIME), + ("NotAfter", FILETIME), + ("Subject", CERT_NAME_BLOB), + ("SubjectPublicKeyInfo", CERT_PUBLIC_KEY_INFO), + ("IssuerUniqueId", CRYPT_BIT_BLOB), + ("SubjectUniqueId", CRYPT_BIT_BLOB), + ("cExtension", DWORD), + ("rgExtension", PCERT_EXTENSION), + ] +CERT_INFO = _CERT_INFO +PCERT_INFO = POINTER(_CERT_INFO) + +class _CERT_ISSUER_SERIAL_NUMBER(Structure): + _fields_ = [ + ("Issuer", CERT_NAME_BLOB), + ("SerialNumber", CRYPT_INTEGER_BLOB), + ] +CERT_ISSUER_SERIAL_NUMBER = _CERT_ISSUER_SERIAL_NUMBER +PCERT_ISSUER_SERIAL_NUMBER = POINTER(_CERT_ISSUER_SERIAL_NUMBER) + +class _TMPUNION_CERT_ID(Union): + _fields_ = [ + ("IssuerSerialNumber", CERT_ISSUER_SERIAL_NUMBER), + ("KeyId", CRYPT_HASH_BLOB), + ("HashId", CRYPT_HASH_BLOB), + ] +TMPUNION_CERT_ID = _TMPUNION_CERT_ID + +class _CERT_ID(Structure): + _fields_ = [ + ("dwIdChoice", DWORD), + ("DUMMYUNIONNAME", TMPUNION_CERT_ID), + ] +CERT_ID = _CERT_ID +PCERT_ID = POINTER(_CERT_ID) + +class _CERT_CONTEXT(Structure): + _fields_ = [ + ("dwCertEncodingType", DWORD), + ("pbCertEncoded", POINTER(BYTE)), + ("cbCertEncoded", DWORD), + ("pCertInfo", PCERT_INFO), + ("hCertStore", HCERTSTORE), + ] +PCCERT_CONTEXT = POINTER(_CERT_CONTEXT) +CERT_CONTEXT = _CERT_CONTEXT +PCERT_CONTEXT = POINTER(_CERT_CONTEXT) + +class WINTRUST_SGNR_INFO_(Structure): + _fields_ = [ + ("cbStruct", DWORD), + ("pcwszDisplayName", LPCWSTR), + ("psSignerInfo", POINTER(CMSG_SIGNER_INFO)), + ("chStores", DWORD), + ("pahStores", POINTER(HCERTSTORE)), + ] +WINTRUST_SGNR_INFO = WINTRUST_SGNR_INFO_ +PWINTRUST_SGNR_INFO = POINTER(WINTRUST_SGNR_INFO_) + +class WINTRUST_CERT_INFO_(Structure): + _fields_ = [ + ("cbStruct", DWORD), + ("pcwszDisplayName", LPCWSTR), + ("psCertContext", POINTER(CERT_CONTEXT)), + ("chStores", DWORD), + ("pahStores", POINTER(HCERTSTORE)), + ("dwFlags", DWORD), + ("psftVerifyAsOf", POINTER(FILETIME)), + ] +WINTRUST_CERT_INFO = WINTRUST_CERT_INFO_ +PWINTRUST_CERT_INFO = POINTER(WINTRUST_CERT_INFO_) + +class _TMP_WINTRUST_UNION_TYPE(Union): + _fields_ = [ + ("pFile", POINTER(WINTRUST_FILE_INFO)), + ("pCatalog", POINTER(WINTRUST_CATALOG_INFO)), + ("pBlob", POINTER(WINTRUST_BLOB_INFO)), + ("pSgnr", POINTER(WINTRUST_SGNR_INFO)), + ("pCert", POINTER(WINTRUST_CERT_INFO)), + ] +TMP_WINTRUST_UNION_TYPE = _TMP_WINTRUST_UNION_TYPE + +class _WINTRUST_DATA(Structure): + _fields_ = [ + ("cbStruct", DWORD), + ("pPolicyCallbackData", LPVOID), + ("pSIPClientData", LPVOID), + ("dwUIChoice", DWORD), + ("fdwRevocationChecks", DWORD), + ("dwUnionChoice", DWORD), + ("tmp_union", TMP_WINTRUST_UNION_TYPE), + ("dwStateAction", DWORD), + ("hWVTStateData", HANDLE), + ("pwszURLReference", POINTER(WCHAR)), + ("dwProvFlags", DWORD), + ("dwUIContext", DWORD), + ] +PWINTRUST_DATA = POINTER(_WINTRUST_DATA) +WINTRUST_DATA = _WINTRUST_DATA + +class _CRYPT_SIGN_MESSAGE_PARA(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("dwMsgEncodingType", DWORD), + ("pSigningCert", PCCERT_CONTEXT), + ("HashAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("pvHashAuxInfo", PVOID), + ("cMsgCert", DWORD), + ("rgpMsgCert", POINTER(PCCERT_CONTEXT)), + ("cMsgCrl", DWORD), + ("rgpMsgCrl", POINTER(PCCRL_CONTEXT)), + ("cAuthAttr", DWORD), + ("rgAuthAttr", PCRYPT_ATTRIBUTE), + ("cUnauthAttr", DWORD), + ("rgUnauthAttr", PCRYPT_ATTRIBUTE), + ("dwFlags", DWORD), + ("dwInnerContentType", DWORD), + ("HashEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("pvHashEncryptionAuxInfo", PVOID), + ] +CRYPT_SIGN_MESSAGE_PARA = _CRYPT_SIGN_MESSAGE_PARA +PCRYPT_SIGN_MESSAGE_PARA = POINTER(_CRYPT_SIGN_MESSAGE_PARA) + +class _CRYPT_HASH_MESSAGE_PARA(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("dwMsgEncodingType", DWORD), + ("hCryptProv", HCRYPTPROV_LEGACY), + ("HashAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("pvHashAuxInfo", PVOID), + ] +PCRYPT_HASH_MESSAGE_PARA = POINTER(_CRYPT_HASH_MESSAGE_PARA) +CRYPT_HASH_MESSAGE_PARA = _CRYPT_HASH_MESSAGE_PARA + +class _CRYPT_KEY_VERIFY_MESSAGE_PARA(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("dwMsgEncodingType", DWORD), + ("hCryptProv", HCRYPTPROV_LEGACY), + ] +CRYPT_KEY_VERIFY_MESSAGE_PARA = _CRYPT_KEY_VERIFY_MESSAGE_PARA +PCRYPT_KEY_VERIFY_MESSAGE_PARA = POINTER(_CRYPT_KEY_VERIFY_MESSAGE_PARA) + +class _CRYPT_VERIFY_MESSAGE_PARA(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("dwMsgAndCertEncodingType", DWORD), + ("hCryptProv", HCRYPTPROV_LEGACY), + ("pfnGetSignerCertificate", PFN_CRYPT_GET_SIGNER_CERTIFICATE), + ("pvGetArg", PVOID), + ("pStrongSignPara", PCCERT_STRONG_SIGN_PARA), + ] +CRYPT_VERIFY_MESSAGE_PARA = _CRYPT_VERIFY_MESSAGE_PARA +PCRYPT_VERIFY_MESSAGE_PARA = POINTER(_CRYPT_VERIFY_MESSAGE_PARA) + +class _SPC_SERIALIZED_OBJECT(Structure): + _fields_ = [ + ("ClassId", SPC_UUID), + ("SerializedData", CRYPT_DATA_BLOB), + ] +SPC_SERIALIZED_OBJECT = _SPC_SERIALIZED_OBJECT +PSPC_SERIALIZED_OBJECT = POINTER(_SPC_SERIALIZED_OBJECT) + +class _TMP_SPC_LINK_UNION(Union): + _fields_ = [ + ("pwszUrl", LPWSTR), + ("Moniker", SPC_SERIALIZED_OBJECT), + ("pwszFile", LPWSTR), + ] +TMP_SPC_LINK_UNION = _TMP_SPC_LINK_UNION + +class SPC_LINK_(Structure): + _fields_ = [ + ("dwLinkChoice", DWORD), + ("u", TMP_SPC_LINK_UNION), + ] +PSPC_LINK = POINTER(SPC_LINK_) +SPC_LINK = SPC_LINK_ + +class _SPC_SP_OPUS_INFO(Structure): + _fields_ = [ + ("pwszProgramName", LPCWSTR), + ("pMoreInfo", POINTER(SPC_LINK)), + ("pPublisherInfo", POINTER(SPC_LINK)), + ] +PSPC_SP_OPUS_INFO = POINTER(_SPC_SP_OPUS_INFO) +SPC_SP_OPUS_INFO = _SPC_SP_OPUS_INFO + +class _CERT_TRUST_STATUS(Structure): + _fields_ = [ + ("dwErrorStatus", DWORD), + ("dwInfoStatus", DWORD), + ] +PCERT_TRUST_STATUS = POINTER(_CERT_TRUST_STATUS) +CERT_TRUST_STATUS = _CERT_TRUST_STATUS + +class _CERT_TRUST_LIST_INFO(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("pCtlEntry", PCTL_ENTRY), + ("pCtlContext", PCCTL_CONTEXT), + ] +PCERT_TRUST_LIST_INFO = POINTER(_CERT_TRUST_LIST_INFO) +CERT_TRUST_LIST_INFO = _CERT_TRUST_LIST_INFO + +class _CERT_REVOCATION_CRL_INFO(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("pBaseCrlContext", PCCRL_CONTEXT), + ("pDeltaCrlContext", PCCRL_CONTEXT), + ("pCrlEntry", PCRL_ENTRY), + ("fDeltaCrlEntry", BOOL), + ] +CERT_REVOCATION_CRL_INFO = _CERT_REVOCATION_CRL_INFO +PCERT_REVOCATION_CRL_INFO = POINTER(_CERT_REVOCATION_CRL_INFO) + +class _CERT_REVOCATION_INFO(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("dwRevocationResult", DWORD), + ("pszRevocationOid", LPCSTR), + ("pvOidSpecificInfo", LPVOID), + ("fHasFreshnessTime", BOOL), + ("dwFreshnessTime", DWORD), + ("pCrlInfo", PCERT_REVOCATION_CRL_INFO), + ] +CERT_REVOCATION_INFO = _CERT_REVOCATION_INFO +PCERT_REVOCATION_INFO = POINTER(_CERT_REVOCATION_INFO) + +class _CERT_CHAIN_ELEMENT(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("pCertContext", PCCERT_CONTEXT), + ("TrustStatus", CERT_TRUST_STATUS), + ("pRevocationInfo", PCERT_REVOCATION_INFO), + ("pIssuanceUsage", PCERT_ENHKEY_USAGE), + ("pApplicationUsage", PCERT_ENHKEY_USAGE), + ("pwszExtendedErrorInfo", LPCWSTR), + ] +PCERT_CHAIN_ELEMENT = POINTER(_CERT_CHAIN_ELEMENT) +CERT_CHAIN_ELEMENT = _CERT_CHAIN_ELEMENT +PCCERT_CHAIN_ELEMENT = POINTER(_CERT_CHAIN_ELEMENT) + +class _CERT_SIMPLE_CHAIN(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("TrustStatus", CERT_TRUST_STATUS), + ("cElement", DWORD), + ("rgpElement", POINTER(PCERT_CHAIN_ELEMENT)), + ("pTrustListInfo", PCERT_TRUST_LIST_INFO), + ("fHasRevocationFreshnessTime", BOOL), + ("dwRevocationFreshnessTime", DWORD), + ] +CERT_SIMPLE_CHAIN = _CERT_SIMPLE_CHAIN +PCERT_SIMPLE_CHAIN = POINTER(_CERT_SIMPLE_CHAIN) +PCCERT_SIMPLE_CHAIN = POINTER(_CERT_SIMPLE_CHAIN) + +# Self referencing struct tricks +class _CERT_CHAIN_CONTEXT(Structure): pass +CERT_CHAIN_CONTEXT = _CERT_CHAIN_CONTEXT +PCERT_CHAIN_CONTEXT = POINTER(_CERT_CHAIN_CONTEXT) +PCCERT_CHAIN_CONTEXT = POINTER(_CERT_CHAIN_CONTEXT) +_CERT_CHAIN_CONTEXT._fields_ = [ + ("cbSize", DWORD), + ("TrustStatus", CERT_TRUST_STATUS), + ("cChain", DWORD), + ("rgpChain", POINTER(PCERT_SIMPLE_CHAIN)), + ("cLowerQualityChainContext", DWORD), + ("rgpLowerQualityChainContext", POINTER(PCCERT_CHAIN_CONTEXT)), + ("fHasRevocationFreshnessTime", BOOL), + ("dwRevocationFreshnessTime", DWORD), + ("dwCreateFlags", DWORD), + ("ChainId", GUID), +] + +class _CERT_USAGE_MATCH(Structure): + _fields_ = [ + ("dwType", DWORD), + ("Usage", CERT_ENHKEY_USAGE), + ] +CERT_USAGE_MATCH = _CERT_USAGE_MATCH +PCERT_USAGE_MATCH = POINTER(_CERT_USAGE_MATCH) + +class _CERT_CHAIN_PARA(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("RequestedUsage", CERT_USAGE_MATCH), + ("RequestedIssuancePolicy", CERT_USAGE_MATCH), + ("dwUrlRetrievalTimeout", DWORD), + ("fCheckRevocationFreshnessTime", BOOL), + ("dwRevocationFreshnessTime", DWORD), + ("pftCacheResync", LPFILETIME), + ] +CERT_CHAIN_PARA = _CERT_CHAIN_PARA +PCERT_CHAIN_PARA = POINTER(_CERT_CHAIN_PARA) + +class _CERT_CHAIN_ENGINE_CONFIG(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("hRestrictedRoot", HCERTSTORE), + ("hRestrictedTrust", HCERTSTORE), + ("hRestrictedOther", HCERTSTORE), + ("cAdditionalStore", DWORD), + ("rghAdditionalStore", POINTER(HCERTSTORE)), + ("dwFlags", DWORD), + ("dwUrlRetrievalTimeout", DWORD), + ("MaximumCachedCertificates", DWORD), + ("CycleDetectionModulus", DWORD), + ] +CERT_CHAIN_ENGINE_CONFIG = _CERT_CHAIN_ENGINE_CONFIG +PCERT_CHAIN_ENGINE_CONFIG = POINTER(_CERT_CHAIN_ENGINE_CONFIG) + +class _SYSTEMTIME(Structure): + _fields_ = [ + ("wYear", WORD), + ("wMonth", WORD), + ("wDayOfWeek", WORD), + ("wDay", WORD), + ("wHour", WORD), + ("wMinute", WORD), + ("wSecond", WORD), + ("wMilliseconds", WORD), + ] +LPSYSTEMTIME = POINTER(_SYSTEMTIME) +SYSTEMTIME = _SYSTEMTIME +PSYSTEMTIME = POINTER(_SYSTEMTIME) + +class _CERT_EXTENSIONS(Structure): + _fields_ = [ + ("cExtension", DWORD), + ("rgExtension", PCERT_EXTENSION), + ] +PCERT_EXTENSIONS = POINTER(_CERT_EXTENSIONS) +CERT_EXTENSIONS = _CERT_EXTENSIONS + +class _CRYPT_KEY_PROV_PARAM(Structure): + _fields_ = [ + ("dwParam", DWORD), + ("pbData", POINTER(BYTE)), + ("cbData", DWORD), + ("dwFlags", DWORD), + ] +CRYPT_KEY_PROV_PARAM = _CRYPT_KEY_PROV_PARAM +PCRYPT_KEY_PROV_PARAM = POINTER(_CRYPT_KEY_PROV_PARAM) + +class _CRYPT_KEY_PROV_INFO(Structure): + _fields_ = [ + ("pwszContainerName", LPWSTR), + ("pwszProvName", LPWSTR), + ("dwProvType", DWORD), + ("dwFlags", DWORD), + ("cProvParam", DWORD), + ("rgProvParam", PCRYPT_KEY_PROV_PARAM), + ("dwKeySpec", DWORD), + ] +CRYPT_KEY_PROV_INFO = _CRYPT_KEY_PROV_INFO +PCRYPT_KEY_PROV_INFO = POINTER(_CRYPT_KEY_PROV_INFO) + +class _CRYPT_ENCRYPT_MESSAGE_PARA(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("dwMsgEncodingType", DWORD), + ("hCryptProv", HCRYPTPROV_LEGACY), + ("ContentEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("pvEncryptionAuxInfo", POINTER(VOID)), + ("dwFlags", DWORD), + ("dwInnerContentType", DWORD), + ] +PCRYPT_ENCRYPT_MESSAGE_PARA = POINTER(_CRYPT_ENCRYPT_MESSAGE_PARA) +CRYPT_ENCRYPT_MESSAGE_PARA = _CRYPT_ENCRYPT_MESSAGE_PARA + +class _CRYPT_DECRYPT_MESSAGE_PARA(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("dwMsgAndCertEncodingType", DWORD), + ("cCertStore", DWORD), + ("rghCertStore", POINTER(HCERTSTORE)), + ("dwFlags", DWORD), + ] +PCRYPT_DECRYPT_MESSAGE_PARA = POINTER(_CRYPT_DECRYPT_MESSAGE_PARA) +CRYPT_DECRYPT_MESSAGE_PARA = _CRYPT_DECRYPT_MESSAGE_PARA + +class _CERT_KEY_CONTEXT(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("hCryptProv", HCRYPTPROV), + ("dwKeySpec", DWORD), + ] +CERT_KEY_CONTEXT = _CERT_KEY_CONTEXT +PCERT_KEY_CONTEXT = POINTER(_CERT_KEY_CONTEXT) + +class _CRYPT_ENCODE_PARA(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("pfnAlloc", PVOID), + ("pfnFree", PVOID), + ] +PCRYPT_ENCODE_PARA = POINTER(_CRYPT_ENCODE_PARA) +CRYPT_ENCODE_PARA = _CRYPT_ENCODE_PARA + +class _TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO(Union): + _fields_ = [ + ("hKeyEncryptionKey", HCRYPTKEY), + ("pvKeyEncryptionKey", PVOID), + ] +TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO = _TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO + +class _CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("KeyEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("pvKeyEncryptionAuxInfo", PVOID), + ("hCryptProv", HCRYPTPROV), + ("dwKeyChoice", DWORD), + ("DUMMYUNIONNAME", TMPUNION_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO), + ("KeyId", CRYPT_DATA_BLOB), + ("Date", FILETIME), + ("pOtherAttr", PCRYPT_ATTRIBUTE_TYPE_VALUE), + ] +PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO = POINTER(_CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO) +CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO = _CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO + +class _CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("KeyEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("pvKeyEncryptionAuxInfo", PVOID), + ("hCryptProv", HCRYPTPROV_LEGACY), + ("RecipientPublicKey", CRYPT_BIT_BLOB), + ("RecipientId", CERT_ID), + ] +PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO = POINTER(_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO) +CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO = _CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO + +class _CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("KeyEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("pvKeyEncryptionAuxInfo", PVOID), + ("hCryptProv", HCRYPTPROV_LEGACY), + ("RecipientPublicKey", CRYPT_BIT_BLOB), + ("RecipientId", CERT_ID), + ] +PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO = POINTER(_CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO) +CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO = _CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO + +class _TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO(Union): + _fields_ = [ + ("pEphemeralAlgorithm", PCRYPT_ALGORITHM_IDENTIFIER), + ("pSenderId", PCERT_ID), + ] +TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO = _TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO + +class _CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("RecipientPublicKey", CRYPT_BIT_BLOB), + ("RecipientId", CERT_ID), + ("Date", FILETIME), + ("pOtherAttr", PCRYPT_ATTRIBUTE_TYPE_VALUE), + ] +PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO = POINTER(_CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO) +CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO = _CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO + +class _CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("KeyEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("pvKeyEncryptionAuxInfo", PVOID), + ("KeyWrapAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("pvKeyWrapAuxInfo", PVOID), + ("hCryptProv", HCRYPTPROV_LEGACY), + ("dwKeySpec", DWORD), + ("dwKeyChoice", DWORD), + ("DUMMYUNIONNAME", TMPUNION_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO), + ("UserKeyingMaterial", CRYPT_DATA_BLOB), + ("cRecipientEncryptedKeys", DWORD), + ("rgpRecipientEncryptedKeys", POINTER(PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO)), + ] +PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO = POINTER(_CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO) +CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO = _CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO + +class _TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION(Union): + _fields_ = [ + ("pKeyTrans", PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO), + ("pKeyAgree", PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO), + ("pMailList", PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO), + ] +TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION = _TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION + +class _CMSG_RECIPIENT_ENCODE_INFO(Structure): + _fields_ = [ + ("dwRecipientChoice", DWORD), + ("DUMMYUNIONNAME", TMP_CMSG_RECIPIENT_ENCODE_INFO_UNION), + ] +CMSG_RECIPIENT_ENCODE_INFO = _CMSG_RECIPIENT_ENCODE_INFO +PCMSG_RECIPIENT_ENCODE_INFO = POINTER(_CMSG_RECIPIENT_ENCODE_INFO) + +class _CMSG_ENVELOPED_ENCODE_INFO(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("hCryptProv", HCRYPTPROV_LEGACY), + ("ContentEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER), + ("pvEncryptionAuxInfo", PVOID), + ("cRecipients", DWORD), + ("rgpRecipients", POINTER(PCERT_INFO)), + ("rgCmsRecipients", PCMSG_RECIPIENT_ENCODE_INFO), + ("cCertEncoded", DWORD), + ("rgCertEncoded", PCERT_BLOB), + ("cCrlEncoded", DWORD), + ("rgCrlEncoded", PCRL_BLOB), + ("cAttrCertEncoded", DWORD), + ("rgAttrCertEncoded", PCERT_BLOB), + ("cUnprotectedAttr", DWORD), + ("rgUnprotectedAttr", PCRYPT_ATTRIBUTE), + ] +PCMSG_ENVELOPED_ENCODE_INFO = POINTER(_CMSG_ENVELOPED_ENCODE_INFO) +CMSG_ENVELOPED_ENCODE_INFO = _CMSG_ENVELOPED_ENCODE_INFO + +class _CMSG_STREAM_INFO(Structure): + _fields_ = [ + ("cbContent", DWORD), + ("pfnStreamOutput", PVOID), + ("pvArg", PVOID), + ] +CMSG_STREAM_INFO = _CMSG_STREAM_INFO +PCMSG_STREAM_INFO = POINTER(_CMSG_STREAM_INFO) + +class _TMPUNION_CMSG_CTRL_DECRYPT_PARA(Union): + _fields_ = [ + ("hCryptProv", HCRYPTPROV), + ("hNCryptKey", NCRYPT_KEY_HANDLE), + ] +TMPUNION_CMSG_CTRL_DECRYPT_PARA = _TMPUNION_CMSG_CTRL_DECRYPT_PARA + +class _CMSG_CTRL_DECRYPT_PARA(Structure): + _fields_ = [ + ("cbSize", DWORD), + ("DUMMYUNIONNAME", TMPUNION_CMSG_CTRL_DECRYPT_PARA), + ("dwKeySpec", DWORD), + ("dwRecipientIndex", DWORD), + ] +PCMSG_CTRL_DECRYPT_PARA = POINTER(_CMSG_CTRL_DECRYPT_PARA) +CMSG_CTRL_DECRYPT_PARA = _CMSG_CTRL_DECRYPT_PARA + +class _TIME_ZONE_INFORMATION(Structure): + _fields_ = [ + ("Bias", LONG), + ("StandardName", WCHAR * 32), + ("StandardDate", SYSTEMTIME), + ("StandardBias", LONG), + ("DaylightName", WCHAR * 32), + ("DaylightDate", SYSTEMTIME), + ("DaylightBias", LONG), + ] +LPTIME_ZONE_INFORMATION = POINTER(_TIME_ZONE_INFORMATION) +PTIME_ZONE_INFORMATION = POINTER(_TIME_ZONE_INFORMATION) +TIME_ZONE_INFORMATION = _TIME_ZONE_INFORMATION + +EvtVarTypeNull = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeNull", 0x0) +EvtVarTypeString = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeString", 0x1) +EvtVarTypeAnsiString = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeAnsiString", 0x2) +EvtVarTypeSByte = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeSByte", 0x3) +EvtVarTypeByte = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeByte", 0x4) +EvtVarTypeInt16 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeInt16", 0x5) +EvtVarTypeUInt16 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeUInt16", 0x6) +EvtVarTypeInt32 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeInt32", 0x7) +EvtVarTypeUInt32 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeUInt32", 0x8) +EvtVarTypeInt64 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeInt64", 0x9) +EvtVarTypeUInt64 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeUInt64", 0xa) +EvtVarTypeSingle = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeSingle", 0xb) +EvtVarTypeDouble = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeDouble", 0xc) +EvtVarTypeBoolean = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeBoolean", 0xd) +EvtVarTypeBinary = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeBinary", 0xe) +EvtVarTypeGuid = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeGuid", 0xf) +EvtVarTypeSizeT = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeSizeT", 0x10) +EvtVarTypeFileTime = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeFileTime", 0x11) +EvtVarTypeSysTime = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeSysTime", 0x12) +EvtVarTypeSid = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeSid", 0x13) +EvtVarTypeHexInt32 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeHexInt32", 0x14) +EvtVarTypeHexInt64 = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeHexInt64", 0x15) +EvtVarTypeEvtHandle = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeEvtHandle", 0x20) +EvtVarTypeEvtXml = EnumValue("_EVT_VARIANT_TYPE", "EvtVarTypeEvtXml", 0x23) +class _EVT_VARIANT_TYPE(EnumType): + values = [EvtVarTypeNull, EvtVarTypeString, EvtVarTypeAnsiString, EvtVarTypeSByte, EvtVarTypeByte, EvtVarTypeInt16, EvtVarTypeUInt16, EvtVarTypeInt32, EvtVarTypeUInt32, EvtVarTypeInt64, EvtVarTypeUInt64, EvtVarTypeSingle, EvtVarTypeDouble, EvtVarTypeBoolean, EvtVarTypeBinary, EvtVarTypeGuid, EvtVarTypeSizeT, EvtVarTypeFileTime, EvtVarTypeSysTime, EvtVarTypeSid, EvtVarTypeHexInt32, EvtVarTypeHexInt64, EvtVarTypeEvtHandle, EvtVarTypeEvtXml] + mapper = FlagMapper(*values) +EVT_VARIANT_TYPE = _EVT_VARIANT_TYPE + + +EvtRenderContextValues = EnumValue("_EVT_RENDER_CONTEXT_FLAGS", "EvtRenderContextValues", 0x0) +EvtRenderContextSystem = EnumValue("_EVT_RENDER_CONTEXT_FLAGS", "EvtRenderContextSystem", 0x1) +EvtRenderContextUser = EnumValue("_EVT_RENDER_CONTEXT_FLAGS", "EvtRenderContextUser", 0x2) +class _EVT_RENDER_CONTEXT_FLAGS(EnumType): + values = [EvtRenderContextValues, EvtRenderContextSystem, EvtRenderContextUser] + mapper = FlagMapper(*values) +EVT_RENDER_CONTEXT_FLAGS = _EVT_RENDER_CONTEXT_FLAGS + + +EvtSystemProviderName = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemProviderName", 0x0) +EvtSystemProviderGuid = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemProviderGuid", 0x1) +EvtSystemEventID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemEventID", 0x2) +EvtSystemQualifiers = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemQualifiers", 0x3) +EvtSystemLevel = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemLevel", 0x4) +EvtSystemTask = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemTask", 0x5) +EvtSystemOpcode = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemOpcode", 0x6) +EvtSystemKeywords = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemKeywords", 0x7) +EvtSystemTimeCreated = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemTimeCreated", 0x8) +EvtSystemEventRecordId = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemEventRecordId", 0x9) +EvtSystemActivityID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemActivityID", 0xa) +EvtSystemRelatedActivityID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemRelatedActivityID", 0xb) +EvtSystemProcessID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemProcessID", 0xc) +EvtSystemThreadID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemThreadID", 0xd) +EvtSystemChannel = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemChannel", 0xe) +EvtSystemComputer = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemComputer", 0xf) +EvtSystemUserID = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemUserID", 0x10) +EvtSystemVersion = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemVersion", 0x11) +EvtSystemPropertyIdEND = EnumValue("_EVT_SYSTEM_PROPERTY_ID", "EvtSystemPropertyIdEND", 0x12) +class _EVT_SYSTEM_PROPERTY_ID(EnumType): + values = [EvtSystemProviderName, EvtSystemProviderGuid, EvtSystemEventID, EvtSystemQualifiers, EvtSystemLevel, EvtSystemTask, EvtSystemOpcode, EvtSystemKeywords, EvtSystemTimeCreated, EvtSystemEventRecordId, EvtSystemActivityID, EvtSystemRelatedActivityID, EvtSystemProcessID, EvtSystemThreadID, EvtSystemChannel, EvtSystemComputer, EvtSystemUserID, EvtSystemVersion, EvtSystemPropertyIdEND] + mapper = FlagMapper(*values) +EVT_SYSTEM_PROPERTY_ID = _EVT_SYSTEM_PROPERTY_ID + + +EvtRenderEventValues = EnumValue("_EVT_RENDER_FLAGS", "EvtRenderEventValues", 0x0) +EvtRenderEventXml = EnumValue("_EVT_RENDER_FLAGS", "EvtRenderEventXml", 0x1) +EvtRenderBookmark = EnumValue("_EVT_RENDER_FLAGS", "EvtRenderBookmark", 0x2) +class _EVT_RENDER_FLAGS(EnumType): + values = [EvtRenderEventValues, EvtRenderEventXml, EvtRenderBookmark] + mapper = FlagMapper(*values) +EVT_RENDER_FLAGS = _EVT_RENDER_FLAGS + + +EvtQueryChannelPath = EnumValue("_EVT_QUERY_FLAGS", "EvtQueryChannelPath", 0x1) +EvtQueryFilePath = EnumValue("_EVT_QUERY_FLAGS", "EvtQueryFilePath", 0x2) +EvtQueryForwardDirection = EnumValue("_EVT_QUERY_FLAGS", "EvtQueryForwardDirection", 0x100) +EvtQueryReverseDirection = EnumValue("_EVT_QUERY_FLAGS", "EvtQueryReverseDirection", 0x200) +EvtQueryTolerateQueryErrors = EnumValue("_EVT_QUERY_FLAGS", "EvtQueryTolerateQueryErrors", 0x1000) +class _EVT_QUERY_FLAGS(EnumType): + values = [EvtQueryChannelPath, EvtQueryFilePath, EvtQueryForwardDirection, EvtQueryReverseDirection, EvtQueryTolerateQueryErrors] + mapper = FlagMapper(*values) +EVT_QUERY_FLAGS = _EVT_QUERY_FLAGS + + +EvtLogCreationTime = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogCreationTime", 0x0) +EvtLogLastAccessTime = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogLastAccessTime", 0x1) +EvtLogLastWriteTime = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogLastWriteTime", 0x2) +EvtLogFileSize = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogFileSize", 0x3) +EvtLogAttributes = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogAttributes", 0x4) +EvtLogNumberOfLogRecords = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogNumberOfLogRecords", 0x5) +EvtLogOldestRecordNumber = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogOldestRecordNumber", 0x6) +EvtLogFull = EnumValue("_EVT_LOG_PROPERTY_ID", "EvtLogFull", 0x7) +class _EVT_LOG_PROPERTY_ID(EnumType): + values = [EvtLogCreationTime, EvtLogLastAccessTime, EvtLogLastWriteTime, EvtLogFileSize, EvtLogAttributes, EvtLogNumberOfLogRecords, EvtLogOldestRecordNumber, EvtLogFull] + mapper = FlagMapper(*values) +EVT_LOG_PROPERTY_ID = _EVT_LOG_PROPERTY_ID + + +EvtOpenChannelPath = EnumValue("_EVT_OPEN_LOG_FLAGS", "EvtOpenChannelPath", 0x1) +EvtOpenFilePath = EnumValue("_EVT_OPEN_LOG_FLAGS", "EvtOpenFilePath", 0x2) +class _EVT_OPEN_LOG_FLAGS(EnumType): + values = [EvtOpenChannelPath, EvtOpenFilePath] + mapper = FlagMapper(*values) +EVT_OPEN_LOG_FLAGS = _EVT_OPEN_LOG_FLAGS + + +EvtChannelConfigEnabled = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigEnabled", 0x0) +EvtChannelConfigIsolation = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigIsolation", 0x1) +EvtChannelConfigType = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigType", 0x2) +EvtChannelConfigOwningPublisher = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigOwningPublisher", 0x3) +EvtChannelConfigClassicEventlog = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigClassicEventlog", 0x4) +EvtChannelConfigAccess = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigAccess", 0x5) +EvtChannelLoggingConfigRetention = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelLoggingConfigRetention", 0x6) +EvtChannelLoggingConfigAutoBackup = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelLoggingConfigAutoBackup", 0x7) +EvtChannelLoggingConfigMaxSize = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelLoggingConfigMaxSize", 0x8) +EvtChannelLoggingConfigLogFilePath = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelLoggingConfigLogFilePath", 0x9) +EvtChannelPublishingConfigLevel = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigLevel", 0xa) +EvtChannelPublishingConfigKeywords = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigKeywords", 0xb) +EvtChannelPublishingConfigControlGuid = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigControlGuid", 0xc) +EvtChannelPublishingConfigBufferSize = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigBufferSize", 0xd) +EvtChannelPublishingConfigMinBuffers = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigMinBuffers", 0xe) +EvtChannelPublishingConfigMaxBuffers = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigMaxBuffers", 0xf) +EvtChannelPublishingConfigLatency = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigLatency", 0x10) +EvtChannelPublishingConfigClockType = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigClockType", 0x11) +EvtChannelPublishingConfigSidType = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigSidType", 0x12) +EvtChannelPublisherList = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublisherList", 0x13) +EvtChannelPublishingConfigFileMax = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelPublishingConfigFileMax", 0x14) +EvtChannelConfigPropertyIdEND = EnumValue("_EVT_CHANNEL_CONFIG_PROPERTY_ID", "EvtChannelConfigPropertyIdEND", 0x15) +class _EVT_CHANNEL_CONFIG_PROPERTY_ID(EnumType): + values = [EvtChannelConfigEnabled, EvtChannelConfigIsolation, EvtChannelConfigType, EvtChannelConfigOwningPublisher, EvtChannelConfigClassicEventlog, EvtChannelConfigAccess, EvtChannelLoggingConfigRetention, EvtChannelLoggingConfigAutoBackup, EvtChannelLoggingConfigMaxSize, EvtChannelLoggingConfigLogFilePath, EvtChannelPublishingConfigLevel, EvtChannelPublishingConfigKeywords, EvtChannelPublishingConfigControlGuid, EvtChannelPublishingConfigBufferSize, EvtChannelPublishingConfigMinBuffers, EvtChannelPublishingConfigMaxBuffers, EvtChannelPublishingConfigLatency, EvtChannelPublishingConfigClockType, EvtChannelPublishingConfigSidType, EvtChannelPublisherList, EvtChannelPublishingConfigFileMax, EvtChannelConfigPropertyIdEND] + mapper = FlagMapper(*values) +EVT_CHANNEL_CONFIG_PROPERTY_ID = _EVT_CHANNEL_CONFIG_PROPERTY_ID + + +EvtChannelTypeAdmin = EnumValue("_EVT_CHANNEL_TYPE", "EvtChannelTypeAdmin", 0x0) +EvtChannelTypeOperational = EnumValue("_EVT_CHANNEL_TYPE", "EvtChannelTypeOperational", 0x1) +EvtChannelTypeAnalytic = EnumValue("_EVT_CHANNEL_TYPE", "EvtChannelTypeAnalytic", 0x2) +EvtChannelTypeDebug = EnumValue("_EVT_CHANNEL_TYPE", "EvtChannelTypeDebug", 0x3) +class _EVT_CHANNEL_TYPE(EnumType): + values = [EvtChannelTypeAdmin, EvtChannelTypeOperational, EvtChannelTypeAnalytic, EvtChannelTypeDebug] + mapper = FlagMapper(*values) +EVT_CHANNEL_TYPE = _EVT_CHANNEL_TYPE + + +EvtChannelIsolationTypeApplication = EnumValue("_EVT_CHANNEL_ISOLATION_TYPE", "EvtChannelIsolationTypeApplication", 0x0) +EvtChannelIsolationTypeSystem = EnumValue("_EVT_CHANNEL_ISOLATION_TYPE", "EvtChannelIsolationTypeSystem", 0x1) +EvtChannelIsolationTypeCustom = EnumValue("_EVT_CHANNEL_ISOLATION_TYPE", "EvtChannelIsolationTypeCustom", 0x2) +class _EVT_CHANNEL_ISOLATION_TYPE(EnumType): + values = [EvtChannelIsolationTypeApplication, EvtChannelIsolationTypeSystem, EvtChannelIsolationTypeCustom] + mapper = FlagMapper(*values) +EVT_CHANNEL_ISOLATION_TYPE = _EVT_CHANNEL_ISOLATION_TYPE + + +EventMetadataEventID = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventID", 0x0) +EventMetadataEventVersion = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventVersion", 0x1) +EventMetadataEventChannel = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventChannel", 0x2) +EventMetadataEventLevel = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventLevel", 0x3) +EventMetadataEventOpcode = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventOpcode", 0x4) +EventMetadataEventTask = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventTask", 0x5) +EventMetadataEventKeyword = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventKeyword", 0x6) +EventMetadataEventMessageID = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventMessageID", 0x7) +EventMetadataEventTemplate = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EventMetadataEventTemplate", 0x8) +EvtEventMetadataPropertyIdEND = EnumValue("_EVT_EVENT_METADATA_PROPERTY_ID", "EvtEventMetadataPropertyIdEND", 0x9) +class _EVT_EVENT_METADATA_PROPERTY_ID(EnumType): + values = [EventMetadataEventID, EventMetadataEventVersion, EventMetadataEventChannel, EventMetadataEventLevel, EventMetadataEventOpcode, EventMetadataEventTask, EventMetadataEventKeyword, EventMetadataEventMessageID, EventMetadataEventTemplate, EvtEventMetadataPropertyIdEND] + mapper = FlagMapper(*values) +EVT_EVENT_METADATA_PROPERTY_ID = _EVT_EVENT_METADATA_PROPERTY_ID + + +EvtPublisherMetadataPublisherGuid = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataPublisherGuid", 0x0) +EvtPublisherMetadataResourceFilePath = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataResourceFilePath", 0x1) +EvtPublisherMetadataParameterFilePath = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataParameterFilePath", 0x2) +EvtPublisherMetadataMessageFilePath = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataMessageFilePath", 0x3) +EvtPublisherMetadataHelpLink = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataHelpLink", 0x4) +EvtPublisherMetadataPublisherMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataPublisherMessageID", 0x5) +EvtPublisherMetadataChannelReferences = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferences", 0x6) +EvtPublisherMetadataChannelReferencePath = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferencePath", 0x7) +EvtPublisherMetadataChannelReferenceIndex = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferenceIndex", 0x8) +EvtPublisherMetadataChannelReferenceID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferenceID", 0x9) +EvtPublisherMetadataChannelReferenceFlags = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferenceFlags", 0xa) +EvtPublisherMetadataChannelReferenceMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataChannelReferenceMessageID", 0xb) +EvtPublisherMetadataLevels = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataLevels", 0xc) +EvtPublisherMetadataLevelName = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataLevelName", 0xd) +EvtPublisherMetadataLevelValue = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataLevelValue", 0xe) +EvtPublisherMetadataLevelMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataLevelMessageID", 0xf) +EvtPublisherMetadataTasks = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataTasks", 0x10) +EvtPublisherMetadataTaskName = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataTaskName", 0x11) +EvtPublisherMetadataTaskEventGuid = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataTaskEventGuid", 0x12) +EvtPublisherMetadataTaskValue = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataTaskValue", 0x13) +EvtPublisherMetadataTaskMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataTaskMessageID", 0x14) +EvtPublisherMetadataOpcodes = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataOpcodes", 0x15) +EvtPublisherMetadataOpcodeName = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataOpcodeName", 0x16) +EvtPublisherMetadataOpcodeValue = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataOpcodeValue", 0x17) +EvtPublisherMetadataOpcodeMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataOpcodeMessageID", 0x18) +EvtPublisherMetadataKeywords = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataKeywords", 0x19) +EvtPublisherMetadataKeywordName = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataKeywordName", 0x1a) +EvtPublisherMetadataKeywordValue = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataKeywordValue", 0x1b) +EvtPublisherMetadataKeywordMessageID = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataKeywordMessageID", 0x1c) +EvtPublisherMetadataPropertyIdEND = EnumValue("_EVT_PUBLISHER_METADATA_PROPERTY_ID", "EvtPublisherMetadataPropertyIdEND", 0x1d) +class _EVT_PUBLISHER_METADATA_PROPERTY_ID(EnumType): + values = [EvtPublisherMetadataPublisherGuid, EvtPublisherMetadataResourceFilePath, EvtPublisherMetadataParameterFilePath, EvtPublisherMetadataMessageFilePath, EvtPublisherMetadataHelpLink, EvtPublisherMetadataPublisherMessageID, EvtPublisherMetadataChannelReferences, EvtPublisherMetadataChannelReferencePath, EvtPublisherMetadataChannelReferenceIndex, EvtPublisherMetadataChannelReferenceID, EvtPublisherMetadataChannelReferenceFlags, EvtPublisherMetadataChannelReferenceMessageID, EvtPublisherMetadataLevels, EvtPublisherMetadataLevelName, EvtPublisherMetadataLevelValue, EvtPublisherMetadataLevelMessageID, EvtPublisherMetadataTasks, EvtPublisherMetadataTaskName, EvtPublisherMetadataTaskEventGuid, EvtPublisherMetadataTaskValue, EvtPublisherMetadataTaskMessageID, EvtPublisherMetadataOpcodes, EvtPublisherMetadataOpcodeName, EvtPublisherMetadataOpcodeValue, EvtPublisherMetadataOpcodeMessageID, EvtPublisherMetadataKeywords, EvtPublisherMetadataKeywordName, EvtPublisherMetadataKeywordValue, EvtPublisherMetadataKeywordMessageID, EvtPublisherMetadataPropertyIdEND] + mapper = FlagMapper(*values) +EVT_PUBLISHER_METADATA_PROPERTY_ID = _EVT_PUBLISHER_METADATA_PROPERTY_ID + + +EvtFormatMessageEvent = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageEvent", 0x1) +EvtFormatMessageLevel = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageLevel", 0x2) +EvtFormatMessageTask = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageTask", 0x3) +EvtFormatMessageOpcode = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageOpcode", 0x4) +EvtFormatMessageKeyword = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageKeyword", 0x5) +EvtFormatMessageChannel = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageChannel", 0x6) +EvtFormatMessageProvider = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageProvider", 0x7) +EvtFormatMessageId = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageId", 0x8) +EvtFormatMessageXml = EnumValue("_EVT_FORMAT_MESSAGE_FLAGS", "EvtFormatMessageXml", 0x9) +class _EVT_FORMAT_MESSAGE_FLAGS(EnumType): + values = [EvtFormatMessageEvent, EvtFormatMessageLevel, EvtFormatMessageTask, EvtFormatMessageOpcode, EvtFormatMessageKeyword, EvtFormatMessageChannel, EvtFormatMessageProvider, EvtFormatMessageId, EvtFormatMessageXml] + mapper = FlagMapper(*values) +EVT_FORMAT_MESSAGE_FLAGS = _EVT_FORMAT_MESSAGE_FLAGS + + +class _EVENTLOGRECORD(Structure): + _fields_ = [ + ("Length", DWORD), + ("Reserved", DWORD), + ("RecordNumber", DWORD), + ("TimeGenerated", DWORD), + ("TimeWritten", DWORD), + ("EventID", DWORD), + ("EventType", WORD), + ("NumStrings", WORD), + ("EventCategory", WORD), + ("ReservedFlags", WORD), + ("ClosingRecordNumber", DWORD), + ("StringOffset", DWORD), + ("UserSidLength", DWORD), + ("UserSidOffset", DWORD), + ("DataLength", DWORD), + ("DataOffset", DWORD), + ] +PEVENTLOGRECORD = POINTER(_EVENTLOGRECORD) +EVENTLOGRECORD = _EVENTLOGRECORD + +class _EVENTLOG_FULL_INFORMATION(Structure): + _fields_ = [ + ("dwFull", DWORD), + ] +EVENTLOG_FULL_INFORMATION = _EVENTLOG_FULL_INFORMATION +LPEVENTLOG_FULL_INFORMATION = POINTER(_EVENTLOG_FULL_INFORMATION) + +class _ANON__EVT_VARIANT_SUB_UNION_1(Union): + _fields_ = [ + ("BooleanVal", BOOL), + ("SByteVal", INT8), + ("Int16Val", INT16), + ("Int32Val", INT32), + ("Int64Val", INT64), + ("ByteVal", UINT8), + ("UInt16Val", UINT16), + ("UInt32Val", UINT32), + ("UInt64Val", UINT64), + ("SingleVal", FLOAT), + ("DoubleVal", DOUBLE), + ("FileTimeVal", ULONGLONG), + ("SysTimeVal", POINTER(SYSTEMTIME)), + ("GuidVal", POINTER(GUID)), + ("StringVal", LPCWSTR), + ("AnsiStringVal", LPCSTR), + ("BinaryVal", PBYTE), + ("SidVal", PSID), + ("SizeTVal", SIZE_T), + ("BooleanArr", POINTER(BOOL)), + ("SByteArr", POINTER(INT8)), + ("Int16Arr", POINTER(INT16)), + ("Int32Arr", POINTER(INT32)), + ("Int64Arr", POINTER(INT64)), + ("ByteArr", POINTER(UINT8)), + ("UInt16Arr", POINTER(UINT16)), + ("UInt32Arr", POINTER(UINT32)), + ("UInt64Arr", POINTER(UINT64)), + ("SingleArr", POINTER(FLOAT)), + ("DoubleArr", POINTER(DOUBLE)), + ("FileTimeArr", POINTER(FILETIME)), + ("SysTimeArr", POINTER(SYSTEMTIME)), + ("GuidArr", POINTER(GUID)), + ("StringArr", POINTER(LPWSTR)), + ("AnsiStringArr", POINTER(LPSTR)), + ("SidArr", POINTER(PSID)), + ("SizeTArr", POINTER(SIZE_T)), + ("EvtHandleVal", EVT_HANDLE), + ("XmlVal", LPCWSTR), + ("XmlValArr", POINTER(LPCWSTR)), + ] + +class _EVT_VARIANT(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__EVT_VARIANT_SUB_UNION_1), + ("Count", DWORD), + ("Type", DWORD), + ] +PEVT_VARIANT = POINTER(_EVT_VARIANT) +EVT_VARIANT = _EVT_VARIANT + +TraceGuidQueryList = EnumValue("TRACE_INFO_CLASS", "TraceGuidQueryList", 0x0) +TraceGuidQueryInfo = EnumValue("TRACE_INFO_CLASS", "TraceGuidQueryInfo", 0x1) +TraceGuidQueryProcess = EnumValue("TRACE_INFO_CLASS", "TraceGuidQueryProcess", 0x2) +TraceStackTracingInfo = EnumValue("TRACE_INFO_CLASS", "TraceStackTracingInfo", 0x3) +TraceSystemTraceEnableFlagsInfo = EnumValue("TRACE_INFO_CLASS", "TraceSystemTraceEnableFlagsInfo", 0x4) +TraceSampledProfileIntervalInfo = EnumValue("TRACE_INFO_CLASS", "TraceSampledProfileIntervalInfo", 0x5) +TraceProfileSourceConfigInfo = EnumValue("TRACE_INFO_CLASS", "TraceProfileSourceConfigInfo", 0x6) +TraceProfileSourceListInfo = EnumValue("TRACE_INFO_CLASS", "TraceProfileSourceListInfo", 0x7) +TracePmcEventListInfo = EnumValue("TRACE_INFO_CLASS", "TracePmcEventListInfo", 0x8) +TracePmcCounterListInfo = EnumValue("TRACE_INFO_CLASS", "TracePmcCounterListInfo", 0x9) +TraceSetDisallowList = EnumValue("TRACE_INFO_CLASS", "TraceSetDisallowList", 0xa) +TraceVersionInfo = EnumValue("TRACE_INFO_CLASS", "TraceVersionInfo", 0xb) +TraceGroupQueryList = EnumValue("TRACE_INFO_CLASS", "TraceGroupQueryList", 0xc) +TraceGroupQueryInfo = EnumValue("TRACE_INFO_CLASS", "TraceGroupQueryInfo", 0xd) +TraceDisallowListQuery = EnumValue("TRACE_INFO_CLASS", "TraceDisallowListQuery", 0xe) +TraceInfoReserved15 = EnumValue("TRACE_INFO_CLASS", "TraceInfoReserved15", 0xf) +TracePeriodicCaptureStateListInfo = EnumValue("TRACE_INFO_CLASS", "TracePeriodicCaptureStateListInfo", 0x10) +TracePeriodicCaptureStateInfo = EnumValue("TRACE_INFO_CLASS", "TracePeriodicCaptureStateInfo", 0x11) +TraceProviderBinaryTracking = EnumValue("TRACE_INFO_CLASS", "TraceProviderBinaryTracking", 0x12) +TraceMaxLoggersQuery = EnumValue("TRACE_INFO_CLASS", "TraceMaxLoggersQuery", 0x13) +MaxTraceSetInfoClass = EnumValue("TRACE_INFO_CLASS", "MaxTraceSetInfoClass", 0x14) +class TRACE_INFO_CLASS(EnumType): + values = [TraceGuidQueryList, TraceGuidQueryInfo, TraceGuidQueryProcess, TraceStackTracingInfo, TraceSystemTraceEnableFlagsInfo, TraceSampledProfileIntervalInfo, TraceProfileSourceConfigInfo, TraceProfileSourceListInfo, TracePmcEventListInfo, TracePmcCounterListInfo, TraceSetDisallowList, TraceVersionInfo, TraceGroupQueryList, TraceGroupQueryInfo, TraceDisallowListQuery, TraceInfoReserved15, TracePeriodicCaptureStateListInfo, TracePeriodicCaptureStateInfo, TraceProviderBinaryTracking, TraceMaxLoggersQuery, MaxTraceSetInfoClass] + mapper = FlagMapper(*values) +TRACE_QUERY_INFO_CLASS = TRACE_INFO_CLASS + + +class _TRACE_GUID_INFO(Structure): + _fields_ = [ + ("InstanceCount", ULONG), + ("Reserved", ULONG), + ] +PTRACE_GUID_INFO = POINTER(_TRACE_GUID_INFO) +TRACE_GUID_INFO = _TRACE_GUID_INFO + +class _TRACE_PROVIDER_INSTANCE_INFO(Structure): + _fields_ = [ + ("NextOffset", ULONG), + ("EnableCount", ULONG), + ("Pid", ULONG), + ("Flags", ULONG), + ] +TRACE_PROVIDER_INSTANCE_INFO = _TRACE_PROVIDER_INSTANCE_INFO +PTRACE_PROVIDER_INSTANCE_INFO = POINTER(_TRACE_PROVIDER_INSTANCE_INFO) + +class _TRACE_ENABLE_INFO(Structure): + _fields_ = [ + ("IsEnabled", ULONG), + ("Level", UCHAR), + ("Reserved1", UCHAR), + ("LoggerId", USHORT), + ("EnableProperty", ULONG), + ("Reserved2", ULONG), + ("MatchAnyKeyword", ULONGLONG), + ("MatchAllKeyword", ULONGLONG), + ] +PTRACE_ENABLE_INFO = POINTER(_TRACE_ENABLE_INFO) +TRACE_ENABLE_INFO = _TRACE_ENABLE_INFO + +class _ANON__ANON__WNODE_HEADER_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("Version", ULONG), + ("Linkage", ULONG), + ] + +class _ANON__WNODE_HEADER_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("HistoricalContext", ULONG64), + ("anon_01", _ANON__ANON__WNODE_HEADER_SUB_UNION_1_SUB_STRUCTURE_1), + ] + + +class _ANON__WNODE_HEADER_SUB_UNION_2(Union): + _fields_ = [ + ("KernelHandle", HANDLE), + ("TimeStamp", LARGE_INTEGER), + ] + +class _WNODE_HEADER(Structure): + _anonymous_ = ("anon_01","anon_02") + _fields_ = [ + ("BufferSize", ULONG), + ("ProviderId", ULONG), + ("anon_01", _ANON__WNODE_HEADER_SUB_UNION_1), + ("anon_02", _ANON__WNODE_HEADER_SUB_UNION_2), + ("Guid", GUID), + ("ClientContext", ULONG), + ("Flags", ULONG), + ] +PWNODE_HEADER = POINTER(_WNODE_HEADER) +WNODE_HEADER = _WNODE_HEADER + +class _EVENT_TRACE_PROPERTIES(Structure): + _fields_ = [ + ("Wnode", WNODE_HEADER), + ("BufferSize", ULONG), + ("MinimumBuffers", ULONG), + ("MaximumBuffers", ULONG), + ("MaximumFileSize", ULONG), + ("LogFileMode", ULONG), + ("FlushTimer", ULONG), + ("EnableFlags", ULONG), + ("AgeLimit", LONG), + ("NumberOfBuffers", ULONG), + ("FreeBuffers", ULONG), + ("EventsLost", ULONG), + ("BuffersWritten", ULONG), + ("LogBuffersLost", ULONG), + ("RealTimeBuffersLost", ULONG), + ("LoggerThreadId", HANDLE), + ("LogFileNameOffset", ULONG), + ("LoggerNameOffset", ULONG), + ] +EVENT_TRACE_PROPERTIES = _EVENT_TRACE_PROPERTIES +PEVENT_TRACE_PROPERTIES = POINTER(_EVENT_TRACE_PROPERTIES) + +class _ANON__ANON__EVENT_TRACE_HEADER_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("HeaderType", BYTE), + ("MarkerFlags", BYTE), + ] + +class _ANON__EVENT_TRACE_HEADER_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("FieldTypeFlags", USHORT), + ("anon_01", _ANON__ANON__EVENT_TRACE_HEADER_SUB_UNION_1_SUB_STRUCTURE_1), + ] + + +class _ANON__ANON__EVENT_TRACE_HEADER_SUB_UNION_2_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("Type", BYTE), + ("Level", BYTE), + ("Version", USHORT), + ] + +class _ANON__EVENT_TRACE_HEADER_SUB_UNION_2(Union): + _anonymous_ = ("Class",) + _fields_ = [ + ("Version", ULONG), + ("Class", _ANON__ANON__EVENT_TRACE_HEADER_SUB_UNION_2_SUB_STRUCTURE_1), + ] + + +class _ANON__EVENT_TRACE_HEADER_SUB_UNION_3(Union): + _fields_ = [ + ("Guid", GUID), + ("GuidPtr", ULONGLONG), + ] + + +class _ANON__ANON__EVENT_TRACE_HEADER_SUB_UNION_4_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("KernelTime", ULONG), + ("UserTime", ULONG), + ] + + +class _ANON__ANON__EVENT_TRACE_HEADER_SUB_UNION_4_SUB_STRUCTURE_2(Structure): + _fields_ = [ + ("ClientContext", ULONG), + ("Flags", ULONG), + ] + +class _ANON__EVENT_TRACE_HEADER_SUB_UNION_4(Union): + _anonymous_ = ("anon_01","anon_02") + _fields_ = [ + ("anon_01", _ANON__ANON__EVENT_TRACE_HEADER_SUB_UNION_4_SUB_STRUCTURE_1), + ("ProcessorTime", ULONG64), + ("anon_02", _ANON__ANON__EVENT_TRACE_HEADER_SUB_UNION_4_SUB_STRUCTURE_2), + ] + +class _EVENT_TRACE_HEADER(Structure): + _anonymous_ = ("anon_01","anon_02","anon_03","anon_04") + _fields_ = [ + ("Size", USHORT), + ("anon_01", _ANON__EVENT_TRACE_HEADER_SUB_UNION_1), + ("anon_02", _ANON__EVENT_TRACE_HEADER_SUB_UNION_2), + ("ThreadId", ULONG), + ("ProcessId", ULONG), + ("TimeStamp", LARGE_INTEGER), + ("anon_03", _ANON__EVENT_TRACE_HEADER_SUB_UNION_3), + ("anon_04", _ANON__EVENT_TRACE_HEADER_SUB_UNION_4), + ] +EVENT_TRACE_HEADER = _EVENT_TRACE_HEADER +PEVENT_TRACE_HEADER = POINTER(_EVENT_TRACE_HEADER) + +class _ANON__ANON__ETW_BUFFER_CONTEXT_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("ProcessorNumber", BYTE), + ("Alignment", BYTE), + ] + +class _ANON__ETW_BUFFER_CONTEXT_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__ANON__ETW_BUFFER_CONTEXT_SUB_UNION_1_SUB_STRUCTURE_1), + ("ProcessorIndex", USHORT), + ] + +class _ETW_BUFFER_CONTEXT(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__ETW_BUFFER_CONTEXT_SUB_UNION_1), + ("LoggerId", USHORT), + ] +PETW_BUFFER_CONTEXT = POINTER(_ETW_BUFFER_CONTEXT) +ETW_BUFFER_CONTEXT = _ETW_BUFFER_CONTEXT + +class _ANON__EVENT_TRACE_SUB_UNION_1(Union): + _fields_ = [ + ("ClientContext", ULONG), + ("BufferContext", ETW_BUFFER_CONTEXT), + ] + +class _EVENT_TRACE(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Header", EVENT_TRACE_HEADER), + ("InstanceId", ULONG), + ("ParentInstanceId", ULONG), + ("ParentGuid", GUID), + ("MofData", PVOID), + ("MofLength", ULONG), + ("anon_01", _ANON__EVENT_TRACE_SUB_UNION_1), + ] +EVENT_TRACE = _EVENT_TRACE +PEVENT_TRACE = POINTER(_EVENT_TRACE) + +class _ANON__ANON__TRACE_LOGFILE_HEADER_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("MajorVersion", UCHAR), + ("MinorVersion", UCHAR), + ("SubVersion", UCHAR), + ("SubMinorVersion", UCHAR), + ] + +class _ANON__TRACE_LOGFILE_HEADER_SUB_UNION_1(Union): + _anonymous_ = ("VersionDetail",) + _fields_ = [ + ("Version", ULONG), + ("VersionDetail", _ANON__ANON__TRACE_LOGFILE_HEADER_SUB_UNION_1_SUB_STRUCTURE_1), + ] + + +class _ANON__ANON__TRACE_LOGFILE_HEADER_SUB_UNION_2_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("StartBuffers", ULONG), + ("PointerSize", ULONG), + ("EventsLost", ULONG), + ("CpuSpeedInMHz", ULONG), + ] + +class _ANON__TRACE_LOGFILE_HEADER_SUB_UNION_2(Union): + _anonymous_ = ("DUMMYSTRUCTNAME",) + _fields_ = [ + ("LogInstanceGuid", GUID), + ("DUMMYSTRUCTNAME", _ANON__ANON__TRACE_LOGFILE_HEADER_SUB_UNION_2_SUB_STRUCTURE_1), + ] + +class _TRACE_LOGFILE_HEADER(Structure): + _anonymous_ = ("DUMMYUNIONNAME","DUMMYUNIONNAME2") + _fields_ = [ + ("BufferSize", ULONG), + ("DUMMYUNIONNAME", _ANON__TRACE_LOGFILE_HEADER_SUB_UNION_1), + ("ProviderVersion", ULONG), + ("NumberOfProcessors", ULONG), + ("EndTime", LARGE_INTEGER), + ("TimerResolution", ULONG), + ("MaximumFileSize", ULONG), + ("LogFileMode", ULONG), + ("BuffersWritten", ULONG), + ("DUMMYUNIONNAME2", _ANON__TRACE_LOGFILE_HEADER_SUB_UNION_2), + ("LoggerName", LPWSTR), + ("LogFileName", LPWSTR), + ("TimeZone", TIME_ZONE_INFORMATION), + ("BootTime", LARGE_INTEGER), + ("PerfFreq", LARGE_INTEGER), + ("StartTime", LARGE_INTEGER), + ("ReservedFlags", ULONG), + ("BuffersLost", ULONG), + ] +TRACE_LOGFILE_HEADER = _TRACE_LOGFILE_HEADER +PTRACE_LOGFILE_HEADER = POINTER(_TRACE_LOGFILE_HEADER) + +class _ANON__EVENT_TRACE_LOGFILEA_SUB_UNION_1(Union): + _fields_ = [ + ("LogFileMode", ULONG), + ("ProcessTraceMode", ULONG), + ] + + +class _ANON__EVENT_TRACE_LOGFILEA_SUB_UNION_2(Union): + _fields_ = [ + ("EventCallback", PEVENT_CALLBACK), + ("EventRecordCallback", PEVENT_RECORD_CALLBACK), + ] + +class _EVENT_TRACE_LOGFILEA(Structure): + _anonymous_ = ("anon_01","anon_02") + _fields_ = [ + ("LogFileName", LPSTR), + ("LoggerName", LPSTR), + ("CurrentTime", LONGLONG), + ("BuffersRead", ULONG), + ("anon_01", _ANON__EVENT_TRACE_LOGFILEA_SUB_UNION_1), + ("CurrentEvent", EVENT_TRACE), + ("LogfileHeader", TRACE_LOGFILE_HEADER), + ("BufferCallback", PEVENT_TRACE_BUFFER_CALLBACKA), + ("BufferSize", ULONG), + ("Filled", ULONG), + ("EventsLost", ULONG), + ("anon_02", _ANON__EVENT_TRACE_LOGFILEA_SUB_UNION_2), + ("IsKernelTrace", ULONG), + ("Context", PVOID), + ] +EVENT_TRACE_LOGFILEA = _EVENT_TRACE_LOGFILEA +PEVENT_TRACE_LOGFILEA = POINTER(_EVENT_TRACE_LOGFILEA) + +class _ANON__EVENT_TRACE_LOGFILEW_SUB_UNION_1(Union): + _fields_ = [ + ("LogFileMode", ULONG), + ("ProcessTraceMode", ULONG), + ] + + +class _ANON__EVENT_TRACE_LOGFILEW_SUB_UNION_2(Union): + _fields_ = [ + ("EventCallback", PEVENT_CALLBACK), + ("EventRecordCallback", PEVENT_RECORD_CALLBACK), + ] + +class _EVENT_TRACE_LOGFILEW(Structure): + _anonymous_ = ("anon_01","anon_02") + _fields_ = [ + ("LogFileName", LPWSTR), + ("LoggerName", LPWSTR), + ("CurrentTime", LONGLONG), + ("BuffersRead", ULONG), + ("anon_01", _ANON__EVENT_TRACE_LOGFILEW_SUB_UNION_1), + ("CurrentEvent", EVENT_TRACE), + ("LogfileHeader", TRACE_LOGFILE_HEADER), + ("BufferCallback", PEVENT_TRACE_BUFFER_CALLBACKW), + ("BufferSize", ULONG), + ("Filled", ULONG), + ("EventsLost", ULONG), + ("anon_02", _ANON__EVENT_TRACE_LOGFILEW_SUB_UNION_2), + ("IsKernelTrace", ULONG), + ("Context", PVOID), + ] +EVENT_TRACE_LOGFILEW = _EVENT_TRACE_LOGFILEW +PEVENT_TRACE_LOGFILEW = POINTER(_EVENT_TRACE_LOGFILEW) + +class _EVENT_FILTER_DESCRIPTOR(Structure): + _fields_ = [ + ("Ptr", ULONGLONG), + ("Size", ULONG), + ("Type", ULONG), + ] +PEVENT_FILTER_DESCRIPTOR = POINTER(_EVENT_FILTER_DESCRIPTOR) +EVENT_FILTER_DESCRIPTOR = _EVENT_FILTER_DESCRIPTOR + +class _ENABLE_TRACE_PARAMETERS(Structure): + _fields_ = [ + ("Version", ULONG), + ("EnableProperty", ULONG), + ("ControlFlags", ULONG), + ("SourceId", GUID), + ("EnableFilterDesc", PEVENT_FILTER_DESCRIPTOR), + ("FilterDescCount", ULONG), + ] +ENABLE_TRACE_PARAMETERS = _ENABLE_TRACE_PARAMETERS +PENABLE_TRACE_PARAMETERS = POINTER(_ENABLE_TRACE_PARAMETERS) + +class _EVENT_DESCRIPTOR(Structure): + _fields_ = [ + ("Id", USHORT), + ("Version", BYTE), + ("Channel", BYTE), + ("Level", BYTE), + ("Opcode", BYTE), + ("Task", USHORT), + ("Keyword", ULONGLONG), + ] +EVENT_DESCRIPTOR = _EVENT_DESCRIPTOR +PEVENT_DESCRIPTOR = POINTER(_EVENT_DESCRIPTOR) + +class _EVENT_DESCRIPTOR(_EVENT_DESCRIPTOR): + def __repr__(self): + return "<{0} Id={self.Id} Opcode={self.Opcode} Version={self.Version} Level={self.Level}>".format(type(self).__name__, self=self) +EVENT_DESCRIPTOR = _EVENT_DESCRIPTOR +PEVENT_DESCRIPTOR = POINTER(_EVENT_DESCRIPTOR) +class _ANON__ANON__EVENT_HEADER_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("KernelTime", ULONG), + ("UserTime", ULONG), + ] + +class _ANON__EVENT_HEADER_SUB_UNION_1(Union): + _anonymous_ = ("DUMMYSTRUCTNAME",) + _fields_ = [ + ("DUMMYSTRUCTNAME", _ANON__ANON__EVENT_HEADER_SUB_UNION_1_SUB_STRUCTURE_1), + ("ProcessorTime", ULONG64), + ] + +class _EVENT_HEADER(Structure): + _anonymous_ = ("DUMMYUNIONNAME",) + _fields_ = [ + ("Size", USHORT), + ("HeaderType", USHORT), + ("Flags", USHORT), + ("EventProperty", USHORT), + ("ThreadId", ULONG), + ("ProcessId", ULONG), + ("TimeStamp", LARGE_INTEGER), + ("ProviderId", GUID), + ("EventDescriptor", EVENT_DESCRIPTOR), + ("DUMMYUNIONNAME", _ANON__EVENT_HEADER_SUB_UNION_1), + ("ActivityId", GUID), + ] +EVENT_HEADER = _EVENT_HEADER +PEVENT_HEADER = POINTER(_EVENT_HEADER) + +class _ANON__EVENT_HEADER_EXTENDED_DATA_ITEM_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("Linkage", USHORT, 1), + ("Reserved2", USHORT, 15), + ] + +class _EVENT_HEADER_EXTENDED_DATA_ITEM(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Reserved1", USHORT), + ("ExtType", USHORT), + ("anon_01", _ANON__EVENT_HEADER_EXTENDED_DATA_ITEM_SUB_STRUCTURE_1), + ("DataSize", USHORT), + ("DataPtr", ULONGLONG), + ] +EVENT_HEADER_EXTENDED_DATA_ITEM = _EVENT_HEADER_EXTENDED_DATA_ITEM +PEVENT_HEADER_EXTENDED_DATA_ITEM = POINTER(_EVENT_HEADER_EXTENDED_DATA_ITEM) + +_OLD_EVENT_HEADER_EXTENDED_DATA_ITEM = _EVENT_HEADER_EXTENDED_DATA_ITEM +class _EVENT_HEADER_EXTENDED_DATA_ITEM(_OLD_EVENT_HEADER_EXTENDED_DATA_ITEM): + @property + def data(self): + bdata = (ctypes.c_char * self.DataSize).from_address(self.DataPtr) + return bdata[:] +EVENT_HEADER_EXTENDED_DATA_ITEM = _EVENT_HEADER_EXTENDED_DATA_ITEM +PEVENT_HEADER_EXTENDED_DATA_ITEM = POINTER(_EVENT_HEADER_EXTENDED_DATA_ITEM) +class _EVENT_RECORD(Structure): + _fields_ = [ + ("EventHeader", EVENT_HEADER), + ("BufferContext", ETW_BUFFER_CONTEXT), + ("ExtendedDataCount", USHORT), + ("UserDataLength", USHORT), + ("ExtendedData", PEVENT_HEADER_EXTENDED_DATA_ITEM), + ("UserData", PVOID), + ("UserContext", PVOID), + ] +EVENT_RECORD = _EVENT_RECORD +PEVENT_RECORD = POINTER(_EVENT_RECORD) + +_OLD_EVENT_RECORD = _EVENT_RECORD +class _EVENT_RECORD(_OLD_EVENT_RECORD): + pass +EVENT_RECORD = _EVENT_RECORD +PEVENT_RECORD = POINTER(_EVENT_RECORD) +WBEM_GENUS_CLASS = EnumValue("tag_WBEM_GENUS_TYPE", "WBEM_GENUS_CLASS", 0x1) +WBEM_GENUS_INSTANCE = EnumValue("tag_WBEM_GENUS_TYPE", "WBEM_GENUS_INSTANCE", 0x2) +class tag_WBEM_GENUS_TYPE(EnumType): + values = [WBEM_GENUS_CLASS, WBEM_GENUS_INSTANCE] + mapper = FlagMapper(*values) +WBEM_GENUS_TYPE = tag_WBEM_GENUS_TYPE + + +WBEM_FLAG_CREATE_OR_UPDATE = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_CREATE_OR_UPDATE", 0x0) +WBEM_FLAG_UPDATE_ONLY = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_UPDATE_ONLY", 0x1) +WBEM_FLAG_CREATE_ONLY = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_CREATE_ONLY", 0x2) +WBEM_FLAG_UPDATE_COMPATIBLE = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_UPDATE_COMPATIBLE", 0x0) +WBEM_FLAG_UPDATE_SAFE_MODE = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_UPDATE_SAFE_MODE", 0x20) +WBEM_FLAG_UPDATE_FORCE_MODE = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_UPDATE_FORCE_MODE", 0x40) +WBEM_MASK_UPDATE_MODE = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_MASK_UPDATE_MODE", 0x60) +WBEM_FLAG_ADVISORY = EnumValue("tag_WBEM_CHANGE_FLAG_TYPE", "WBEM_FLAG_ADVISORY", 0x10000) +class tag_WBEM_CHANGE_FLAG_TYPE(EnumType): + values = [WBEM_FLAG_CREATE_OR_UPDATE, WBEM_FLAG_UPDATE_ONLY, WBEM_FLAG_CREATE_ONLY, WBEM_FLAG_UPDATE_COMPATIBLE, WBEM_FLAG_UPDATE_SAFE_MODE, WBEM_FLAG_UPDATE_FORCE_MODE, WBEM_MASK_UPDATE_MODE, WBEM_FLAG_ADVISORY] + mapper = FlagMapper(*values) +WBEM_CHANGE_FLAG_TYPE = tag_WBEM_CHANGE_FLAG_TYPE + + +WBEM_NO_ERROR = EnumValue("tag_WBEMSTATUS", "WBEM_NO_ERROR", 0x0) +WBEM_S_NO_ERROR = EnumValue("tag_WBEMSTATUS", "WBEM_S_NO_ERROR", 0x0) +WBEM_S_SAME = EnumValue("tag_WBEMSTATUS", "WBEM_S_SAME", 0x0) +WBEM_S_FALSE = EnumValue("tag_WBEMSTATUS", "WBEM_S_FALSE", 0x1) +WBEM_S_ALREADY_EXISTS = EnumValue("tag_WBEMSTATUS", "WBEM_S_ALREADY_EXISTS", 0x40001) +WBEM_S_RESET_TO_DEFAULT = EnumValue("tag_WBEMSTATUS", "WBEM_S_RESET_TO_DEFAULT", 0x40002) +WBEM_S_DIFFERENT = EnumValue("tag_WBEMSTATUS", "WBEM_S_DIFFERENT", 0x40003) +WBEM_S_TIMEDOUT = EnumValue("tag_WBEMSTATUS", "WBEM_S_TIMEDOUT", 0x40004) +WBEM_S_NO_MORE_DATA = EnumValue("tag_WBEMSTATUS", "WBEM_S_NO_MORE_DATA", 0x40005) +WBEM_S_OPERATION_CANCELLED = EnumValue("tag_WBEMSTATUS", "WBEM_S_OPERATION_CANCELLED", 0x40006) +WBEM_S_PENDING = EnumValue("tag_WBEMSTATUS", "WBEM_S_PENDING", 0x40007) +WBEM_S_DUPLICATE_OBJECTS = EnumValue("tag_WBEMSTATUS", "WBEM_S_DUPLICATE_OBJECTS", 0x40008) +WBEM_S_ACCESS_DENIED = EnumValue("tag_WBEMSTATUS", "WBEM_S_ACCESS_DENIED", 0x40009) +WBEM_S_PARTIAL_RESULTS = EnumValue("tag_WBEMSTATUS", "WBEM_S_PARTIAL_RESULTS", 0x40010) +WBEM_S_SOURCE_NOT_AVAILABLE = EnumValue("tag_WBEMSTATUS", "WBEM_S_SOURCE_NOT_AVAILABLE", 0x40017) +WBEM_E_FAILED = EnumValue("tag_WBEMSTATUS", "WBEM_E_FAILED", 0x80041001) +WBEM_E_NOT_FOUND = EnumValue("tag_WBEMSTATUS", "WBEM_E_NOT_FOUND", 0x80041002) +WBEM_E_ACCESS_DENIED = EnumValue("tag_WBEMSTATUS", "WBEM_E_ACCESS_DENIED", 0x80041003) +WBEM_E_PROVIDER_FAILURE = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_FAILURE", 0x80041004) +WBEM_E_TYPE_MISMATCH = EnumValue("tag_WBEMSTATUS", "WBEM_E_TYPE_MISMATCH", 0x80041005) +WBEM_E_OUT_OF_MEMORY = EnumValue("tag_WBEMSTATUS", "WBEM_E_OUT_OF_MEMORY", 0x80041006) +WBEM_E_INVALID_CONTEXT = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_CONTEXT", 0x80041007) +WBEM_E_INVALID_PARAMETER = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_PARAMETER", 0x80041008) +WBEM_E_NOT_AVAILABLE = EnumValue("tag_WBEMSTATUS", "WBEM_E_NOT_AVAILABLE", 0x80041009) +WBEM_E_CRITICAL_ERROR = EnumValue("tag_WBEMSTATUS", "WBEM_E_CRITICAL_ERROR", 0x8004100a) +WBEM_E_INVALID_STREAM = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_STREAM", 0x8004100b) +WBEM_E_NOT_SUPPORTED = EnumValue("tag_WBEMSTATUS", "WBEM_E_NOT_SUPPORTED", 0x8004100c) +WBEM_E_INVALID_SUPERCLASS = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_SUPERCLASS", 0x8004100d) +WBEM_E_INVALID_NAMESPACE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_NAMESPACE", 0x8004100e) +WBEM_E_INVALID_OBJECT = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_OBJECT", 0x8004100f) +WBEM_E_INVALID_CLASS = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_CLASS", 0x80041010) +WBEM_E_PROVIDER_NOT_FOUND = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_NOT_FOUND", 0x80041011) +WBEM_E_INVALID_PROVIDER_REGISTRATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_PROVIDER_REGISTRATION", 0x80041012) +WBEM_E_PROVIDER_LOAD_FAILURE = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_LOAD_FAILURE", 0x80041013) +WBEM_E_INITIALIZATION_FAILURE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INITIALIZATION_FAILURE", 0x80041014) +WBEM_E_TRANSPORT_FAILURE = EnumValue("tag_WBEMSTATUS", "WBEM_E_TRANSPORT_FAILURE", 0x80041015) +WBEM_E_INVALID_OPERATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_OPERATION", 0x80041016) +WBEM_E_INVALID_QUERY = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_QUERY", 0x80041017) +WBEM_E_INVALID_QUERY_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_QUERY_TYPE", 0x80041018) +WBEM_E_ALREADY_EXISTS = EnumValue("tag_WBEMSTATUS", "WBEM_E_ALREADY_EXISTS", 0x80041019) +WBEM_E_OVERRIDE_NOT_ALLOWED = EnumValue("tag_WBEMSTATUS", "WBEM_E_OVERRIDE_NOT_ALLOWED", 0x8004101a) +WBEM_E_PROPAGATED_QUALIFIER = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROPAGATED_QUALIFIER", 0x8004101b) +WBEM_E_PROPAGATED_PROPERTY = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROPAGATED_PROPERTY", 0x8004101c) +WBEM_E_UNEXPECTED = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNEXPECTED", 0x8004101d) +WBEM_E_ILLEGAL_OPERATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_ILLEGAL_OPERATION", 0x8004101e) +WBEM_E_CANNOT_BE_KEY = EnumValue("tag_WBEMSTATUS", "WBEM_E_CANNOT_BE_KEY", 0x8004101f) +WBEM_E_INCOMPLETE_CLASS = EnumValue("tag_WBEMSTATUS", "WBEM_E_INCOMPLETE_CLASS", 0x80041020) +WBEM_E_INVALID_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_SYNTAX", 0x80041021) +WBEM_E_NONDECORATED_OBJECT = EnumValue("tag_WBEMSTATUS", "WBEM_E_NONDECORATED_OBJECT", 0x80041022) +WBEM_E_READ_ONLY = EnumValue("tag_WBEMSTATUS", "WBEM_E_READ_ONLY", 0x80041023) +WBEM_E_PROVIDER_NOT_CAPABLE = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_NOT_CAPABLE", 0x80041024) +WBEM_E_CLASS_HAS_CHILDREN = EnumValue("tag_WBEMSTATUS", "WBEM_E_CLASS_HAS_CHILDREN", 0x80041025) +WBEM_E_CLASS_HAS_INSTANCES = EnumValue("tag_WBEMSTATUS", "WBEM_E_CLASS_HAS_INSTANCES", 0x80041026) +WBEM_E_QUERY_NOT_IMPLEMENTED = EnumValue("tag_WBEMSTATUS", "WBEM_E_QUERY_NOT_IMPLEMENTED", 0x80041027) +WBEM_E_ILLEGAL_NULL = EnumValue("tag_WBEMSTATUS", "WBEM_E_ILLEGAL_NULL", 0x80041028) +WBEM_E_INVALID_QUALIFIER_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_QUALIFIER_TYPE", 0x80041029) +WBEM_E_INVALID_PROPERTY_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_PROPERTY_TYPE", 0x8004102a) +WBEM_E_VALUE_OUT_OF_RANGE = EnumValue("tag_WBEMSTATUS", "WBEM_E_VALUE_OUT_OF_RANGE", 0x8004102b) +WBEM_E_CANNOT_BE_SINGLETON = EnumValue("tag_WBEMSTATUS", "WBEM_E_CANNOT_BE_SINGLETON", 0x8004102c) +WBEM_E_INVALID_CIM_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_CIM_TYPE", 0x8004102d) +WBEM_E_INVALID_METHOD = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_METHOD", 0x8004102e) +WBEM_E_INVALID_METHOD_PARAMETERS = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_METHOD_PARAMETERS", 0x8004102f) +WBEM_E_SYSTEM_PROPERTY = EnumValue("tag_WBEMSTATUS", "WBEM_E_SYSTEM_PROPERTY", 0x80041030) +WBEM_E_INVALID_PROPERTY = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_PROPERTY", 0x80041031) +WBEM_E_CALL_CANCELLED = EnumValue("tag_WBEMSTATUS", "WBEM_E_CALL_CANCELLED", 0x80041032) +WBEM_E_SHUTTING_DOWN = EnumValue("tag_WBEMSTATUS", "WBEM_E_SHUTTING_DOWN", 0x80041033) +WBEM_E_PROPAGATED_METHOD = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROPAGATED_METHOD", 0x80041034) +WBEM_E_UNSUPPORTED_PARAMETER = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNSUPPORTED_PARAMETER", 0x80041035) +WBEM_E_MISSING_PARAMETER_ID = EnumValue("tag_WBEMSTATUS", "WBEM_E_MISSING_PARAMETER_ID", 0x80041036) +WBEM_E_INVALID_PARAMETER_ID = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_PARAMETER_ID", 0x80041037) +WBEM_E_NONCONSECUTIVE_PARAMETER_IDS = EnumValue("tag_WBEMSTATUS", "WBEM_E_NONCONSECUTIVE_PARAMETER_IDS", 0x80041038) +WBEM_E_PARAMETER_ID_ON_RETVAL = EnumValue("tag_WBEMSTATUS", "WBEM_E_PARAMETER_ID_ON_RETVAL", 0x80041039) +WBEM_E_INVALID_OBJECT_PATH = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_OBJECT_PATH", 0x8004103a) +WBEM_E_OUT_OF_DISK_SPACE = EnumValue("tag_WBEMSTATUS", "WBEM_E_OUT_OF_DISK_SPACE", 0x8004103b) +WBEM_E_BUFFER_TOO_SMALL = EnumValue("tag_WBEMSTATUS", "WBEM_E_BUFFER_TOO_SMALL", 0x8004103c) +WBEM_E_UNSUPPORTED_PUT_EXTENSION = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNSUPPORTED_PUT_EXTENSION", 0x8004103d) +WBEM_E_UNKNOWN_OBJECT_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNKNOWN_OBJECT_TYPE", 0x8004103e) +WBEM_E_UNKNOWN_PACKET_TYPE = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNKNOWN_PACKET_TYPE", 0x8004103f) +WBEM_E_MARSHAL_VERSION_MISMATCH = EnumValue("tag_WBEMSTATUS", "WBEM_E_MARSHAL_VERSION_MISMATCH", 0x80041040) +WBEM_E_MARSHAL_INVALID_SIGNATURE = EnumValue("tag_WBEMSTATUS", "WBEM_E_MARSHAL_INVALID_SIGNATURE", 0x80041041) +WBEM_E_INVALID_QUALIFIER = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_QUALIFIER", 0x80041042) +WBEM_E_INVALID_DUPLICATE_PARAMETER = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_DUPLICATE_PARAMETER", 0x80041043) +WBEM_E_TOO_MUCH_DATA = EnumValue("tag_WBEMSTATUS", "WBEM_E_TOO_MUCH_DATA", 0x80041044) +WBEM_E_SERVER_TOO_BUSY = EnumValue("tag_WBEMSTATUS", "WBEM_E_SERVER_TOO_BUSY", 0x80041045) +WBEM_E_INVALID_FLAVOR = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_FLAVOR", 0x80041046) +WBEM_E_CIRCULAR_REFERENCE = EnumValue("tag_WBEMSTATUS", "WBEM_E_CIRCULAR_REFERENCE", 0x80041047) +WBEM_E_UNSUPPORTED_CLASS_UPDATE = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNSUPPORTED_CLASS_UPDATE", 0x80041048) +WBEM_E_CANNOT_CHANGE_KEY_INHERITANCE = EnumValue("tag_WBEMSTATUS", "WBEM_E_CANNOT_CHANGE_KEY_INHERITANCE", 0x80041049) +WBEM_E_CANNOT_CHANGE_INDEX_INHERITANCE = EnumValue("tag_WBEMSTATUS", "WBEM_E_CANNOT_CHANGE_INDEX_INHERITANCE", 0x80041050) +WBEM_E_TOO_MANY_PROPERTIES = EnumValue("tag_WBEMSTATUS", "WBEM_E_TOO_MANY_PROPERTIES", 0x80041051) +WBEM_E_UPDATE_TYPE_MISMATCH = EnumValue("tag_WBEMSTATUS", "WBEM_E_UPDATE_TYPE_MISMATCH", 0x80041052) +WBEM_E_UPDATE_OVERRIDE_NOT_ALLOWED = EnumValue("tag_WBEMSTATUS", "WBEM_E_UPDATE_OVERRIDE_NOT_ALLOWED", 0x80041053) +WBEM_E_UPDATE_PROPAGATED_METHOD = EnumValue("tag_WBEMSTATUS", "WBEM_E_UPDATE_PROPAGATED_METHOD", 0x80041054) +WBEM_E_METHOD_NOT_IMPLEMENTED = EnumValue("tag_WBEMSTATUS", "WBEM_E_METHOD_NOT_IMPLEMENTED", 0x80041055) +WBEM_E_METHOD_DISABLED = EnumValue("tag_WBEMSTATUS", "WBEM_E_METHOD_DISABLED", 0x80041056) +WBEM_E_REFRESHER_BUSY = EnumValue("tag_WBEMSTATUS", "WBEM_E_REFRESHER_BUSY", 0x80041057) +WBEM_E_UNPARSABLE_QUERY = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNPARSABLE_QUERY", 0x80041058) +WBEM_E_NOT_EVENT_CLASS = EnumValue("tag_WBEMSTATUS", "WBEM_E_NOT_EVENT_CLASS", 0x80041059) +WBEM_E_MISSING_GROUP_WITHIN = EnumValue("tag_WBEMSTATUS", "WBEM_E_MISSING_GROUP_WITHIN", 0x8004105a) +WBEM_E_MISSING_AGGREGATION_LIST = EnumValue("tag_WBEMSTATUS", "WBEM_E_MISSING_AGGREGATION_LIST", 0x8004105b) +WBEM_E_PROPERTY_NOT_AN_OBJECT = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROPERTY_NOT_AN_OBJECT", 0x8004105c) +WBEM_E_AGGREGATING_BY_OBJECT = EnumValue("tag_WBEMSTATUS", "WBEM_E_AGGREGATING_BY_OBJECT", 0x8004105d) +WBEM_E_UNINTERPRETABLE_PROVIDER_QUERY = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNINTERPRETABLE_PROVIDER_QUERY", 0x8004105f) +WBEM_E_BACKUP_RESTORE_WINMGMT_RUNNING = EnumValue("tag_WBEMSTATUS", "WBEM_E_BACKUP_RESTORE_WINMGMT_RUNNING", 0x80041060) +WBEM_E_QUEUE_OVERFLOW = EnumValue("tag_WBEMSTATUS", "WBEM_E_QUEUE_OVERFLOW", 0x80041061) +WBEM_E_PRIVILEGE_NOT_HELD = EnumValue("tag_WBEMSTATUS", "WBEM_E_PRIVILEGE_NOT_HELD", 0x80041062) +WBEM_E_INVALID_OPERATOR = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_OPERATOR", 0x80041063) +WBEM_E_LOCAL_CREDENTIALS = EnumValue("tag_WBEMSTATUS", "WBEM_E_LOCAL_CREDENTIALS", 0x80041064) +WBEM_E_CANNOT_BE_ABSTRACT = EnumValue("tag_WBEMSTATUS", "WBEM_E_CANNOT_BE_ABSTRACT", 0x80041065) +WBEM_E_AMENDED_OBJECT = EnumValue("tag_WBEMSTATUS", "WBEM_E_AMENDED_OBJECT", 0x80041066) +WBEM_E_CLIENT_TOO_SLOW = EnumValue("tag_WBEMSTATUS", "WBEM_E_CLIENT_TOO_SLOW", 0x80041067) +WBEM_E_NULL_SECURITY_DESCRIPTOR = EnumValue("tag_WBEMSTATUS", "WBEM_E_NULL_SECURITY_DESCRIPTOR", 0x80041068) +WBEM_E_TIMED_OUT = EnumValue("tag_WBEMSTATUS", "WBEM_E_TIMED_OUT", 0x80041069) +WBEM_E_INVALID_ASSOCIATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_ASSOCIATION", 0x8004106a) +WBEM_E_AMBIGUOUS_OPERATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_AMBIGUOUS_OPERATION", 0x8004106b) +WBEM_E_QUOTA_VIOLATION = EnumValue("tag_WBEMSTATUS", "WBEM_E_QUOTA_VIOLATION", 0x8004106c) +WBEM_E_RESERVED_001 = EnumValue("tag_WBEMSTATUS", "WBEM_E_RESERVED_001", 0x8004106d) +WBEM_E_RESERVED_002 = EnumValue("tag_WBEMSTATUS", "WBEM_E_RESERVED_002", 0x8004106e) +WBEM_E_UNSUPPORTED_LOCALE = EnumValue("tag_WBEMSTATUS", "WBEM_E_UNSUPPORTED_LOCALE", 0x8004106f) +WBEM_E_HANDLE_OUT_OF_DATE = EnumValue("tag_WBEMSTATUS", "WBEM_E_HANDLE_OUT_OF_DATE", 0x80041070) +WBEM_E_CONNECTION_FAILED = EnumValue("tag_WBEMSTATUS", "WBEM_E_CONNECTION_FAILED", 0x80041071) +WBEM_E_INVALID_HANDLE_REQUEST = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_HANDLE_REQUEST", 0x80041072) +WBEM_E_PROPERTY_NAME_TOO_WIDE = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROPERTY_NAME_TOO_WIDE", 0x80041073) +WBEM_E_CLASS_NAME_TOO_WIDE = EnumValue("tag_WBEMSTATUS", "WBEM_E_CLASS_NAME_TOO_WIDE", 0x80041074) +WBEM_E_METHOD_NAME_TOO_WIDE = EnumValue("tag_WBEMSTATUS", "WBEM_E_METHOD_NAME_TOO_WIDE", 0x80041075) +WBEM_E_QUALIFIER_NAME_TOO_WIDE = EnumValue("tag_WBEMSTATUS", "WBEM_E_QUALIFIER_NAME_TOO_WIDE", 0x80041076) +WBEM_E_RERUN_COMMAND = EnumValue("tag_WBEMSTATUS", "WBEM_E_RERUN_COMMAND", 0x80041077) +WBEM_E_DATABASE_VER_MISMATCH = EnumValue("tag_WBEMSTATUS", "WBEM_E_DATABASE_VER_MISMATCH", 0x80041078) +WBEM_E_VETO_DELETE = EnumValue("tag_WBEMSTATUS", "WBEM_E_VETO_DELETE", 0x80041079) +WBEM_E_VETO_PUT = EnumValue("tag_WBEMSTATUS", "WBEM_E_VETO_PUT", 0x8004107a) +WBEM_E_INVALID_LOCALE = EnumValue("tag_WBEMSTATUS", "WBEM_E_INVALID_LOCALE", 0x80041080) +WBEM_E_PROVIDER_SUSPENDED = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_SUSPENDED", 0x80041081) +WBEM_E_SYNCHRONIZATION_REQUIRED = EnumValue("tag_WBEMSTATUS", "WBEM_E_SYNCHRONIZATION_REQUIRED", 0x80041082) +WBEM_E_NO_SCHEMA = EnumValue("tag_WBEMSTATUS", "WBEM_E_NO_SCHEMA", 0x80041083) +WBEM_E_PROVIDER_ALREADY_REGISTERED = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_ALREADY_REGISTERED", 0x80041084) +WBEM_E_PROVIDER_NOT_REGISTERED = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_NOT_REGISTERED", 0x80041085) +WBEM_E_FATAL_TRANSPORT_ERROR = EnumValue("tag_WBEMSTATUS", "WBEM_E_FATAL_TRANSPORT_ERROR", 0x80041086) +WBEM_E_ENCRYPTED_CONNECTION_REQUIRED = EnumValue("tag_WBEMSTATUS", "WBEM_E_ENCRYPTED_CONNECTION_REQUIRED", 0x80041087) +WBEM_E_PROVIDER_TIMED_OUT = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_TIMED_OUT", 0x80041088) +WBEM_E_NO_KEY = EnumValue("tag_WBEMSTATUS", "WBEM_E_NO_KEY", 0x80041089) +WBEM_E_PROVIDER_DISABLED = EnumValue("tag_WBEMSTATUS", "WBEM_E_PROVIDER_DISABLED", 0x8004108a) +WBEMESS_E_REGISTRATION_TOO_BROAD = EnumValue("tag_WBEMSTATUS", "WBEMESS_E_REGISTRATION_TOO_BROAD", 0x80042001) +WBEMESS_E_REGISTRATION_TOO_PRECISE = EnumValue("tag_WBEMSTATUS", "WBEMESS_E_REGISTRATION_TOO_PRECISE", 0x80042002) +WBEMESS_E_AUTHZ_NOT_PRIVILEGED = EnumValue("tag_WBEMSTATUS", "WBEMESS_E_AUTHZ_NOT_PRIVILEGED", 0x80042003) +WBEMMOF_E_EXPECTED_QUALIFIER_NAME = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_QUALIFIER_NAME", 0x80044001) +WBEMMOF_E_EXPECTED_SEMI = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_SEMI", 0x80044002) +WBEMMOF_E_EXPECTED_OPEN_BRACE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_OPEN_BRACE", 0x80044003) +WBEMMOF_E_EXPECTED_CLOSE_BRACE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_CLOSE_BRACE", 0x80044004) +WBEMMOF_E_EXPECTED_CLOSE_BRACKET = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_CLOSE_BRACKET", 0x80044005) +WBEMMOF_E_EXPECTED_CLOSE_PAREN = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_CLOSE_PAREN", 0x80044006) +WBEMMOF_E_ILLEGAL_CONSTANT_VALUE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_ILLEGAL_CONSTANT_VALUE", 0x80044007) +WBEMMOF_E_EXPECTED_TYPE_IDENTIFIER = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_TYPE_IDENTIFIER", 0x80044008) +WBEMMOF_E_EXPECTED_OPEN_PAREN = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_OPEN_PAREN", 0x80044009) +WBEMMOF_E_UNRECOGNIZED_TOKEN = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNRECOGNIZED_TOKEN", 0x8004400a) +WBEMMOF_E_UNRECOGNIZED_TYPE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNRECOGNIZED_TYPE", 0x8004400b) +WBEMMOF_E_EXPECTED_PROPERTY_NAME = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_PROPERTY_NAME", 0x8004400c) +WBEMMOF_E_TYPEDEF_NOT_SUPPORTED = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_TYPEDEF_NOT_SUPPORTED", 0x8004400d) +WBEMMOF_E_UNEXPECTED_ALIAS = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNEXPECTED_ALIAS", 0x8004400e) +WBEMMOF_E_UNEXPECTED_ARRAY_INIT = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNEXPECTED_ARRAY_INIT", 0x8004400f) +WBEMMOF_E_INVALID_AMENDMENT_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_AMENDMENT_SYNTAX", 0x80044010) +WBEMMOF_E_INVALID_DUPLICATE_AMENDMENT = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_DUPLICATE_AMENDMENT", 0x80044011) +WBEMMOF_E_INVALID_PRAGMA = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_PRAGMA", 0x80044012) +WBEMMOF_E_INVALID_NAMESPACE_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_NAMESPACE_SYNTAX", 0x80044013) +WBEMMOF_E_EXPECTED_CLASS_NAME = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_CLASS_NAME", 0x80044014) +WBEMMOF_E_TYPE_MISMATCH = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_TYPE_MISMATCH", 0x80044015) +WBEMMOF_E_EXPECTED_ALIAS_NAME = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_ALIAS_NAME", 0x80044016) +WBEMMOF_E_INVALID_CLASS_DECLARATION = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_CLASS_DECLARATION", 0x80044017) +WBEMMOF_E_INVALID_INSTANCE_DECLARATION = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_INSTANCE_DECLARATION", 0x80044018) +WBEMMOF_E_EXPECTED_DOLLAR = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_DOLLAR", 0x80044019) +WBEMMOF_E_CIMTYPE_QUALIFIER = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_CIMTYPE_QUALIFIER", 0x8004401a) +WBEMMOF_E_DUPLICATE_PROPERTY = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_DUPLICATE_PROPERTY", 0x8004401b) +WBEMMOF_E_INVALID_NAMESPACE_SPECIFICATION = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_NAMESPACE_SPECIFICATION", 0x8004401c) +WBEMMOF_E_OUT_OF_RANGE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_OUT_OF_RANGE", 0x8004401d) +WBEMMOF_E_INVALID_FILE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_FILE", 0x8004401e) +WBEMMOF_E_ALIASES_IN_EMBEDDED = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_ALIASES_IN_EMBEDDED", 0x8004401f) +WBEMMOF_E_NULL_ARRAY_ELEM = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_NULL_ARRAY_ELEM", 0x80044020) +WBEMMOF_E_DUPLICATE_QUALIFIER = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_DUPLICATE_QUALIFIER", 0x80044021) +WBEMMOF_E_EXPECTED_FLAVOR_TYPE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_FLAVOR_TYPE", 0x80044022) +WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES", 0x80044023) +WBEMMOF_E_MULTIPLE_ALIASES = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_MULTIPLE_ALIASES", 0x80044024) +WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES2 = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES2", 0x80044025) +WBEMMOF_E_NO_ARRAYS_RETURNED = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_NO_ARRAYS_RETURNED", 0x80044026) +WBEMMOF_E_MUST_BE_IN_OR_OUT = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_MUST_BE_IN_OR_OUT", 0x80044027) +WBEMMOF_E_INVALID_FLAGS_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_FLAGS_SYNTAX", 0x80044028) +WBEMMOF_E_EXPECTED_BRACE_OR_BAD_TYPE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_EXPECTED_BRACE_OR_BAD_TYPE", 0x80044029) +WBEMMOF_E_UNSUPPORTED_CIMV22_QUAL_VALUE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNSUPPORTED_CIMV22_QUAL_VALUE", 0x8004402a) +WBEMMOF_E_UNSUPPORTED_CIMV22_DATA_TYPE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_UNSUPPORTED_CIMV22_DATA_TYPE", 0x8004402b) +WBEMMOF_E_INVALID_DELETEINSTANCE_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_DELETEINSTANCE_SYNTAX", 0x8004402c) +WBEMMOF_E_INVALID_QUALIFIER_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_QUALIFIER_SYNTAX", 0x8004402d) +WBEMMOF_E_QUALIFIER_USED_OUTSIDE_SCOPE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_QUALIFIER_USED_OUTSIDE_SCOPE", 0x8004402e) +WBEMMOF_E_ERROR_CREATING_TEMP_FILE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_ERROR_CREATING_TEMP_FILE", 0x8004402f) +WBEMMOF_E_ERROR_INVALID_INCLUDE_FILE = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_ERROR_INVALID_INCLUDE_FILE", 0x80044030) +WBEMMOF_E_INVALID_DELETECLASS_SYNTAX = EnumValue("tag_WBEMSTATUS", "WBEMMOF_E_INVALID_DELETECLASS_SYNTAX", 0x80044031) +class tag_WBEMSTATUS(EnumType): + values = [WBEM_NO_ERROR, WBEM_S_NO_ERROR, WBEM_S_SAME, WBEM_S_FALSE, WBEM_S_ALREADY_EXISTS, WBEM_S_RESET_TO_DEFAULT, WBEM_S_DIFFERENT, WBEM_S_TIMEDOUT, WBEM_S_NO_MORE_DATA, WBEM_S_OPERATION_CANCELLED, WBEM_S_PENDING, WBEM_S_DUPLICATE_OBJECTS, WBEM_S_ACCESS_DENIED, WBEM_S_PARTIAL_RESULTS, WBEM_S_SOURCE_NOT_AVAILABLE, WBEM_E_FAILED, WBEM_E_NOT_FOUND, WBEM_E_ACCESS_DENIED, WBEM_E_PROVIDER_FAILURE, WBEM_E_TYPE_MISMATCH, WBEM_E_OUT_OF_MEMORY, WBEM_E_INVALID_CONTEXT, WBEM_E_INVALID_PARAMETER, WBEM_E_NOT_AVAILABLE, WBEM_E_CRITICAL_ERROR, WBEM_E_INVALID_STREAM, WBEM_E_NOT_SUPPORTED, WBEM_E_INVALID_SUPERCLASS, WBEM_E_INVALID_NAMESPACE, WBEM_E_INVALID_OBJECT, WBEM_E_INVALID_CLASS, WBEM_E_PROVIDER_NOT_FOUND, WBEM_E_INVALID_PROVIDER_REGISTRATION, WBEM_E_PROVIDER_LOAD_FAILURE, WBEM_E_INITIALIZATION_FAILURE, WBEM_E_TRANSPORT_FAILURE, WBEM_E_INVALID_OPERATION, WBEM_E_INVALID_QUERY, WBEM_E_INVALID_QUERY_TYPE, WBEM_E_ALREADY_EXISTS, WBEM_E_OVERRIDE_NOT_ALLOWED, WBEM_E_PROPAGATED_QUALIFIER, WBEM_E_PROPAGATED_PROPERTY, WBEM_E_UNEXPECTED, WBEM_E_ILLEGAL_OPERATION, WBEM_E_CANNOT_BE_KEY, WBEM_E_INCOMPLETE_CLASS, WBEM_E_INVALID_SYNTAX, WBEM_E_NONDECORATED_OBJECT, WBEM_E_READ_ONLY, WBEM_E_PROVIDER_NOT_CAPABLE, WBEM_E_CLASS_HAS_CHILDREN, WBEM_E_CLASS_HAS_INSTANCES, WBEM_E_QUERY_NOT_IMPLEMENTED, WBEM_E_ILLEGAL_NULL, WBEM_E_INVALID_QUALIFIER_TYPE, WBEM_E_INVALID_PROPERTY_TYPE, WBEM_E_VALUE_OUT_OF_RANGE, WBEM_E_CANNOT_BE_SINGLETON, WBEM_E_INVALID_CIM_TYPE, WBEM_E_INVALID_METHOD, WBEM_E_INVALID_METHOD_PARAMETERS, WBEM_E_SYSTEM_PROPERTY, WBEM_E_INVALID_PROPERTY, WBEM_E_CALL_CANCELLED, WBEM_E_SHUTTING_DOWN, WBEM_E_PROPAGATED_METHOD, WBEM_E_UNSUPPORTED_PARAMETER, WBEM_E_MISSING_PARAMETER_ID, WBEM_E_INVALID_PARAMETER_ID, WBEM_E_NONCONSECUTIVE_PARAMETER_IDS, WBEM_E_PARAMETER_ID_ON_RETVAL, WBEM_E_INVALID_OBJECT_PATH, WBEM_E_OUT_OF_DISK_SPACE, WBEM_E_BUFFER_TOO_SMALL, WBEM_E_UNSUPPORTED_PUT_EXTENSION, WBEM_E_UNKNOWN_OBJECT_TYPE, WBEM_E_UNKNOWN_PACKET_TYPE, WBEM_E_MARSHAL_VERSION_MISMATCH, WBEM_E_MARSHAL_INVALID_SIGNATURE, WBEM_E_INVALID_QUALIFIER, WBEM_E_INVALID_DUPLICATE_PARAMETER, WBEM_E_TOO_MUCH_DATA, WBEM_E_SERVER_TOO_BUSY, WBEM_E_INVALID_FLAVOR, WBEM_E_CIRCULAR_REFERENCE, WBEM_E_UNSUPPORTED_CLASS_UPDATE, WBEM_E_CANNOT_CHANGE_KEY_INHERITANCE, WBEM_E_CANNOT_CHANGE_INDEX_INHERITANCE, WBEM_E_TOO_MANY_PROPERTIES, WBEM_E_UPDATE_TYPE_MISMATCH, WBEM_E_UPDATE_OVERRIDE_NOT_ALLOWED, WBEM_E_UPDATE_PROPAGATED_METHOD, WBEM_E_METHOD_NOT_IMPLEMENTED, WBEM_E_METHOD_DISABLED, WBEM_E_REFRESHER_BUSY, WBEM_E_UNPARSABLE_QUERY, WBEM_E_NOT_EVENT_CLASS, WBEM_E_MISSING_GROUP_WITHIN, WBEM_E_MISSING_AGGREGATION_LIST, WBEM_E_PROPERTY_NOT_AN_OBJECT, WBEM_E_AGGREGATING_BY_OBJECT, WBEM_E_UNINTERPRETABLE_PROVIDER_QUERY, WBEM_E_BACKUP_RESTORE_WINMGMT_RUNNING, WBEM_E_QUEUE_OVERFLOW, WBEM_E_PRIVILEGE_NOT_HELD, WBEM_E_INVALID_OPERATOR, WBEM_E_LOCAL_CREDENTIALS, WBEM_E_CANNOT_BE_ABSTRACT, WBEM_E_AMENDED_OBJECT, WBEM_E_CLIENT_TOO_SLOW, WBEM_E_NULL_SECURITY_DESCRIPTOR, WBEM_E_TIMED_OUT, WBEM_E_INVALID_ASSOCIATION, WBEM_E_AMBIGUOUS_OPERATION, WBEM_E_QUOTA_VIOLATION, WBEM_E_RESERVED_001, WBEM_E_RESERVED_002, WBEM_E_UNSUPPORTED_LOCALE, WBEM_E_HANDLE_OUT_OF_DATE, WBEM_E_CONNECTION_FAILED, WBEM_E_INVALID_HANDLE_REQUEST, WBEM_E_PROPERTY_NAME_TOO_WIDE, WBEM_E_CLASS_NAME_TOO_WIDE, WBEM_E_METHOD_NAME_TOO_WIDE, WBEM_E_QUALIFIER_NAME_TOO_WIDE, WBEM_E_RERUN_COMMAND, WBEM_E_DATABASE_VER_MISMATCH, WBEM_E_VETO_DELETE, WBEM_E_VETO_PUT, WBEM_E_INVALID_LOCALE, WBEM_E_PROVIDER_SUSPENDED, WBEM_E_SYNCHRONIZATION_REQUIRED, WBEM_E_NO_SCHEMA, WBEM_E_PROVIDER_ALREADY_REGISTERED, WBEM_E_PROVIDER_NOT_REGISTERED, WBEM_E_FATAL_TRANSPORT_ERROR, WBEM_E_ENCRYPTED_CONNECTION_REQUIRED, WBEM_E_PROVIDER_TIMED_OUT, WBEM_E_NO_KEY, WBEM_E_PROVIDER_DISABLED, WBEMESS_E_REGISTRATION_TOO_BROAD, WBEMESS_E_REGISTRATION_TOO_PRECISE, WBEMESS_E_AUTHZ_NOT_PRIVILEGED, WBEMMOF_E_EXPECTED_QUALIFIER_NAME, WBEMMOF_E_EXPECTED_SEMI, WBEMMOF_E_EXPECTED_OPEN_BRACE, WBEMMOF_E_EXPECTED_CLOSE_BRACE, WBEMMOF_E_EXPECTED_CLOSE_BRACKET, WBEMMOF_E_EXPECTED_CLOSE_PAREN, WBEMMOF_E_ILLEGAL_CONSTANT_VALUE, WBEMMOF_E_EXPECTED_TYPE_IDENTIFIER, WBEMMOF_E_EXPECTED_OPEN_PAREN, WBEMMOF_E_UNRECOGNIZED_TOKEN, WBEMMOF_E_UNRECOGNIZED_TYPE, WBEMMOF_E_EXPECTED_PROPERTY_NAME, WBEMMOF_E_TYPEDEF_NOT_SUPPORTED, WBEMMOF_E_UNEXPECTED_ALIAS, WBEMMOF_E_UNEXPECTED_ARRAY_INIT, WBEMMOF_E_INVALID_AMENDMENT_SYNTAX, WBEMMOF_E_INVALID_DUPLICATE_AMENDMENT, WBEMMOF_E_INVALID_PRAGMA, WBEMMOF_E_INVALID_NAMESPACE_SYNTAX, WBEMMOF_E_EXPECTED_CLASS_NAME, WBEMMOF_E_TYPE_MISMATCH, WBEMMOF_E_EXPECTED_ALIAS_NAME, WBEMMOF_E_INVALID_CLASS_DECLARATION, WBEMMOF_E_INVALID_INSTANCE_DECLARATION, WBEMMOF_E_EXPECTED_DOLLAR, WBEMMOF_E_CIMTYPE_QUALIFIER, WBEMMOF_E_DUPLICATE_PROPERTY, WBEMMOF_E_INVALID_NAMESPACE_SPECIFICATION, WBEMMOF_E_OUT_OF_RANGE, WBEMMOF_E_INVALID_FILE, WBEMMOF_E_ALIASES_IN_EMBEDDED, WBEMMOF_E_NULL_ARRAY_ELEM, WBEMMOF_E_DUPLICATE_QUALIFIER, WBEMMOF_E_EXPECTED_FLAVOR_TYPE, WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES, WBEMMOF_E_MULTIPLE_ALIASES, WBEMMOF_E_INCOMPATIBLE_FLAVOR_TYPES2, WBEMMOF_E_NO_ARRAYS_RETURNED, WBEMMOF_E_MUST_BE_IN_OR_OUT, WBEMMOF_E_INVALID_FLAGS_SYNTAX, WBEMMOF_E_EXPECTED_BRACE_OR_BAD_TYPE, WBEMMOF_E_UNSUPPORTED_CIMV22_QUAL_VALUE, WBEMMOF_E_UNSUPPORTED_CIMV22_DATA_TYPE, WBEMMOF_E_INVALID_DELETEINSTANCE_SYNTAX, WBEMMOF_E_INVALID_QUALIFIER_SYNTAX, WBEMMOF_E_QUALIFIER_USED_OUTSIDE_SCOPE, WBEMMOF_E_ERROR_CREATING_TEMP_FILE, WBEMMOF_E_ERROR_INVALID_INCLUDE_FILE, WBEMMOF_E_INVALID_DELETECLASS_SYNTAX] + mapper = FlagMapper(*values) +WBEMSTATUS = tag_WBEMSTATUS + + +WBEM_NO_WAIT = EnumValue("tag_WBEM_TIMEOUT_TYPE", "WBEM_NO_WAIT", 0x0) +WBEM_INFINITE = EnumValue("tag_WBEM_TIMEOUT_TYPE", "WBEM_INFINITE", 0xffffffff) +class tag_WBEM_TIMEOUT_TYPE(EnumType): + values = [WBEM_NO_WAIT, WBEM_INFINITE] + mapper = FlagMapper(*values) +WBEM_TIMEOUT_TYPE = tag_WBEM_TIMEOUT_TYPE + + +WBEM_FLAG_RETURN_IMMEDIATELY = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_RETURN_IMMEDIATELY", 0x10) +WBEM_FLAG_RETURN_WBEM_COMPLETE = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_RETURN_WBEM_COMPLETE", 0x0) +WBEM_FLAG_BIDIRECTIONAL = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_BIDIRECTIONAL", 0x0) +WBEM_FLAG_FORWARD_ONLY = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_FORWARD_ONLY", 0x20) +WBEM_FLAG_NO_ERROR_OBJECT = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_NO_ERROR_OBJECT", 0x40) +WBEM_FLAG_RETURN_ERROR_OBJECT = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_RETURN_ERROR_OBJECT", 0x0) +WBEM_FLAG_SEND_STATUS = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_SEND_STATUS", 0x80) +WBEM_FLAG_DONT_SEND_STATUS = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_DONT_SEND_STATUS", 0x0) +WBEM_FLAG_ENSURE_LOCATABLE = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_ENSURE_LOCATABLE", 0x100) +WBEM_FLAG_DIRECT_READ = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_DIRECT_READ", 0x200) +WBEM_FLAG_SEND_ONLY_SELECTED = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_SEND_ONLY_SELECTED", 0x0) +WBEM_RETURN_WHEN_COMPLETE = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_RETURN_WHEN_COMPLETE", 0x0) +WBEM_RETURN_IMMEDIATELY = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_RETURN_IMMEDIATELY", 0x10) +WBEM_MASK_RESERVED_FLAGS = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_MASK_RESERVED_FLAGS", 0x1f000) +WBEM_FLAG_USE_AMENDED_QUALIFIERS = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_USE_AMENDED_QUALIFIERS", 0x20000) +WBEM_FLAG_STRONG_VALIDATION = EnumValue("tag_WBEM_GENERIC_FLAG_TYPE", "WBEM_FLAG_STRONG_VALIDATION", 0x100000) +class tag_WBEM_GENERIC_FLAG_TYPE(EnumType): + values = [WBEM_FLAG_RETURN_IMMEDIATELY, WBEM_FLAG_RETURN_WBEM_COMPLETE, WBEM_FLAG_BIDIRECTIONAL, WBEM_FLAG_FORWARD_ONLY, WBEM_FLAG_NO_ERROR_OBJECT, WBEM_FLAG_RETURN_ERROR_OBJECT, WBEM_FLAG_SEND_STATUS, WBEM_FLAG_DONT_SEND_STATUS, WBEM_FLAG_ENSURE_LOCATABLE, WBEM_FLAG_DIRECT_READ, WBEM_FLAG_SEND_ONLY_SELECTED, WBEM_RETURN_WHEN_COMPLETE, WBEM_RETURN_IMMEDIATELY, WBEM_MASK_RESERVED_FLAGS, WBEM_FLAG_USE_AMENDED_QUALIFIERS, WBEM_FLAG_STRONG_VALIDATION] + mapper = FlagMapper(*values) +WBEM_GENERIC_FLAG_TYPE = tag_WBEM_GENERIC_FLAG_TYPE + + +WBEM_FLAG_CONNECT_REPOSITORY_ONLY = EnumValue("tag_WBEM_CONNECT_OPTIONS", "WBEM_FLAG_CONNECT_REPOSITORY_ONLY", 0x40) +WBEM_FLAG_CONNECT_USE_MAX_WAIT = EnumValue("tag_WBEM_CONNECT_OPTIONS", "WBEM_FLAG_CONNECT_USE_MAX_WAIT", 0x80) +WBEM_FLAG_CONNECT_PROVIDERS = EnumValue("tag_WBEM_CONNECT_OPTIONS", "WBEM_FLAG_CONNECT_PROVIDERS", 0x100) +class tag_WBEM_CONNECT_OPTIONS(EnumType): + values = [WBEM_FLAG_CONNECT_REPOSITORY_ONLY, WBEM_FLAG_CONNECT_USE_MAX_WAIT, WBEM_FLAG_CONNECT_PROVIDERS] + mapper = FlagMapper(*values) +WBEM_CONNECT_OPTIONS = tag_WBEM_CONNECT_OPTIONS + + +WBEM_FLAG_DEEP = EnumValue("tag_WBEM_QUERY_FLAG_TYPE", "WBEM_FLAG_DEEP", 0x0) +WBEM_FLAG_SHALLOW = EnumValue("tag_WBEM_QUERY_FLAG_TYPE", "WBEM_FLAG_SHALLOW", 0x1) +WBEM_FLAG_PROTOTYPE = EnumValue("tag_WBEM_QUERY_FLAG_TYPE", "WBEM_FLAG_PROTOTYPE", 0x2) +class tag_WBEM_QUERY_FLAG_TYPE(EnumType): + values = [WBEM_FLAG_DEEP, WBEM_FLAG_SHALLOW, WBEM_FLAG_PROTOTYPE] + mapper = FlagMapper(*values) +WBEM_QUERY_FLAG_TYPE = tag_WBEM_QUERY_FLAG_TYPE + + +class _TRACE_PROVIDER_INFO(Structure): + _fields_ = [ + ("ProviderGuid", GUID), + ("SchemaSource", ULONG), + ("ProviderNameOffset", ULONG), + ] +TRACE_PROVIDER_INFO = _TRACE_PROVIDER_INFO + +class _PROVIDER_ENUMERATION_INFO(Structure): + _fields_ = [ + ("NumberOfProviders", ULONG), + ("Reserved", ULONG), + ("TraceProviderInfoArray", TRACE_PROVIDER_INFO * ANYSIZE_ARRAY), + ] +PPROVIDER_ENUMERATION_INFO = POINTER(_PROVIDER_ENUMERATION_INFO) +PROVIDER_ENUMERATION_INFO = _PROVIDER_ENUMERATION_INFO + +KeyValueBasicInformation = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValueBasicInformation", 0x0) +KeyValueFullInformation = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValueFullInformation", 0x1) +KeyValuePartialInformation = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValuePartialInformation", 0x2) +KeyValueFullInformationAlign64 = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValueFullInformationAlign64", 0x3) +KeyValuePartialInformationAlign64 = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValuePartialInformationAlign64", 0x4) +KeyValueLayerInformation = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "KeyValueLayerInformation", 0x5) +MaxKeyValueInfoClass = EnumValue("_KEY_VALUE_INFORMATION_CLASS", "MaxKeyValueInfoClass", 0x6) +class _KEY_VALUE_INFORMATION_CLASS(EnumType): + values = [KeyValueBasicInformation, KeyValueFullInformation, KeyValuePartialInformation, KeyValueFullInformationAlign64, KeyValuePartialInformationAlign64, KeyValueLayerInformation, MaxKeyValueInfoClass] + mapper = FlagMapper(*values) +KEY_VALUE_INFORMATION_CLASS = _KEY_VALUE_INFORMATION_CLASS + + +KeyBasicInformation = EnumValue("_KEY_INFORMATION_CLASS", "KeyBasicInformation", 0x0) +KeyNodeInformation = EnumValue("_KEY_INFORMATION_CLASS", "KeyNodeInformation", 0x1) +KeyFullInformation = EnumValue("_KEY_INFORMATION_CLASS", "KeyFullInformation", 0x2) +KeyNameInformation = EnumValue("_KEY_INFORMATION_CLASS", "KeyNameInformation", 0x3) +KeyCachedInformation = EnumValue("_KEY_INFORMATION_CLASS", "KeyCachedInformation", 0x4) +KeyFlagsInformation = EnumValue("_KEY_INFORMATION_CLASS", "KeyFlagsInformation", 0x5) +KeyVirtualizationInformation = EnumValue("_KEY_INFORMATION_CLASS", "KeyVirtualizationInformation", 0x6) +KeyHandleTagsInformation = EnumValue("_KEY_INFORMATION_CLASS", "KeyHandleTagsInformation", 0x7) +KeyTrustInformation = EnumValue("_KEY_INFORMATION_CLASS", "KeyTrustInformation", 0x8) +KeyLayerInformation = EnumValue("_KEY_INFORMATION_CLASS", "KeyLayerInformation", 0x9) +MaxKeyInfoClass = EnumValue("_KEY_INFORMATION_CLASS", "MaxKeyInfoClass", 0xa) +class _KEY_INFORMATION_CLASS(EnumType): + values = [KeyBasicInformation, KeyNodeInformation, KeyFullInformation, KeyNameInformation, KeyCachedInformation, KeyFlagsInformation, KeyVirtualizationInformation, KeyHandleTagsInformation, KeyTrustInformation, KeyLayerInformation, MaxKeyInfoClass] + mapper = FlagMapper(*values) +KEY_INFORMATION_CLASS = _KEY_INFORMATION_CLASS + + +class _KEY_VALUE_BASIC_INFORMATION(Structure): + _fields_ = [ + ("TitleIndex", ULONG), + ("Type", ULONG), + ("NameLength", ULONG), + ("Name", WCHAR * 1), + ] +PKEY_VALUE_BASIC_INFORMATION = POINTER(_KEY_VALUE_BASIC_INFORMATION) +KEY_VALUE_BASIC_INFORMATION = _KEY_VALUE_BASIC_INFORMATION + +class _KEY_VALUE_FULL_INFORMATION(Structure): + _fields_ = [ + ("TitleIndex", ULONG), + ("Type", ULONG), + ("DataOffset", ULONG), + ("DataLength", ULONG), + ("NameLength", ULONG), + ("Name", WCHAR * 1), + ] +KEY_VALUE_FULL_INFORMATION = _KEY_VALUE_FULL_INFORMATION +PKEY_VALUE_FULL_INFORMATION = POINTER(_KEY_VALUE_FULL_INFORMATION) + +class _KEY_VALUE_PARTIAL_INFORMATION(Structure): + _fields_ = [ + ("TitleIndex", ULONG), + ("Type", ULONG), + ("DataLength", ULONG), + ("Data", UCHAR * 1), + ] +PKEY_VALUE_PARTIAL_INFORMATION = POINTER(_KEY_VALUE_PARTIAL_INFORMATION) +KEY_VALUE_PARTIAL_INFORMATION = _KEY_VALUE_PARTIAL_INFORMATION + VAR_PERINSTANCE = EnumValue("tagVARKIND", "VAR_PERINSTANCE", 0x0) VAR_STATIC = EnumValue("tagVARKIND", "VAR_STATIC", 0x1) VAR_CONST = EnumValue("tagVARKIND", "VAR_CONST", 0x2) @@ -7346,3 +7533,1318 @@ class tagTYPEATTR(Structure): TYPEATTR = tagTYPEATTR LPTYPEATTR = POINTER(tagTYPEATTR) +ProcessDEPPolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessDEPPolicy", 0x0) +ProcessASLRPolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessASLRPolicy", 0x1) +ProcessDynamicCodePolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessDynamicCodePolicy", 0x2) +ProcessStrictHandleCheckPolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessStrictHandleCheckPolicy", 0x3) +ProcessSystemCallDisablePolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessSystemCallDisablePolicy", 0x4) +ProcessMitigationOptionsMask = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessMitigationOptionsMask", 0x5) +ProcessExtensionPointDisablePolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessExtensionPointDisablePolicy", 0x6) +ProcessReserved1Policy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessReserved1Policy", 0x7) +ProcessSignaturePolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "ProcessSignaturePolicy", 0x8) +MaxProcessMitigationPolicy = EnumValue("_PROCESS_MITIGATION_POLICY", "MaxProcessMitigationPolicy", 0x9) +class _PROCESS_MITIGATION_POLICY(EnumType): + values = [ProcessDEPPolicy, ProcessASLRPolicy, ProcessDynamicCodePolicy, ProcessStrictHandleCheckPolicy, ProcessSystemCallDisablePolicy, ProcessMitigationOptionsMask, ProcessExtensionPointDisablePolicy, ProcessReserved1Policy, ProcessSignaturePolicy, MaxProcessMitigationPolicy] + mapper = FlagMapper(*values) +PROCESS_MITIGATION_POLICY = _PROCESS_MITIGATION_POLICY +PPROCESS_MITIGATION_POLICY = POINTER(_PROCESS_MITIGATION_POLICY) + + +class _ANON__ANON__PROCESS_MITIGATION_DEP_POLICY_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("Enable", DWORD, 1), + ("DisableAtlThunkEmulation", DWORD, 1), + ("ReservedFlags", DWORD, 30), + ] + +class _ANON__PROCESS_MITIGATION_DEP_POLICY_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Flags", DWORD), + ("anon_01", _ANON__ANON__PROCESS_MITIGATION_DEP_POLICY_SUB_UNION_1_SUB_STRUCTURE_1), + ] + +class _PROCESS_MITIGATION_DEP_POLICY(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__PROCESS_MITIGATION_DEP_POLICY_SUB_UNION_1), + ("Permanent", BOOLEAN), + ] +PPROCESS_MITIGATION_DEP_POLICY = POINTER(_PROCESS_MITIGATION_DEP_POLICY) +PROCESS_MITIGATION_DEP_POLICY = _PROCESS_MITIGATION_DEP_POLICY + +class _ANON__ANON__PROCESS_MITIGATION_ASLR_POLICY_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("EnableBottomUpRandomization", DWORD, 1), + ("EnableForceRelocateImages", DWORD, 1), + ("EnableHighEntropy", DWORD, 1), + ("DisallowStrippedImages", DWORD, 1), + ("ReservedFlags", DWORD, 28), + ] + +class _ANON__PROCESS_MITIGATION_ASLR_POLICY_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Flags", DWORD), + ("anon_01", _ANON__ANON__PROCESS_MITIGATION_ASLR_POLICY_SUB_UNION_1_SUB_STRUCTURE_1), + ] + +class _PROCESS_MITIGATION_ASLR_POLICY(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__PROCESS_MITIGATION_ASLR_POLICY_SUB_UNION_1), + ] +PPROCESS_MITIGATION_ASLR_POLICY = POINTER(_PROCESS_MITIGATION_ASLR_POLICY) +PROCESS_MITIGATION_ASLR_POLICY = _PROCESS_MITIGATION_ASLR_POLICY + +class _ANON__ANON__PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("ProhibitDynamicCode", DWORD, 1), + ("AllowThreadOptOut", DWORD, 1), + ("AllowRemoteDowngrade", DWORD, 1), + ("AuditProhibitDynamicCode", DWORD, 1), + ("ReservedFlags", DWORD, 28), + ] + +class _ANON__PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Flags", DWORD), + ("anon_01", _ANON__ANON__PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_SUB_UNION_1_SUB_STRUCTURE_1), + ] + +class _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__PROCESS_MITIGATION_DYNAMIC_CODE_POLICY_SUB_UNION_1), + ] +PROCESS_MITIGATION_DYNAMIC_CODE_POLICY = _PROCESS_MITIGATION_DYNAMIC_CODE_POLICY +PPROCESS_MITIGATION_DYNAMIC_CODE_POLICY = POINTER(_PROCESS_MITIGATION_DYNAMIC_CODE_POLICY) + +class _ANON__ANON__PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("RaiseExceptionOnInvalidHandleReference", DWORD, 1), + ("HandleExceptionsPermanentlyEnabled", DWORD, 1), + ("ReservedFlags", DWORD, 30), + ] + +class _ANON__PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Flags", DWORD), + ("anon_01", _ANON__ANON__PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_SUB_UNION_1_SUB_STRUCTURE_1), + ] + +class _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY_SUB_UNION_1), + ] +PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY = _PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY +PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY = POINTER(_PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY) + +class _ANON__ANON__PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("DisallowWin32kSystemCalls", DWORD, 1), + ("AuditDisallowWin32kSystemCalls", DWORD, 1), + ("ReservedFlags", DWORD, 30), + ] + +class _ANON__PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Flags", DWORD), + ("anon_01", _ANON__ANON__PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_SUB_UNION_1_SUB_STRUCTURE_1), + ] + +class _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY_SUB_UNION_1), + ] +PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY = POINTER(_PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY) +PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY = _PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY + +class _ANON__ANON__PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("DisableExtensionPoints", DWORD, 1), + ("ReservedFlags", DWORD, 31), + ] + +class _ANON__PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Flags", DWORD), + ("anon_01", _ANON__ANON__PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_SUB_UNION_1_SUB_STRUCTURE_1), + ] + +class _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY_SUB_UNION_1), + ] +PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY = _PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY +PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY = POINTER(_PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY) + +class _ANON__ANON__PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("EnableControlFlowGuard", DWORD, 1), + ("EnableExportSuppression", DWORD, 1), + ("StrictMode", DWORD, 1), + ("ReservedFlags", DWORD, 29), + ] + +class _ANON__PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Flags", DWORD), + ("anon_01", _ANON__ANON__PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_SUB_UNION_1_SUB_STRUCTURE_1), + ] + +class _PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY_SUB_UNION_1), + ] +PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY = POINTER(_PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY) +PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY = _PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY + +class _ANON__ANON__PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("MicrosoftSignedOnly", DWORD, 1), + ("StoreSignedOnly", DWORD, 1), + ("MitigationOptIn", DWORD, 1), + ("AuditMicrosoftSignedOnly", DWORD, 1), + ("AuditStoreSignedOnly", DWORD, 1), + ("ReservedFlags", DWORD, 27), + ] + +class _ANON__PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Flags", DWORD), + ("anon_01", _ANON__ANON__PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_SUB_UNION_1_SUB_STRUCTURE_1), + ] + +class _PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY_SUB_UNION_1), + ] +PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY = POINTER(_PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY) +PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY = _PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY + +class _ANON__ANON__PROCESS_MITIGATION_IMAGE_LOAD_POLICY_SUB_UNION_1_SUB_STRUCTURE_1(Structure): + _fields_ = [ + ("NoRemoteImages", DWORD, 1), + ("NoLowMandatoryLabelImages", DWORD, 1), + ("PreferSystem32Images", DWORD, 1), + ("AuditNoRemoteImages", DWORD, 1), + ("AuditNoLowMandatoryLabelImages", DWORD, 1), + ("ReservedFlags", DWORD, 27), + ] + +class _ANON__PROCESS_MITIGATION_IMAGE_LOAD_POLICY_SUB_UNION_1(Union): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("Flags", DWORD), + ("anon_01", _ANON__ANON__PROCESS_MITIGATION_IMAGE_LOAD_POLICY_SUB_UNION_1_SUB_STRUCTURE_1), + ] + +class _PROCESS_MITIGATION_IMAGE_LOAD_POLICY(Structure): + _anonymous_ = ("anon_01",) + _fields_ = [ + ("anon_01", _ANON__PROCESS_MITIGATION_IMAGE_LOAD_POLICY_SUB_UNION_1), + ] +PPROCESS_MITIGATION_IMAGE_LOAD_POLICY = POINTER(_PROCESS_MITIGATION_IMAGE_LOAD_POLICY) +PROCESS_MITIGATION_IMAGE_LOAD_POLICY = _PROCESS_MITIGATION_IMAGE_LOAD_POLICY + +BG_AUTH_SCHEME_BASIC = EnumValue("__MIDL_IBackgroundCopyJob2_0002", "BG_AUTH_SCHEME_BASIC", 0x0) +BG_AUTH_SCHEME_DIGEST = EnumValue("__MIDL_IBackgroundCopyJob2_0002", "BG_AUTH_SCHEME_DIGEST", 0x1) +BG_AUTH_SCHEME_NTLM = EnumValue("__MIDL_IBackgroundCopyJob2_0002", "BG_AUTH_SCHEME_NTLM", 0x2) +BG_AUTH_SCHEME_NEGOTIATE = EnumValue("__MIDL_IBackgroundCopyJob2_0002", "BG_AUTH_SCHEME_NEGOTIATE", 0x3) +BG_AUTH_SCHEME_PASSPORT = EnumValue("__MIDL_IBackgroundCopyJob2_0002", "BG_AUTH_SCHEME_PASSPORT", 0x4) +class __MIDL_IBackgroundCopyJob2_0002(EnumType): + values = [BG_AUTH_SCHEME_BASIC, BG_AUTH_SCHEME_DIGEST, BG_AUTH_SCHEME_NTLM, BG_AUTH_SCHEME_NEGOTIATE, BG_AUTH_SCHEME_PASSPORT] + mapper = FlagMapper(*values) +BG_AUTH_SCHEME = __MIDL_IBackgroundCopyJob2_0002 + + +BG_AUTH_TARGET_SERVER = EnumValue("__MIDL_IBackgroundCopyJob2_0001", "BG_AUTH_TARGET_SERVER", 0x0) +BG_AUTH_TARGET_PROXY = EnumValue("__MIDL_IBackgroundCopyJob2_0001", "BG_AUTH_TARGET_PROXY", 0x1) +class __MIDL_IBackgroundCopyJob2_0001(EnumType): + values = [BG_AUTH_TARGET_SERVER, BG_AUTH_TARGET_PROXY] + mapper = FlagMapper(*values) +BG_AUTH_TARGET = __MIDL_IBackgroundCopyJob2_0001 + + +class __MIDL_IBackgroundCopyJob2_0003(Structure): + _fields_ = [ + ("UserName", LPWSTR), + ("Password", LPWSTR), + ] +BG_BASIC_CREDENTIALS = __MIDL_IBackgroundCopyJob2_0003 + +class __MIDL_IBackgroundCopyJob2_0004(Union): + _fields_ = [ + ("Basic", BG_BASIC_CREDENTIALS), + ] +BG_AUTH_CREDENTIALS_UNION = __MIDL_IBackgroundCopyJob2_0004 + +class BG_AUTH_CREDENTIALS(Structure): + _fields_ = [ + ("Target", BG_AUTH_TARGET), + ("Scheme", BG_AUTH_SCHEME), + ("Credentials", BG_AUTH_CREDENTIALS_UNION), + ] + + +class _BG_JOB_REPLY_PROGRESS(Structure): + _fields_ = [ + ("BytesTotal", UINT64), + ("BytesTransferred", UINT64), + ] +BG_JOB_REPLY_PROGRESS = _BG_JOB_REPLY_PROGRESS + +class _BG_FILE_RANGE(Structure): + _fields_ = [ + ("InitialOffset", UINT64), + ("Length", UINT64), + ] +BG_FILE_RANGE = _BG_FILE_RANGE + +class _SHITEMID(Structure): + _fields_ = [ + ("cb", USHORT), + ("abID", BYTE * 1), + ] +SHITEMID = _SHITEMID + +class _ITEMIDLIST(Structure): + _fields_ = [ + ("mkid", SHITEMID), + ] +ITEMIDLIST = _ITEMIDLIST +PCIDLIST_ABSOLUTE = POINTER(_ITEMIDLIST) +PIDLIST_ABSOLUTE = POINTER(_ITEMIDLIST) + +class tagRGBTRIPLE(Structure): + _fields_ = [ + ("rgbtBlue", BYTE), + ("rgbtGreen", BYTE), + ("rgbtRed", BYTE), + ] +NPRGBTRIPLE = POINTER(tagRGBTRIPLE) +LPRGBTRIPLE = POINTER(tagRGBTRIPLE) +RGBTRIPLE = tagRGBTRIPLE +PRGBTRIPLE = POINTER(tagRGBTRIPLE) + +class tagBITMAPFILEHEADER(Structure): + _pack_ = 2 + _fields_ = [ + ("bfType", WORD), + ("bfSize", DWORD), + ("bfReserved1", WORD), + ("bfReserved2", WORD), + ("bfOffBits", DWORD), + ] +BITMAPFILEHEADER = tagBITMAPFILEHEADER +PBITMAPFILEHEADER = POINTER(tagBITMAPFILEHEADER) +LPBITMAPFILEHEADER = POINTER(tagBITMAPFILEHEADER) + +class tagBITMAPCOREHEADER(Structure): + _fields_ = [ + ("bcSize", DWORD), + ("bcWidth", WORD), + ("bcHeight", WORD), + ("bcPlanes", WORD), + ("bcBitCount", WORD), + ] +LPBITMAPCOREHEADER = POINTER(tagBITMAPCOREHEADER) +PBITMAPCOREHEADER = POINTER(tagBITMAPCOREHEADER) +BITMAPCOREHEADER = tagBITMAPCOREHEADER + +class tagBITMAP(Structure): + _fields_ = [ + ("bmType", LONG), + ("bmWidth", LONG), + ("bmHeight", LONG), + ("bmWidthBytes", LONG), + ("bmPlanes", WORD), + ("bmBitsPixel", WORD), + ("bmBits", LPVOID), + ] +NPBITMAP = POINTER(tagBITMAP) +LPBITMAP = POINTER(tagBITMAP) +PBITMAP = POINTER(tagBITMAP) +BITMAP = tagBITMAP + +class tagBITMAPINFOHEADER(Structure): + _fields_ = [ + ("biSize", DWORD), + ("biWidth", LONG), + ("biHeight", LONG), + ("biPlanes", WORD), + ("biBitCount", WORD), + ("biCompression", DWORD), + ("biSizeImage", DWORD), + ("biXPelsPerMeter", LONG), + ("biYPelsPerMeter", LONG), + ("biClrUsed", DWORD), + ("biClrImportant", DWORD), + ] +BITMAPINFOHEADER = tagBITMAPINFOHEADER +PBITMAPINFOHEADER = POINTER(tagBITMAPINFOHEADER) +LPBITMAPINFOHEADER = POINTER(tagBITMAPINFOHEADER) + +class tagRGBQUAD(Structure): + _fields_ = [ + ("rgbBlue", BYTE), + ("rgbGreen", BYTE), + ("rgbRed", BYTE), + ("rgbReserved", BYTE), + ] +RGBQUAD = tagRGBQUAD + +class tagBITMAPINFO(Structure): + _fields_ = [ + ("bmiHeader", BITMAPINFOHEADER), + ("bmiColors", RGBQUAD * 1), + ] +LPBITMAPINFO = POINTER(tagBITMAPINFO) +PBITMAPINFO = POINTER(tagBITMAPINFO) +BITMAPINFO = tagBITMAPINFO + +class tagBITMAPCOREINFO(Structure): + _fields_ = [ + ("bmciHeader", BITMAPCOREHEADER), + ("bmciColors", RGBTRIPLE * 1), + ] +LPBITMAPCOREINFO = POINTER(tagBITMAPCOREINFO) +BITMAPCOREINFO = tagBITMAPCOREINFO +PBITMAPCOREINFO = POINTER(tagBITMAPCOREINFO) + +class tagWNDCLASSEXA(Structure): + _fields_ = [ + ("cbSize", UINT), + ("style", UINT), + ("lpfnWndProc", WNDPROC), + ("cbClsExtra", INT), + ("cbWndExtra", INT), + ("hInstance", HINSTANCE), + ("hIcon", HICON), + ("hCursor", HCURSOR), + ("hbrBackground", HBRUSH), + ("lpszMenuName", LPCSTR), + ("lpszClassName", LPCSTR), + ("hIconSm", HICON), + ] +PWNDCLASSEXA = POINTER(tagWNDCLASSEXA) +LPWNDCLASSEXA = POINTER(tagWNDCLASSEXA) +WNDCLASSEXA = tagWNDCLASSEXA + +class tagWNDCLASSEXW(Structure): + _fields_ = [ + ("cbSize", UINT), + ("style", UINT), + ("lpfnWndProc", WNDPROC), + ("cbClsExtra", INT), + ("cbWndExtra", INT), + ("hInstance", HINSTANCE), + ("hIcon", HICON), + ("hCursor", HCURSOR), + ("hbrBackground", HBRUSH), + ("lpszMenuName", LPWSTR), + ("lpszClassName", LPWSTR), + ("hIconSm", HICON), + ] +WNDCLASSEXW = tagWNDCLASSEXW +LPWNDCLASSEXW = POINTER(tagWNDCLASSEXW) +PWNDCLASSEXW = POINTER(tagWNDCLASSEXW) + +TCP_TABLE_BASIC_LISTENER = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_BASIC_LISTENER", 0x0) +TCP_TABLE_BASIC_CONNECTIONS = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_BASIC_CONNECTIONS", 0x1) +TCP_TABLE_BASIC_ALL = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_BASIC_ALL", 0x2) +TCP_TABLE_OWNER_PID_LISTENER = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_PID_LISTENER", 0x3) +TCP_TABLE_OWNER_PID_CONNECTIONS = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_PID_CONNECTIONS", 0x4) +TCP_TABLE_OWNER_PID_ALL = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_PID_ALL", 0x5) +TCP_TABLE_OWNER_MODULE_LISTENER = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_MODULE_LISTENER", 0x6) +TCP_TABLE_OWNER_MODULE_CONNECTIONS = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_MODULE_CONNECTIONS", 0x7) +TCP_TABLE_OWNER_MODULE_ALL = EnumValue("_TCP_TABLE_CLASS", "TCP_TABLE_OWNER_MODULE_ALL", 0x8) +class _TCP_TABLE_CLASS(EnumType): + values = [TCP_TABLE_BASIC_LISTENER, TCP_TABLE_BASIC_CONNECTIONS, TCP_TABLE_BASIC_ALL, TCP_TABLE_OWNER_PID_LISTENER, TCP_TABLE_OWNER_PID_CONNECTIONS, TCP_TABLE_OWNER_PID_ALL, TCP_TABLE_OWNER_MODULE_LISTENER, TCP_TABLE_OWNER_MODULE_CONNECTIONS, TCP_TABLE_OWNER_MODULE_ALL] + mapper = FlagMapper(*values) +TCP_TABLE_CLASS = _TCP_TABLE_CLASS + + +MIB_TCP_STATE_CLOSED = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_CLOSED", 0x1) +MIB_TCP_STATE_LISTEN = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_LISTEN", 0x2) +MIB_TCP_STATE_SYN_SENT = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_SYN_SENT", 0x3) +MIB_TCP_STATE_SYN_RCVD = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_SYN_RCVD", 0x4) +MIB_TCP_STATE_ESTAB = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_ESTAB", 0x5) +MIB_TCP_STATE_FIN_WAIT1 = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_FIN_WAIT1", 0x6) +MIB_TCP_STATE_FIN_WAIT2 = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_FIN_WAIT2", 0x7) +MIB_TCP_STATE_CLOSE_WAIT = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_CLOSE_WAIT", 0x8) +MIB_TCP_STATE_CLOSING = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_CLOSING", 0x9) +MIB_TCP_STATE_LAST_ACK = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_LAST_ACK", 0xa) +MIB_TCP_STATE_TIME_WAIT = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_TIME_WAIT", 0xb) +MIB_TCP_STATE_DELETE_TCB = EnumValue("_MIB_TCP_STATE", "MIB_TCP_STATE_DELETE_TCB", 0xc) +class _MIB_TCP_STATE(EnumType): + values = [MIB_TCP_STATE_CLOSED, MIB_TCP_STATE_LISTEN, MIB_TCP_STATE_SYN_SENT, MIB_TCP_STATE_SYN_RCVD, MIB_TCP_STATE_ESTAB, MIB_TCP_STATE_FIN_WAIT1, MIB_TCP_STATE_FIN_WAIT2, MIB_TCP_STATE_CLOSE_WAIT, MIB_TCP_STATE_CLOSING, MIB_TCP_STATE_LAST_ACK, MIB_TCP_STATE_TIME_WAIT, MIB_TCP_STATE_DELETE_TCB] + mapper = FlagMapper(*values) +MIB_TCP_STATE = _MIB_TCP_STATE + + +NET_FW_IP_PROTOCOL_TCP = EnumValue("NET_FW_IP_PROTOCOL_", "NET_FW_IP_PROTOCOL_TCP", 0x6) +NET_FW_IP_PROTOCOL_UDP = EnumValue("NET_FW_IP_PROTOCOL_", "NET_FW_IP_PROTOCOL_UDP", 0x11) +NET_FW_IP_PROTOCOL_ANY = EnumValue("NET_FW_IP_PROTOCOL_", "NET_FW_IP_PROTOCOL_ANY", 0x100) +class NET_FW_IP_PROTOCOL_(EnumType): + values = [NET_FW_IP_PROTOCOL_TCP, NET_FW_IP_PROTOCOL_UDP, NET_FW_IP_PROTOCOL_ANY] + mapper = FlagMapper(*values) +NET_FW_IP_PROTOCOL = NET_FW_IP_PROTOCOL_ + + +IF_OPER_STATUS_NON_OPERATIONAL = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_NON_OPERATIONAL", 0x0) +IF_OPER_STATUS_UNREACHABLE = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_UNREACHABLE", 0x1) +IF_OPER_STATUS_DISCONNECTED = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_DISCONNECTED", 0x2) +IF_OPER_STATUS_CONNECTING = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_CONNECTING", 0x3) +IF_OPER_STATUS_CONNECTED = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_CONNECTED", 0x4) +IF_OPER_STATUS_OPERATIONAL = EnumValue("_INTERNAL_IF_OPER_STATUS", "IF_OPER_STATUS_OPERATIONAL", 0x5) +class _INTERNAL_IF_OPER_STATUS(EnumType): + values = [IF_OPER_STATUS_NON_OPERATIONAL, IF_OPER_STATUS_UNREACHABLE, IF_OPER_STATUS_DISCONNECTED, IF_OPER_STATUS_CONNECTING, IF_OPER_STATUS_CONNECTED, IF_OPER_STATUS_OPERATIONAL] + mapper = FlagMapper(*values) +INTERNAL_IF_OPER_STATUS = _INTERNAL_IF_OPER_STATUS + + +DnsFreeFlat = EnumValue("DNS_FREE_TYPE", "DnsFreeFlat", 0x0) +DnsFreeRecordList = EnumValue("DNS_FREE_TYPE", "DnsFreeRecordList", 0x1) +DnsFreeParsedMessageFields = EnumValue("DNS_FREE_TYPE", "DnsFreeParsedMessageFields", 0x2) +class DNS_FREE_TYPE(EnumType): + values = [DnsFreeFlat, DnsFreeRecordList, DnsFreeParsedMessageFields] + mapper = FlagMapper(*values) + + +class IP6_ADDRESS(Structure): + _fields_ = [ + ("IP6Qword", ULONGLONG * 2), + ] +PIP6_ADDRESS = POINTER(IP6_ADDRESS) + +class _MIB_IPADDRROW_XP(Structure): + _fields_ = [ + ("dwAddr", DWORD), + ("dwIndex", IF_INDEX), + ("dwMask", DWORD), + ("dwBCastAddr", DWORD), + ("dwReasmSize", DWORD), + ("unused1", USHORT), + ("wType", USHORT), + ] +MIB_IPADDRROW = _MIB_IPADDRROW_XP +PMIB_IPADDRROW_XP = POINTER(_MIB_IPADDRROW_XP) +MIB_IPADDRROW_XP = _MIB_IPADDRROW_XP + +class _MIB_IPADDRTABLE(Structure): + _fields_ = [ + ("dwNumEntries", DWORD), + ("table", MIB_IPADDRROW * ANY_SIZE), + ] +PMIB_IPADDRTABLE = POINTER(_MIB_IPADDRTABLE) +MIB_IPADDRTABLE = _MIB_IPADDRTABLE + +class _MIB_IFROW(Structure): + _fields_ = [ + ("wszName", WCHAR * MAX_INTERFACE_NAME_LEN), + ("dwIndex", IF_INDEX), + ("dwType", IFTYPE), + ("dwMtu", DWORD), + ("dwSpeed", DWORD), + ("dwPhysAddrLen", DWORD), + ("bPhysAddr", BYTE * MAXLEN_PHYSADDR), + ("dwAdminStatus", DWORD), + ("dwOperStatus", INTERNAL_IF_OPER_STATUS), + ("dwLastChange", DWORD), + ("dwInOctets", DWORD), + ("dwInUcastPkts", DWORD), + ("dwInNUcastPkts", DWORD), + ("dwInDiscards", DWORD), + ("dwInErrors", DWORD), + ("dwInUnknownProtos", DWORD), + ("dwOutOctets", DWORD), + ("dwOutUcastPkts", DWORD), + ("dwOutNUcastPkts", DWORD), + ("dwOutDiscards", DWORD), + ("dwOutErrors", DWORD), + ("dwOutQLen", DWORD), + ("dwDescrLen", DWORD), + ("bDescr", UCHAR * MAXLEN_IFDESCR), + ] +PMIB_IFROW = POINTER(_MIB_IFROW) +MIB_IFROW = _MIB_IFROW + +class _MIB_IFTABLE(Structure): + _fields_ = [ + ("dwNumEntries", DWORD), + ("table", MIB_IFROW * ANY_SIZE), + ] +PMIB_IFTABLE = POINTER(_MIB_IFTABLE) +MIB_IFTABLE = _MIB_IFTABLE + +class _MIB_TCPROW_OWNER_PID(Structure): + _fields_ = [ + ("dwState", DWORD), + ("dwLocalAddr", DWORD), + ("dwLocalPort", DWORD), + ("dwRemoteAddr", DWORD), + ("dwRemotePort", DWORD), + ("dwOwningPid", DWORD), + ] +MIB_TCPROW_OWNER_PID = _MIB_TCPROW_OWNER_PID +PMIB_TCPROW_OWNER_PID = POINTER(_MIB_TCPROW_OWNER_PID) + +class _MIB_TCPTABLE_OWNER_PID(Structure): + _fields_ = [ + ("dwNumEntries", DWORD), + ("table", MIB_TCPROW_OWNER_PID * ANY_SIZE), + ] +MIB_TCPTABLE_OWNER_PID = _MIB_TCPTABLE_OWNER_PID +PMIB_TCPTABLE_OWNER_PID = POINTER(_MIB_TCPTABLE_OWNER_PID) + +class _MIB_UDPROW_OWNER_PID(Structure): + _fields_ = [ + ("dwLocalAddr", DWORD), + ("dwLocalPort", DWORD), + ("dwOwningPid", DWORD), + ] +MIB_UDPROW_OWNER_PID = _MIB_UDPROW_OWNER_PID +PMIB_UDPROW_OWNER_PID = POINTER(_MIB_UDPROW_OWNER_PID) + +class _MIB_UDPTABLE_OWNER_PID(Structure): + _fields_ = [ + ("dwNumEntries", DWORD), + ("table", MIB_UDPROW_OWNER_PID * ANY_SIZE), + ] +MIB_UDPTABLE_OWNER_PID = _MIB_UDPTABLE_OWNER_PID +PMIB_UDPTABLE_OWNER_PID = POINTER(_MIB_UDPTABLE_OWNER_PID) + +class _MIB_UDP6ROW_OWNER_PID(Structure): + _fields_ = [ + ("ucLocalAddr", UCHAR * 16), + ("dwLocalScopeId", DWORD), + ("dwLocalPort", DWORD), + ("dwOwningPid", DWORD), + ] +MIB_UDP6ROW_OWNER_PID = _MIB_UDP6ROW_OWNER_PID +PMIB_UDP6ROW_OWNER_PID = POINTER(_MIB_UDP6ROW_OWNER_PID) + +class _MIB_UDP6TABLE_OWNER_PID(Structure): + _fields_ = [ + ("dwNumEntries", DWORD), + ("table", MIB_UDP6ROW_OWNER_PID * ANY_SIZE), + ] +PMIB_UDP6TABLE_OWNER_PID = POINTER(_MIB_UDP6TABLE_OWNER_PID) +MIB_UDP6TABLE_OWNER_PID = _MIB_UDP6TABLE_OWNER_PID + +class _MIB_TCP6ROW_OWNER_PID(Structure): + _fields_ = [ + ("ucLocalAddr", UCHAR * 16), + ("dwLocalScopeId", DWORD), + ("dwLocalPort", DWORD), + ("ucRemoteAddr", UCHAR * 16), + ("dwRemoteScopeId", DWORD), + ("dwRemotePort", DWORD), + ("dwState", DWORD), + ("dwOwningPid", DWORD), + ] +MIB_TCP6ROW_OWNER_PID = _MIB_TCP6ROW_OWNER_PID +PMIB_TCP6ROW_OWNER_PID = POINTER(_MIB_TCP6ROW_OWNER_PID) + +class _MIB_TCP6TABLE_OWNER_PID(Structure): + _fields_ = [ + ("dwNumEntries", DWORD), + ("table", MIB_TCP6ROW_OWNER_PID * ANY_SIZE), + ] +MIB_TCP6TABLE_OWNER_PID = _MIB_TCP6TABLE_OWNER_PID +PMIB_TCP6TABLE_OWNER_PID = POINTER(_MIB_TCP6TABLE_OWNER_PID) + +class _MIB_TCPROW(Structure): + _fields_ = [ + ("dwState", DWORD), + ("dwLocalAddr", DWORD), + ("dwLocalPort", DWORD), + ("dwRemoteAddr", DWORD), + ("dwRemotePort", DWORD), + ] +MIB_TCPROW = _MIB_TCPROW +PMIB_TCPROW = POINTER(_MIB_TCPROW) + +class _IP_ADAPTER_INDEX_MAP(Structure): + _fields_ = [ + ("Index", ULONG), + ("Name", WCHAR * MAX_ADAPTER_NAME), + ] +PIP_ADAPTER_INDEX_MAP = POINTER(_IP_ADAPTER_INDEX_MAP) +IP_ADAPTER_INDEX_MAP = _IP_ADAPTER_INDEX_MAP + +class _IP_INTERFACE_INFO(Structure): + _fields_ = [ + ("NumAdapters", LONG), + ("Adapter", IP_ADAPTER_INDEX_MAP * 1), + ] +PIP_INTERFACE_INFO = POINTER(_IP_INTERFACE_INFO) +IP_INTERFACE_INFO = _IP_INTERFACE_INFO + +# Self referencing struct tricks +class _DNS_CACHE_ENTRY(Structure): pass +PDNS_CACHE_ENTRY = POINTER(_DNS_CACHE_ENTRY) +DNS_CACHE_ENTRY = _DNS_CACHE_ENTRY +_DNS_CACHE_ENTRY._fields_ = [ + ("pNext", POINTER(_DNS_CACHE_ENTRY)), + ("pszName", PCWSTR), + ("wType", USHORT), + ("wDataLength", USHORT), + ("dwFlags", ULONG), +] + +class DNS_A_DATA(Structure): + _fields_ = [ + ("IpAddress", IP4_ADDRESS), + ] +PDNS_A_DATA = POINTER(DNS_A_DATA) + +class DNS_PTR_DATAW(Structure): + _fields_ = [ + ("pNameHost", PWSTR), + ] +PDNS_PTR_DATAW = POINTER(DNS_PTR_DATAW) + +class DNS_PTR_DATAA(Structure): + _fields_ = [ + ("pNameHost", PSTR), + ] +PDNS_PTR_DATAA = POINTER(DNS_PTR_DATAA) + +class DNS_SOA_DATAW(Structure): + _fields_ = [ + ("pNamePrimaryServer", PWSTR), + ("pNameAdministrator", PWSTR), + ("dwSerialNo", DWORD), + ("dwRefresh", DWORD), + ("dwRetry", DWORD), + ("dwExpire", DWORD), + ("dwDefaultTtl", DWORD), + ] +PDNS_SOA_DATAW = POINTER(DNS_SOA_DATAW) + +class DNS_SOA_DATAA(Structure): + _fields_ = [ + ("pNamePrimaryServer", PSTR), + ("pNameAdministrator", PSTR), + ("dwSerialNo", DWORD), + ("dwRefresh", DWORD), + ("dwRetry", DWORD), + ("dwExpire", DWORD), + ("dwDefaultTtl", DWORD), + ] +PDNS_SOA_DATAA = POINTER(DNS_SOA_DATAA) + +class DNS_MINFO_DATAW(Structure): + _fields_ = [ + ("pNameMailbox", PWSTR), + ("pNameErrorsMailbox", PWSTR), + ] +PDNS_MINFO_DATAW = POINTER(DNS_MINFO_DATAW) + +class DNS_MINFO_DATAA(Structure): + _fields_ = [ + ("pNameMailbox", PSTR), + ("pNameErrorsMailbox", PSTR), + ] +PDNS_MINFO_DATAA = POINTER(DNS_MINFO_DATAA) + +class DNS_MX_DATAW(Structure): + _fields_ = [ + ("pNameExchange", PWSTR), + ("wPreference", WORD), + ("Pad", WORD), + ] +PDNS_MX_DATAW = POINTER(DNS_MX_DATAW) + +class DNS_MX_DATAA(Structure): + _fields_ = [ + ("pNameExchange", PSTR), + ("wPreference", WORD), + ("Pad", WORD), + ] +PDNS_MX_DATAA = POINTER(DNS_MX_DATAA) + +class DNS_TXT_DATAW(Structure): + _fields_ = [ + ("dwStringCount", DWORD), + ("pStringArray", PWSTR * 1), + ] +PDNS_TXT_DATAW = POINTER(DNS_TXT_DATAW) + +class DNS_TXT_DATAA(Structure): + _fields_ = [ + ("dwStringCount", DWORD), + ("pStringArray", PSTR * 1), + ] +PDNS_TXT_DATAA = POINTER(DNS_TXT_DATAA) + +class DNS_NULL_DATA(Structure): + _fields_ = [ + ("dwByteCount", DWORD), + ("Data", BYTE * 1), + ] +PDNS_NULL_DATA = POINTER(DNS_NULL_DATA) + +class DNS_WKS_DATA(Structure): + _fields_ = [ + ("IpAddress", IP4_ADDRESS), + ("chProtocol", UCHAR), + ("BitMask", BYTE * 1), + ] +PDNS_WKS_DATA = POINTER(DNS_WKS_DATA) + +class DNS_AAAA_DATA(Structure): + _fields_ = [ + ("Ip6Address", IP6_ADDRESS), + ] +PDNS_AAAA_DATA = POINTER(DNS_AAAA_DATA) + +class DNS_SIG_DATAW(Structure): + _fields_ = [ + ("wTypeCovered", WORD), + ("chAlgorithm", BYTE), + ("chLabelCount", BYTE), + ("dwOriginalTtl", DWORD), + ("dwExpiration", DWORD), + ("dwTimeSigned", DWORD), + ("wKeyTag", WORD), + ("wSignatureLength", WORD), + ("pNameSigner", PWSTR), + ("Signature", BYTE * 1), + ] +DNS_RRSIG_DATAW = DNS_SIG_DATAW +PDNS_RRSIG_DATAW = POINTER(DNS_SIG_DATAW) +PDNS_SIG_DATAW = POINTER(DNS_SIG_DATAW) + +class DNS_SIG_DATAA(Structure): + _fields_ = [ + ("wTypeCovered", WORD), + ("chAlgorithm", BYTE), + ("chLabelCount", BYTE), + ("dwOriginalTtl", DWORD), + ("dwExpiration", DWORD), + ("dwTimeSigned", DWORD), + ("wKeyTag", WORD), + ("wSignatureLength", WORD), + ("pNameSigner", PSTR), + ("Signature", BYTE * 1), + ] +PDNS_SIG_DATAA = POINTER(DNS_SIG_DATAA) +PDNS_RRSIG_DATAA = POINTER(DNS_SIG_DATAA) +DNS_RRSIG_DATAA = DNS_SIG_DATAA + +class DNS_KEY_DATA(Structure): + _fields_ = [ + ("wFlags", WORD), + ("chProtocol", BYTE), + ("chAlgorithm", BYTE), + ("wKeyLength", WORD), + ("wPad", WORD), + ("Key", BYTE * 1), + ] +PDNS_DNSKEY_DATA = POINTER(DNS_KEY_DATA) +PDNS_KEY_DATA = POINTER(DNS_KEY_DATA) +DNS_DNSKEY_DATA = DNS_KEY_DATA + +class DNS_DHCID_DATA(Structure): + _fields_ = [ + ("dwByteCount", DWORD), + ("DHCID", BYTE * 1), + ] +PDNS_DHCID_DATA = POINTER(DNS_DHCID_DATA) + +class DNS_NSEC_DATAW(Structure): + _fields_ = [ + ("pNextDomainName", PWSTR), + ("wTypeBitMapsLength", WORD), + ("wPad", WORD), + ("TypeBitMaps", BYTE * 1), + ] +PDNS_NSEC_DATAW = POINTER(DNS_NSEC_DATAW) + +class DNS_NSEC_DATAA(Structure): + _fields_ = [ + ("pNextDomainName", PSTR), + ("wTypeBitMapsLength", WORD), + ("wPad", WORD), + ("TypeBitMaps", BYTE * 1), + ] +PDNS_NSEC_DATAA = POINTER(DNS_NSEC_DATAA) + +class DNS_NSEC3_DATA(Structure): + _fields_ = [ + ("chAlgorithm", BYTE), + ("bFlags", BYTE), + ("wIterations", WORD), + ("bSaltLength", BYTE), + ("bHashLength", BYTE), + ("wTypeBitMapsLength", WORD), + ("chData", BYTE * 1), + ] +PDNS_NSEC3_DATA = POINTER(DNS_NSEC3_DATA) + +class DNS_NSEC3PARAM_DATA(Structure): + _fields_ = [ + ("chAlgorithm", BYTE), + ("bFlags", BYTE), + ("wIterations", WORD), + ("bSaltLength", BYTE), + ("bPad", BYTE * 3), + ("pbSalt", BYTE * 1), + ] +PDNS_NSEC3PARAM_DATA = POINTER(DNS_NSEC3PARAM_DATA) + +class DNS_DS_DATA(Structure): + _fields_ = [ + ("wKeyTag", WORD), + ("chAlgorithm", BYTE), + ("chDigestType", BYTE), + ("wDigestLength", WORD), + ("wPad", WORD), + ("Digest", BYTE * 1), + ] +PDNS_DS_DATA = POINTER(DNS_DS_DATA) + +class DNS_OPT_DATA(Structure): + _fields_ = [ + ("wDataLength", WORD), + ("wPad", WORD), + ("Data", BYTE * 1), + ] +PDNS_OPT_DATA = POINTER(DNS_OPT_DATA) + +class DNS_LOC_DATA(Structure): + _fields_ = [ + ("wVersion", WORD), + ("wSize", WORD), + ("wHorPrec", WORD), + ("wVerPrec", WORD), + ("dwLatitude", DWORD), + ("dwLongitude", DWORD), + ("dwAltitude", DWORD), + ] +PDNS_LOC_DATA = POINTER(DNS_LOC_DATA) + +class DNS_NXT_DATAW(Structure): + _fields_ = [ + ("pNameNext", PWSTR), + ("wNumTypes", WORD), + ("wTypes", WORD * 1), + ] +PDNS_NXT_DATAW = POINTER(DNS_NXT_DATAW) + +class DNS_NXT_DATAA(Structure): + _fields_ = [ + ("pNameNext", PSTR), + ("wNumTypes", WORD), + ("wTypes", WORD * 1), + ] +PDNS_NXT_DATAA = POINTER(DNS_NXT_DATAA) + +class DNS_SRV_DATAW(Structure): + _fields_ = [ + ("pNameTarget", PWSTR), + ("wPriority", WORD), + ("wWeight", WORD), + ("wPort", WORD), + ("Pad", WORD), + ] +PDNS_SRV_DATAW = POINTER(DNS_SRV_DATAW) + +class DNS_SRV_DATAA(Structure): + _fields_ = [ + ("pNameTarget", PSTR), + ("wPriority", WORD), + ("wWeight", WORD), + ("wPort", WORD), + ("Pad", WORD), + ] +PDNS_SRV_DATAA = POINTER(DNS_SRV_DATAA) + +class DNS_NAPTR_DATAW(Structure): + _fields_ = [ + ("wOrder", WORD), + ("wPreference", WORD), + ("pFlags", PWSTR), + ("pService", PWSTR), + ("pRegularExpression", PWSTR), + ("pReplacement", PWSTR), + ] +PDNS_NAPTR_DATAW = POINTER(DNS_NAPTR_DATAW) + +class DNS_NAPTR_DATAA(Structure): + _fields_ = [ + ("wOrder", WORD), + ("wPreference", WORD), + ("pFlags", PSTR), + ("pService", PSTR), + ("pRegularExpression", PSTR), + ("pReplacement", PSTR), + ] +PDNS_NAPTR_DATAA = POINTER(DNS_NAPTR_DATAA) + +class DNS_ATMA_DATA(Structure): + _fields_ = [ + ("AddressType", BYTE), + ("Address", BYTE * DNS_ATMA_MAX_ADDR_LENGTH), + ] +PDNS_ATMA_DATA = POINTER(DNS_ATMA_DATA) + +class DNS_TKEY_DATAW(Structure): + _fields_ = [ + ("pNameAlgorithm", PWSTR), + ("pAlgorithmPacket", PBYTE), + ("pKey", PBYTE), + ("pOtherData", PBYTE), + ("dwCreateTime", DWORD), + ("dwExpireTime", DWORD), + ("wMode", WORD), + ("wError", WORD), + ("wKeyLength", WORD), + ("wOtherLength", WORD), + ("cAlgNameLength", UCHAR), + ("bPacketPointers", BOOL), + ] +PDNS_TKEY_DATAW = POINTER(DNS_TKEY_DATAW) + +class DNS_TKEY_DATAA(Structure): + _fields_ = [ + ("pNameAlgorithm", PSTR), + ("pAlgorithmPacket", PBYTE), + ("pKey", PBYTE), + ("pOtherData", PBYTE), + ("dwCreateTime", DWORD), + ("dwExpireTime", DWORD), + ("wMode", WORD), + ("wError", WORD), + ("wKeyLength", WORD), + ("wOtherLength", WORD), + ("cAlgNameLength", UCHAR), + ("bPacketPointers", BOOL), + ] +PDNS_TKEY_DATAA = POINTER(DNS_TKEY_DATAA) + +class DNS_TSIG_DATAW(Structure): + _fields_ = [ + ("pNameAlgorithm", PWSTR), + ("pAlgorithmPacket", PBYTE), + ("pSignature", PBYTE), + ("pOtherData", PBYTE), + ("i64CreateTime", LONGLONG), + ("wFudgeTime", WORD), + ("wOriginalXid", WORD), + ("wError", WORD), + ("wSigLength", WORD), + ("wOtherLength", WORD), + ("cAlgNameLength", UCHAR), + ("bPacketPointers", BOOL), + ] +PDNS_TSIG_DATAW = POINTER(DNS_TSIG_DATAW) + +class DNS_TSIG_DATAA(Structure): + _fields_ = [ + ("pNameAlgorithm", PSTR), + ("pAlgorithmPacket", PBYTE), + ("pSignature", PBYTE), + ("pOtherData", PBYTE), + ("i64CreateTime", LONGLONG), + ("wFudgeTime", WORD), + ("wOriginalXid", WORD), + ("wError", WORD), + ("wSigLength", WORD), + ("wOtherLength", WORD), + ("cAlgNameLength", UCHAR), + ("bPacketPointers", BOOL), + ] +PDNS_TSIG_DATAA = POINTER(DNS_TSIG_DATAA) + +class DNS_WINS_DATA(Structure): + _fields_ = [ + ("dwMappingFlag", DWORD), + ("dwLookupTimeout", DWORD), + ("dwCacheTimeout", DWORD), + ("cWinsServerCount", DWORD), + ("WinsServers", IP4_ADDRESS * 1), + ] +PDNS_WINS_DATA = POINTER(DNS_WINS_DATA) + +class DNS_WINSR_DATAW(Structure): + _fields_ = [ + ("dwMappingFlag", DWORD), + ("dwLookupTimeout", DWORD), + ("dwCacheTimeout", DWORD), + ("pNameResultDomain", PWSTR), + ] +PDNS_WINSR_DATAW = POINTER(DNS_WINSR_DATAW) + +class DNS_WINSR_DATAA(Structure): + _fields_ = [ + ("dwMappingFlag", DWORD), + ("dwLookupTimeout", DWORD), + ("dwCacheTimeout", DWORD), + ("pNameResultDomain", PSTR), + ] +PDNS_WINSR_DATAA = POINTER(DNS_WINSR_DATAA) + +class DNS_TLSA_DATA(Structure): + _fields_ = [ + ("bCertUsage", BYTE), + ("bSelector", BYTE), + ("bMatchingType", BYTE), + ("bCertificateAssociationDataLength", WORD), + ("bPad", BYTE * 3), + ("bCertificateAssociationData", BYTE * 1), + ] +PDNS_TLSA_DATA = POINTER(DNS_TLSA_DATA) + +class DNS_UNKNOWN_DATA(Structure): + _fields_ = [ + ("dwByteCount", DWORD), + ("bData", BYTE * 1), + ] +PDNS_UNKNOWN_DATA = POINTER(DNS_UNKNOWN_DATA) + +class _DnsRecordFlags(Structure): + _fields_ = [ + ("Section", DWORD, 2), + ("Delete", DWORD, 1), + ("CharSet", DWORD, 2), + ("Unused", DWORD, 3), + ("Reserved", DWORD, 24), + ] +DNS_RECORD_FLAGS = _DnsRecordFlags + +class _ANON__DNSRECORDA_SUB_UNION_1(Union): + _fields_ = [ + ("DW", DWORD), + ("S", DNS_RECORD_FLAGS), + ] + + +class _ANON__DNSRECORDA_SUB_UNION_2(Union): + _fields_ = [ + ("A", DNS_A_DATA), + ("SOA", DNS_SOA_DATAA), + ("Soa", DNS_SOA_DATAA), + ("PTR", DNS_PTR_DATAA), + ("Ptr", DNS_PTR_DATAA), + ("NS", DNS_PTR_DATAA), + ("Ns", DNS_PTR_DATAA), + ("CNAME", DNS_PTR_DATAA), + ("Cname", DNS_PTR_DATAA), + ("DNAME", DNS_PTR_DATAA), + ("Dname", DNS_PTR_DATAA), + ("MB", DNS_PTR_DATAA), + ("Mb", DNS_PTR_DATAA), + ("MD", DNS_PTR_DATAA), + ("Md", DNS_PTR_DATAA), + ("MF", DNS_PTR_DATAA), + ("Mf", DNS_PTR_DATAA), + ("MG", DNS_PTR_DATAA), + ("Mg", DNS_PTR_DATAA), + ("MR", DNS_PTR_DATAA), + ("Mr", DNS_PTR_DATAA), + ("MINFO", DNS_MINFO_DATAA), + ("Minfo", DNS_MINFO_DATAA), + ("RP", DNS_MINFO_DATAA), + ("Rp", DNS_MINFO_DATAA), + ("MX", DNS_MX_DATAA), + ("Mx", DNS_MX_DATAA), + ("AFSDB", DNS_MX_DATAA), + ("Afsdb", DNS_MX_DATAA), + ("RT", DNS_MX_DATAA), + ("Rt", DNS_MX_DATAA), + ("HINFO", DNS_TXT_DATAA), + ("Hinfo", DNS_TXT_DATAA), + ("ISDN", DNS_TXT_DATAA), + ("Isdn", DNS_TXT_DATAA), + ("TXT", DNS_TXT_DATAA), + ("Txt", DNS_TXT_DATAA), + ("X25", DNS_TXT_DATAA), + ("Null", DNS_NULL_DATA), + ("WKS", DNS_WKS_DATA), + ("Wks", DNS_WKS_DATA), + ("AAAA", DNS_AAAA_DATA), + ("KEY", DNS_KEY_DATA), + ("Key", DNS_KEY_DATA), + ("SIG", DNS_SIG_DATAA), + ("Sig", DNS_SIG_DATAA), + ("ATMA", DNS_ATMA_DATA), + ("Atma", DNS_ATMA_DATA), + ("NXT", DNS_NXT_DATAA), + ("Nxt", DNS_NXT_DATAA), + ("SRV", DNS_SRV_DATAA), + ("Srv", DNS_SRV_DATAA), + ("NAPTR", DNS_NAPTR_DATAA), + ("Naptr", DNS_NAPTR_DATAA), + ("OPT", DNS_OPT_DATA), + ("Opt", DNS_OPT_DATA), + ("DS", DNS_DS_DATA), + ("Ds", DNS_DS_DATA), + ("RRSIG", DNS_RRSIG_DATAA), + ("Rrsig", DNS_RRSIG_DATAA), + ("NSEC", DNS_NSEC_DATAA), + ("Nsec", DNS_NSEC_DATAA), + ("DNSKEY", DNS_DNSKEY_DATA), + ("Dnskey", DNS_DNSKEY_DATA), + ("TKEY", DNS_TKEY_DATAA), + ("Tkey", DNS_TKEY_DATAA), + ("TSIG", DNS_TSIG_DATAA), + ("Tsig", DNS_TSIG_DATAA), + ("WINS", DNS_WINS_DATA), + ("Wins", DNS_WINS_DATA), + ("WINSR", DNS_WINSR_DATAA), + ("WinsR", DNS_WINSR_DATAA), + ("NBSTAT", DNS_WINSR_DATAA), + ("Nbstat", DNS_WINSR_DATAA), + ("DHCID", DNS_DHCID_DATA), + ("NSEC3", DNS_NSEC3_DATA), + ("Nsec3", DNS_NSEC3_DATA), + ("NSEC3PARAM", DNS_NSEC3PARAM_DATA), + ("Nsec3Param", DNS_NSEC3PARAM_DATA), + ("TLSA", DNS_TLSA_DATA), + ("Tlsa", DNS_TLSA_DATA), + ("UNKNOWN", DNS_UNKNOWN_DATA), + ("Unknown", DNS_UNKNOWN_DATA), + ("pDataPtr", PBYTE), + ] + +# Self referencing struct tricks +class _DnsRecordA(Structure): pass +PDNS_RECORDA = POINTER(_DnsRecordA) +DNS_RECORDA = _DnsRecordA +_DnsRecordA._fields_ = [ + ("pNext", POINTER(_DnsRecordA)), + ("pName", PSTR), + ("wType", WORD), + ("wDataLength", WORD), + ("Flags", _ANON__DNSRECORDA_SUB_UNION_1), + ("dwTtl", DWORD), + ("dwReserved", DWORD), + ("Data", _ANON__DNSRECORDA_SUB_UNION_2), +] + +class _ANON__DNSRECORDW_SUB_UNION_1(Union): + _fields_ = [ + ("DW", DWORD), + ("S", DNS_RECORD_FLAGS), + ] + + +class _ANON__DNSRECORDW_SUB_UNION_2(Union): + _fields_ = [ + ("A", DNS_A_DATA), + ("SOA", DNS_SOA_DATAW), + ("Soa", DNS_SOA_DATAW), + ("PTR", DNS_PTR_DATAW), + ("Ptr", DNS_PTR_DATAW), + ("NS", DNS_PTR_DATAW), + ("Ns", DNS_PTR_DATAW), + ("CNAME", DNS_PTR_DATAW), + ("Cname", DNS_PTR_DATAW), + ("DNAME", DNS_PTR_DATAW), + ("Dname", DNS_PTR_DATAW), + ("MB", DNS_PTR_DATAW), + ("Mb", DNS_PTR_DATAW), + ("MD", DNS_PTR_DATAW), + ("Md", DNS_PTR_DATAW), + ("MF", DNS_PTR_DATAW), + ("Mf", DNS_PTR_DATAW), + ("MG", DNS_PTR_DATAW), + ("Mg", DNS_PTR_DATAW), + ("MR", DNS_PTR_DATAW), + ("Mr", DNS_PTR_DATAW), + ("MINFO", DNS_MINFO_DATAW), + ("Minfo", DNS_MINFO_DATAW), + ("RP", DNS_MINFO_DATAW), + ("Rp", DNS_MINFO_DATAW), + ("MX", DNS_MX_DATAW), + ("Mx", DNS_MX_DATAW), + ("AFSDB", DNS_MX_DATAW), + ("Afsdb", DNS_MX_DATAW), + ("RT", DNS_MX_DATAW), + ("Rt", DNS_MX_DATAW), + ("HINFO", DNS_TXT_DATAW), + ("Hinfo", DNS_TXT_DATAW), + ("ISDN", DNS_TXT_DATAW), + ("Isdn", DNS_TXT_DATAW), + ("TXT", DNS_TXT_DATAW), + ("Txt", DNS_TXT_DATAW), + ("X25", DNS_TXT_DATAW), + ("Null", DNS_NULL_DATA), + ("WKS", DNS_WKS_DATA), + ("Wks", DNS_WKS_DATA), + ("AAAA", DNS_AAAA_DATA), + ("KEY", DNS_KEY_DATA), + ("Key", DNS_KEY_DATA), + ("SIG", DNS_SIG_DATAW), + ("Sig", DNS_SIG_DATAW), + ("ATMA", DNS_ATMA_DATA), + ("Atma", DNS_ATMA_DATA), + ("NXT", DNS_NXT_DATAW), + ("Nxt", DNS_NXT_DATAW), + ("SRV", DNS_SRV_DATAW), + ("Srv", DNS_SRV_DATAW), + ("NAPTR", DNS_NAPTR_DATAW), + ("Naptr", DNS_NAPTR_DATAW), + ("OPT", DNS_OPT_DATA), + ("Opt", DNS_OPT_DATA), + ("DS", DNS_DS_DATA), + ("Ds", DNS_DS_DATA), + ("RRSIG", DNS_RRSIG_DATAW), + ("Rrsig", DNS_RRSIG_DATAW), + ("NSEC", DNS_NSEC_DATAW), + ("Nsec", DNS_NSEC_DATAW), + ("DNSKEY", DNS_DNSKEY_DATA), + ("Dnskey", DNS_DNSKEY_DATA), + ("TKEY", DNS_TKEY_DATAW), + ("Tkey", DNS_TKEY_DATAW), + ("TSIG", DNS_TSIG_DATAW), + ("Tsig", DNS_TSIG_DATAW), + ("WINS", DNS_WINS_DATA), + ("Wins", DNS_WINS_DATA), + ("WINSR", DNS_WINSR_DATAW), + ("WinsR", DNS_WINSR_DATAW), + ("NBSTAT", DNS_WINSR_DATAW), + ("Nbstat", DNS_WINSR_DATAW), + ("DHCID", DNS_DHCID_DATA), + ("NSEC3", DNS_NSEC3_DATA), + ("Nsec3", DNS_NSEC3_DATA), + ("NSEC3PARAM", DNS_NSEC3PARAM_DATA), + ("Nsec3Param", DNS_NSEC3PARAM_DATA), + ("TLSA", DNS_TLSA_DATA), + ("Tlsa", DNS_TLSA_DATA), + ("UNKNOWN", DNS_UNKNOWN_DATA), + ("Unknown", DNS_UNKNOWN_DATA), + ("pDataPtr", PBYTE), + ] + +# Self referencing struct tricks +class _DnsRecordW(Structure): pass +DNS_RECORDW = _DnsRecordW +PDNS_RECORDW = POINTER(_DnsRecordW) +_DnsRecordW._fields_ = [ + ("pNext", POINTER(_DnsRecordW)), + ("pName", PWSTR), + ("wType", WORD), + ("wDataLength", WORD), + ("Flags", _ANON__DNSRECORDW_SUB_UNION_1), + ("dwTtl", DWORD), + ("dwReserved", DWORD), + ("Data", _ANON__DNSRECORDW_SUB_UNION_2), +] + diff --git a/windows/winproxy/__init__.py b/windows/winproxy/__init__.py index 18e6dc9..304da7a 100644 --- a/windows/winproxy/__init__.py +++ b/windows/winproxy/__init__.py @@ -1,3 +1,3 @@ from .apiproxy import is_implemented, get_target, resolve -from .error import WinproxyError +from .error import WinproxyError, ExportNotFound from .apis import * # Import all functions \ No newline at end of file diff --git a/windows/winproxy/apiproxy.py b/windows/winproxy/apiproxy.py index ce5ac8a..b28dd1f 100644 --- a/windows/winproxy/apiproxy.py +++ b/windows/winproxy/apiproxy.py @@ -2,6 +2,7 @@ import ctypes import functools import windows.generated_def as gdef +from .error import ExportNotFound # Utils def is_implemented(apiproxy): @@ -25,14 +26,6 @@ def resolve(apiproxy): return ctypes.cast(func, gdef.PVOID).value -# ApiProxy stuff -class ExportNotFound(RuntimeError): - def __init__(self, func_name, api_name): - self.func_name = func_name - self.api_name = api_name - super(ExportNotFound, self).__init__("Function {0} not found into {1}".format(func_name, api_name)) - - class NeededParameterType(object): _inst = None diff --git a/windows/winproxy/apis/__init__.py b/windows/winproxy/apis/__init__.py index a4460a5..4591e92 100644 --- a/windows/winproxy/apis/__init__.py +++ b/windows/winproxy/apis/__init__.py @@ -14,4 +14,6 @@ from shlwapi import * from user32 import * from version import * from wevtapi import * -from wintrust import * \ No newline at end of file +from wintrust import * +from tdh import * +from dnsapi import * \ No newline at end of file diff --git a/windows/winproxy/apis/advapi32.py b/windows/winproxy/apis/advapi32.py index 48d0278..f9e01ea 100644 --- a/windows/winproxy/apis/advapi32.py +++ b/windows/winproxy/apis/advapi32.py @@ -2,7 +2,7 @@ import ctypes import windows.generated_def as gdef from ..apiproxy import ApiProxy, NeededParameter -from ..error import fail_on_zero, succeed_on_zero, result_is_error_code +from ..error import fail_on_zero, succeed_on_zero, result_is_error_code, result_is_handle class Advapi32Proxy(ApiProxy): APIDLL = "advapi32" @@ -95,6 +95,16 @@ def AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges=False, NewState=Need BufferLength = ctypes.sizeof(NewState) return AdjustTokenPrivileges.ctypes_function(TokenHandle, DisableAllPrivileges, NewState, BufferLength, PreviousState, ReturnLength) +# Access check + +@Advapi32Proxy() +def MapGenericMask(AccessMask, GenericMapping): + return MapGenericMask.ctypes_function(AccessMask, GenericMapping) + +@Advapi32Proxy() +def AccessCheck(pSecurityDescriptor, ClientToken, DesiredAccess, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus): + return AccessCheck.ctypes_function(pSecurityDescriptor, ClientToken, DesiredAccess, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus) + # Sid @Advapi32Proxy() @@ -355,3 +365,81 @@ def CryptAcquireContextW(phProv, pszContainer, pszProvider, dwProvType, dwFlags) def CryptReleaseContext(hProv, dwFlags): return CryptReleaseContext.ctypes_function(hProv, dwFlags) + +## Event Tracing + +@Advapi32Proxy(error_check=succeed_on_zero) +def EnumerateTraceGuidsEx(TraceQueryInfoClass, InBuffer, InBufferSize, OutBuffer, OutBufferSize, ReturnLength): + if isinstance(InBuffer, gdef.GUID): + # GUID is not convertible to a pointer directly + # But we want to use it as an array for this function + # Test/Assert on InBufferSize? + InBuffer = ctypes.cast(ctypes.pointer(InBuffer), gdef.PVOID) # Caller keep a ref + return EnumerateTraceGuidsEx.ctypes_function(TraceQueryInfoClass, InBuffer, InBufferSize, OutBuffer, OutBufferSize, ReturnLength) + +@Advapi32Proxy(error_check=result_is_error_code) +def QueryAllTracesA(PropertyArray, PropertyArrayCount, SessionCount): + return QueryAllTracesA.ctypes_function(PropertyArray, PropertyArrayCount, SessionCount) + + +@Advapi32Proxy(error_check=result_is_error_code) +def QueryAllTracesW(PropertyArray, PropertyArrayCount, SessionCount): + return QueryAllTracesW.ctypes_function(PropertyArray, PropertyArrayCount, SessionCount) + + +@Advapi32Proxy(error_check=result_is_handle) +def OpenTraceA(Logfile): + return OpenTraceA.ctypes_function(Logfile) + +@Advapi32Proxy(error_check=result_is_handle) +def OpenTraceW(Logfile): + return OpenTraceW.ctypes_function(Logfile) + + +@Advapi32Proxy(error_check=result_is_error_code) +def StartTraceA(TraceHandle, InstanceName, Properties): + return StartTraceA.ctypes_function(TraceHandle, InstanceName, Properties) + +@Advapi32Proxy(error_check=result_is_error_code) +def StartTraceW(TraceHandle, InstanceName, Properties): + return StartTraceW.ctypes_function(TraceHandle, InstanceName, Properties) + +@Advapi32Proxy(error_check=result_is_error_code) +def StopTraceA(TraceHandle, InstanceName, Properties): + return StopTraceA.ctypes_function(TraceHandle, InstanceName, Properties) + +@Advapi32Proxy(error_check=result_is_error_code) +def StopTraceW(TraceHandle, InstanceName, Properties): + return StopTraceW.ctypes_function(TraceHandle, InstanceName, Properties) + +@Advapi32Proxy(error_check=result_is_error_code) +def ControlTraceA(TraceHandle, InstanceName, Properties, ControlCode): + return ControlTraceA.ctypes_function(TraceHandle, InstanceName, Properties, ControlCode) + +@Advapi32Proxy(error_check=result_is_error_code) +def ControlTraceW(TraceHandle, InstanceName, Properties, ControlCode): + return ControlTraceW.ctypes_function(TraceHandle, InstanceName, Properties, ControlCode) + +@Advapi32Proxy(error_check=result_is_error_code) +def ProcessTrace(HandleArray, HandleCount, StartTime, EndTime): + return ProcessTrace.ctypes_function(HandleArray, HandleCount, StartTime, EndTime) + +@Advapi32Proxy(error_check=result_is_error_code) +def EnableTrace(Enable, EnableFlag, EnableLevel, ControlGuid, SessionHandle): + return EnableTrace.ctypes_function(Enable, EnableFlag, EnableLevel, ControlGuid, SessionHandle) + +@Advapi32Proxy(error_check=result_is_error_code) +def EnableTraceEx(ProviderId, SourceId, TraceHandle, IsEnabled, Level, MatchAnyKeyword, MatchAllKeyword, EnableProperty, EnableFilterDesc): + return EnableTraceEx.ctypes_function(ProviderId, SourceId, TraceHandle, IsEnabled, Level, MatchAnyKeyword, MatchAllKeyword, EnableProperty, EnableFilterDesc) + +@Advapi32Proxy(error_check=result_is_error_code) +def EnableTraceEx2(TraceHandle, ProviderId, ControlCode, Level, MatchAnyKeyword, MatchAllKeyword, Timeout, EnableParameters): + return EnableTraceEx2.ctypes_function(TraceHandle, ProviderId, ControlCode, Level, MatchAnyKeyword, MatchAllKeyword, Timeout, EnableParameters) + +@Advapi32Proxy(error_check=result_is_error_code) +def TraceQueryInformation(SessionHandle, InformationClass, TraceInformation, InformationLength, ReturnLength): + return TraceQueryInformation.ctypes_function(SessionHandle, InformationClass, TraceInformation, InformationLength, ReturnLength) + +@Advapi32Proxy(error_check=result_is_error_code) +def TraceSetInformation(SessionHandle, InformationClass, TraceInformation, InformationLength): + return TraceSetInformation.ctypes_function(SessionHandle, InformationClass, TraceInformation, InformationLength) diff --git a/windows/winproxy/apis/dbghelp.py b/windows/winproxy/apis/dbghelp.py index c5b2609..d84ae6a 100644 --- a/windows/winproxy/apis/dbghelp.py +++ b/windows/winproxy/apis/dbghelp.py @@ -8,6 +8,15 @@ class DbgHelpProxy(ApiProxy): APIDLL = "dbghelp" default_error_check = staticmethod(fail_on_zero) +# We keep the simple definition where callback UserContext are PVOID +# Be we want to be able to pass arbitrary python object (list/dict) +# So ctypes magic to make the py_object->pvoid transformation +# !! this code loose a ref to obj. +# Should still work as our calling-caller method keep a ref +def transform_pyobject_to_pvoid(obj): + if obj is None or isinstance(obj, (int, long)): + return obj + return ctypes.POINTER(gdef.PVOID)(ctypes.py_object(obj))[0] @DbgHelpProxy() def SymInitialize(hProcess, UserSearchPath, fInvadeProcess): @@ -27,4 +36,63 @@ def SymFromAddr(hProcess, Address, Displacement, Symbol): @DbgHelpProxy() def SymGetModuleInfo64(hProcess, dwAddr, ModuleInfo): - return SymGetModuleInfo64.ctypes_function(hProcess, dwAddr, ModuleInfo) \ No newline at end of file + return SymGetModuleInfo64.ctypes_function(hProcess, dwAddr, ModuleInfo) + +@DbgHelpProxy() +def SymFromName(hProcess, Name, Symbol): + return SymFromName.ctypes_function(hProcess, Name, Symbol) + +@DbgHelpProxy() +def SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags): + return SymLoadModuleEx.ctypes_function(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags) + +@DbgHelpProxy() +def SymSetOptions(SymOptions): + return SymSetOptions.ctypes_function(SymOptions) + +@DbgHelpProxy() +def SymGetTypeInfo(hProcess, ModBase, TypeId, GetType, pInfo): + return SymGetTypeInfo.ctypes_function(hProcess, ModBase, TypeId, GetType, pInfo) + +@DbgHelpProxy() +def SymEnumSymbols(hProcess, BaseOfDll, Mask, EnumSymbolsCallback, UserContext): + if UserContext is not None and not isinstance(UserContext, (int, long)): + UserContext = transform_pyobject_to_pvoid(UserContext) + return SymEnumSymbols.ctypes_function(hProcess, BaseOfDll, Mask, EnumSymbolsCallback, UserContext) + +@DbgHelpProxy() +def SymEnumSymbolsEx(hProcess, BaseOfDll, Mask, EnumSymbolsCallback, UserContext, Options): + if UserContext is not None and not isinstance(UserContext, (int, long)): + UserContext = transform_pyobject_to_pvoid(UserContext) + return SymEnumSymbolsEx.ctypes_function(hProcess, BaseOfDll, Mask, EnumSymbolsCallback, UserContext, Options) + +@DbgHelpProxy() +def SymEnumTypes(hProcess, BaseOfDll, EnumSymbolsCallback, UserContext): + if UserContext is not None and not isinstance(UserContext, (int, long)): + UserContext = transform_pyobject_to_pvoid(UserContext) + return SymEnumTypes.ctypes_function(hProcess, BaseOfDll, EnumSymbolsCallback, UserContext) + +@DbgHelpProxy() +def SymEnumTypesByName(hProcess, BaseOfDll, mask, EnumSymbolsCallback, UserContext): + if UserContext is not None and not isinstance(UserContext, (int, long)): + UserContext = transform_pyobject_to_pvoid(UserContext) + return SymEnumTypesByName.ctypes_function(hProcess, BaseOfDll, mask, EnumSymbolsCallback, UserContext) + +@DbgHelpProxy() +def SymEnumerateModules64(hProcess, EnumModulesCallback, UserContext): + if UserContext is not None and not isinstance(UserContext, (int, long)): + UserContext = transform_pyobject_to_pvoid(UserContext) + return SymEnumerateModules64.ctypes_function(hProcess, EnumModulesCallback, UserContext) + +@DbgHelpProxy() +def SymGetTypeFromName(hProcess, BaseOfDll, Name, Symbol): + return SymGetTypeFromName.ctypes_function(hProcess, BaseOfDll, Name, Symbol) + +@DbgHelpProxy() +def SymSearch(hProcess, BaseOfDll, Index, SymTag, Mask, Address, EnumSymbolsCallback, UserContext, Options): + UserContext = transform_pyobject_to_pvoid(UserContext) + return SymSearch.ctypes_function(hProcess, BaseOfDll, Index, SymTag, Mask, Address, EnumSymbolsCallback, UserContext, Options) + +@DbgHelpProxy() +def SymSearchW(hProcess, BaseOfDll, Index, SymTag, Mask, Address, EnumSymbolsCallback, UserContext, Options): + return SymSearchW.ctypes_function(hProcess, BaseOfDll, Index, SymTag, Mask, Address, EnumSymbolsCallback, UserContext, Options) diff --git a/windows/winproxy/apis/dnsapi.py b/windows/winproxy/apis/dnsapi.py new file mode 100644 index 0000000..02f8054 --- /dev/null +++ b/windows/winproxy/apis/dnsapi.py @@ -0,0 +1,28 @@ +import ctypes +import windows.generated_def as gdef + +from ..apiproxy import ApiProxy, NeededParameter +from ..error import fail_on_zero, result_is_error_code + +class DNSapiProxy(ApiProxy): + APIDLL = "dnsapi" + default_error_check = staticmethod(fail_on_zero) + + +@DNSapiProxy() +def DnsGetCacheDataTable(DnsEntries): + return DnsGetCacheDataTable.ctypes_function(DnsEntries) + + +@DNSapiProxy(error_check=result_is_error_code) +def DnsQuery_A(pszName, wType, Options, pExtra, ppQueryResults, pReserved): + return DnsQuery_A.ctypes_function(pszName, wType, Options, pExtra, ppQueryResults, pReserved) + + +@DNSapiProxy(error_check=result_is_error_code) +def DnsQuery_W(pszName, wType, Options, pExtra, ppQueryResults, pReserved): + return DnsQuery_W.ctypes_function(pszName, wType, Options, pExtra, ppQueryResults, pReserved) + +@DNSapiProxy() +def DnsFree(pData, FreeType): + return DnsFree.ctypes_function(pData, FreeType) diff --git a/windows/winproxy/apis/kernel32.py b/windows/winproxy/apis/kernel32.py index 58bfa29..17c9c94 100644 --- a/windows/winproxy/apis/kernel32.py +++ b/windows/winproxy/apis/kernel32.py @@ -427,11 +427,15 @@ def DeviceIoControl(hDevice, dwIoControlCode, lpInBuffer, nInBufferSize=None, lp # Wow64 @Kernel32Proxy() -def Wow64DisableWow64FsRedirection(OldValue): +def Wow64DisableWow64FsRedirection(OldValue=None): + if OldValue is None: + OldValue = gdef.PVOID() return Wow64DisableWow64FsRedirection.ctypes_function(OldValue) @Kernel32Proxy() -def Wow64RevertWow64FsRedirection(OldValue): +def Wow64RevertWow64FsRedirection(OldValue=None): + if OldValue is None: + OldValue = gdef.PVOID() return Wow64RevertWow64FsRedirection.ctypes_function(OldValue) @Kernel32Proxy() @@ -711,6 +715,10 @@ def ConnectNamedPipe(hNamedPipe, lpOverlapped): def SetNamedPipeHandleState(hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout): return SetNamedPipeHandleState.ctypes_function(hNamedPipe, lpMode, lpMaxCollectionCount, lpCollectDataTimeout) +@Kernel32Proxy() +def CreatePipe(hReadPipe, hWritePipe, lpPipeAttributes, nSize): + return CreatePipe.ctypes_function(hReadPipe, hWritePipe, lpPipeAttributes, nSize) + # Firmware @Kernel32Proxy() @@ -729,4 +737,22 @@ def GetFirmwareEnvironmentVariableExA(lpName, lpGuid, pBuffer, nSize, pdwAttribu def GetFirmwareEnvironmentVariableExW(lpName, lpGuid, pBuffer, nSize, pdwAttribubutes): return GetFirmwareEnvironmentVariableExW.ctypes_function(lpName, lpGuid, pBuffer, nSize, pdwAttribubutes) -##### \ No newline at end of file +##### + +# Time + +@Kernel32Proxy(error_check=fail_on_zero) +def FileTimeToSystemTime(lpFileTime, lpSystemTime): + return FileTimeToSystemTime.ctypes_function(lpFileTime, lpSystemTime) + +@Kernel32Proxy(error_check=fail_on_zero) +def SystemTimeToFileTime(lpSystemTime, lpFileTime): + return SystemTimeToFileTime.ctypes_function(lpSystemTime, lpFileTime) + +@Kernel32Proxy(error_check=None) +def GetSystemTime(lpSystemTime): + return GetSystemTime.ctypes_function(lpSystemTime) + +@Kernel32Proxy(error_check=None) +def GetSystemTimeAsFileTime(lpSystemTimeAsFileTime): + return GetSystemTimeAsFileTime.ctypes_function(lpSystemTimeAsFileTime) diff --git a/windows/winproxy/apis/ntdll.py b/windows/winproxy/apis/ntdll.py index dc64b20..f9094ea 100644 --- a/windows/winproxy/apis/ntdll.py +++ b/windows/winproxy/apis/ntdll.py @@ -35,6 +35,11 @@ def NtWow64WriteVirtualMemory64(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumb def NtCreateFile(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, AllocationSize, FileAttributes, ShareAccess, CreateDisposition, CreateOptions, EaBuffer, EaLength): return NtCreateFile.ctypes_function(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, AllocationSize, FileAttributes, ShareAccess, CreateDisposition, CreateOptions, EaBuffer, EaLength) +@NtdllProxy() +def NtOpenFile(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, ShareAccess, OpenOptions): + return NtOpenFile.ctypes_function(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, ShareAccess, OpenOptions) + + @NtdllProxy() def NtSetInformationFile(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass): return NtSetInformationFile.ctypes_function(FileHandle, IoStatusBlock, FileInformation, Length, FileInformationClass) @@ -195,8 +200,8 @@ def NtQueryDirectoryObject(DirectoryHandle, Buffer, Length, ReturnSingleEntry, R @NtdllProxy() -def NtQuerySymbolicLinkObject(LinkHandle, LinkTarget, ReturnedLength): - return NtQuerySymbolicLinkObject.ctypes_function(LinkHandle, LinkTarget, ReturnedLength) +def NtCreateSymbolicLinkObject(pHandle, DesiredAccess, ObjectAttributes, DestinationName): + return NtCreateSymbolicLinkObject.ctypes_function(pHandle, DesiredAccess, ObjectAttributes, DestinationName) @NtdllProxy() @@ -204,6 +209,11 @@ def NtOpenSymbolicLinkObject(LinkHandle, DesiredAccess, ObjectAttributes): return NtOpenSymbolicLinkObject.ctypes_function(LinkHandle, DesiredAccess, ObjectAttributes) +@NtdllProxy() +def NtQuerySymbolicLinkObject(LinkHandle, LinkTarget, ReturnedLength): + return NtQuerySymbolicLinkObject.ctypes_function(LinkHandle, LinkTarget, ReturnedLength) + + # Event @NtdllProxy() @@ -358,6 +368,9 @@ def NtQueryLicenseValue(Name, Type, Buffer, Length=None, DataLength=NeededParame Length = len(buffer) return NtQueryLicenseValue.ctypes_function(Name, Type, Buffer, Length, DataLength) +@NtdllProxy() +def NtQueryKey(KeyHandle, KeyInformationClass, KeyInformation, Length, ResultLength): + return NtQueryKey.ctypes_function(KeyHandle, KeyInformationClass, KeyInformation, Length, ResultLength) # Other @@ -373,6 +386,12 @@ def NtEnumerateSystemEnvironmentValuesEx(InformationClass, Buffer, BufferLength) return NtEnumerateSystemEnvironmentValuesEx.ctypes_function(InformationClass, Buffer, BufferLength) +# Pipe +@NtdllProxy() +def NtCreateNamedPipeFile(NamedPipeFileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, ShareAccess, CreateDisposition, CreateOptions, WriteModeMessage, ReadModeMessage, NonBlocking, MaxInstances, InBufferSize, OutBufferSize, DefaultTimeOut): + return NtCreateNamedPipeFile.ctypes_function(NamedPipeFileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, ShareAccess, CreateDisposition, CreateOptions, WriteModeMessage, ReadModeMessage, NonBlocking, MaxInstances, InBufferSize, OutBufferSize, DefaultTimeOut) + + ######### diff --git a/windows/winproxy/apis/ole32.py b/windows/winproxy/apis/ole32.py index d2447ab..2d490cb 100644 --- a/windows/winproxy/apis/ole32.py +++ b/windows/winproxy/apis/ole32.py @@ -32,10 +32,18 @@ def CoCreateInstanceEx(rclsid, punkOuter, dwClsCtx, pServerInfo, dwCount, pResul return CoCreateInstanceEx.ctypes_function(rclsid, punkOuter, dwClsCtx, pServerInfo, dwCount, pResults) +@Ole32Proxy() +def CoGetClassObject(rclsid, dwClsContext, pvReserved, riid, ppv): + return CoGetClassObject.ctypes_function(rclsid, dwClsContext, pvReserved, riid, ppv) + @Ole32Proxy() def CoGetInterceptor(iidIntercepted, punkOuter, iid, ppv): return CoGetInterceptor.ctypes_function(iidIntercepted, punkOuter, iid, ppv) @Ole32Proxy() def CLSIDFromProgID(lpszProgID, lpclsid): - return CLSIDFromProgID.ctypes_function(lpszProgID, lpclsid) \ No newline at end of file + return CLSIDFromProgID.ctypes_function(lpszProgID, lpclsid) + +@Ole32Proxy() +def CoTaskMemFree(pv): + return CoTaskMemFree.ctypes_function(pv) \ No newline at end of file diff --git a/windows/winproxy/apis/tdh.py b/windows/winproxy/apis/tdh.py new file mode 100644 index 0000000..4db3a9f --- /dev/null +++ b/windows/winproxy/apis/tdh.py @@ -0,0 +1,16 @@ +import ctypes +import windows.generated_def as gdef + +from ..apiproxy import ApiProxy, NeededParameter +from ..error import result_is_error_code + +# TDH: Trace Data Helper +# https://docs.microsoft.com/en-us/windows/desktop/etw/retrieving-event-data-using-tdh + +class TdhProxy(ApiProxy): + APIDLL = "tdh" + default_error_check = staticmethod(result_is_error_code) + +@TdhProxy() +def TdhEnumerateProviders(pBuffer, pBufferSize): + return TdhEnumerateProviders.ctypes_function(pBuffer, pBufferSize) \ No newline at end of file diff --git a/windows/winproxy/apis/version.py b/windows/winproxy/apis/version.py index 3869f7e..ce5b9a3 100644 --- a/windows/winproxy/apis/version.py +++ b/windows/winproxy/apis/version.py @@ -19,7 +19,7 @@ def GetFileVersionInfoA(lptstrFilename, dwHandle=0, dwLen=None, lpData=NeededPar def GetFileVersionInfoW(lptstrFilename, dwHandle=0, dwLen=None, lpData=NeededParameter): if dwLen is None and lpData is not None: dwLen = len(lpData) - return GetFileVersionInfoA.ctypes_function(lptstrFilename, dwHandle, dwLen, lpData) + return GetFileVersionInfoW.ctypes_function(lptstrFilename, dwHandle, dwLen, lpData) @VersionProxy() def GetFileVersionInfoSizeA(lptstrFilename, lpdwHandle=None): diff --git a/windows/winproxy/error.py b/windows/winproxy/error.py index 315a915..aaaddc8 100644 --- a/windows/winproxy/error.py +++ b/windows/winproxy/error.py @@ -3,6 +3,15 @@ import ctypes import windows.generated_def as gdef from windows.generated_def.ntstatus import NtStatusException + +# ApiProxy stuff +class ExportNotFound(RuntimeError): + def __init__(self, func_name, api_name): + self.func_name = func_name + self.api_name = api_name + super(ExportNotFound, self).__init__("Function {0} not found into {1}".format(func_name, api_name)) + + # PFW Winproxy Exception type class WinproxyError(WindowsError): def __new__(cls, func_name, error_code=None):