Last active
June 25, 2021 12:57
-
-
Save terickson001/aecbb9107e15afd9397d61883c091843 to your computer and use it in GitHub Desktop.
Windows.h bindings for Odin. Generated with bind-odin
This file has been truncated, but you can view the full file.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| package win32 | |
| foreign import kernel32 "system:kernel32.lib"; | |
| foreign import user32 "system:user32.lib"; | |
| foreign import ole32 "system:ole32.lib"; | |
| foreign import shell32 "system:shell32.lib"; | |
| foreign import gdi32 "system:gdi32.lib"; | |
| foreign import comdlg32 "system:comdlg32.lib"; | |
| foreign import bcrypt "system:bcrypt.lib"; | |
| foreign import advapi32 "system:advapi32.lib"; | |
| foreign import winmm "system:winmm.lib"; | |
| foreign import opengl32 "system:opengl32.lib"; | |
| foreign import userenv "system:userenv.lib"; | |
| foreign import synchronization "system:synchronization.lib"; | |
| foreign import oleaut32 "system:oleaut32.lib"; | |
| foreign import WS2_32 "system:WS2_32.lib"; | |
| import _c "core:c" | |
| /* Opaque Types */ | |
| __crt_locale_data :: struct {} | |
| _ACTIVATION_CONTEXT :: struct {} | |
| __crt_multibyte_data :: struct {} | |
| _TEB :: struct {} | |
| _NDR_CORRELATION_INFO :: struct {} | |
| _NDR_ASYNC_MESSAGE :: struct {} | |
| NET_ADDRESS_INFO_ :: struct {} | |
| _wireSAFEARRAY :: struct { | |
| cDims : USHORT, | |
| fFeatures : USHORT, | |
| cbElements : ULONG, | |
| cLocks : ULONG, | |
| uArrayStructs : SAFEARRAYUNION, | |
| rgsabound : [1]SAFEARRAYBOUND, | |
| } | |
| _SC_NOTIFICATION_REGISTRATION :: struct {} | |
| _PROC_THREAD_ATTRIBUTE_LIST :: struct {} | |
| /* Defines */ | |
| uintptr_t :: u64; | |
| va_list :: ^_c.uchar; | |
| size_t :: u64; | |
| ptrdiff_t :: i64; | |
| intptr_t :: i64; | |
| __vcrt_bool :: _c.bool; | |
| wchar_t :: _c.ushort; | |
| /* EXCEPTION_DISPOSITION :: enum { */ | |
| EXCEPTION_DISPOSITION :: _c.int; | |
| ExceptionContinueExecution :: 0; | |
| ExceptionContinueSearch :: ExceptionContinueExecution + 1; | |
| ExceptionNestedException :: ExceptionContinueSearch + 1; | |
| ExceptionCollidedUnwind :: ExceptionNestedException + 1; | |
| /* } */ | |
| ; | |
| ULONG :: _c.ulong; | |
| PULONG :: ^ULONG; | |
| USHORT :: _c.ushort; | |
| PUSHORT :: ^USHORT; | |
| UCHAR :: _c.uchar; | |
| PUCHAR :: ^UCHAR; | |
| PSZ :: ^_c.uchar; | |
| DWORD :: _c.ulong; | |
| BOOL :: _c.int; | |
| BYTE :: _c.uchar; | |
| WORD :: _c.ushort; | |
| FLOAT :: _c.float; | |
| PFLOAT :: ^FLOAT; | |
| PBOOL :: ^BOOL; | |
| LPBOOL :: ^BOOL; | |
| PBYTE :: ^BYTE; | |
| LPBYTE :: ^BYTE; | |
| PINT :: ^_c.int; | |
| LPINT :: ^_c.int; | |
| PWORD :: ^WORD; | |
| LPWORD :: ^WORD; | |
| LPLONG :: ^_c.long; | |
| PDWORD :: ^DWORD; | |
| LPDWORD :: ^DWORD; | |
| LPVOID :: rawptr; | |
| LPCVOID :: rawptr; | |
| INT :: _c.int; | |
| UINT :: _c.uint; | |
| PUINT :: ^_c.uint; | |
| __crt_bool :: _c.bool; | |
| errno_t :: _c.int; | |
| wint_t :: _c.ushort; | |
| wctype_t :: _c.ushort; | |
| __time32_t :: _c.long; | |
| __time64_t :: i64; | |
| __crt_locale_data_public :: struct { | |
| _locale_pctype : ^_c.ushort, | |
| _locale_mb_cur_max : _c.int, | |
| _locale_lc_codepage : _c.uint, | |
| }; | |
| __crt_locale_pointers :: struct { | |
| locinfo : ^__crt_locale_data, | |
| mbcinfo : ^__crt_multibyte_data, | |
| }; | |
| _locale_t :: ^__crt_locale_pointers; | |
| _Mbstatet :: struct { | |
| _Wchar : _c.ulong, | |
| _Byte : _c.ushort, | |
| _State : _c.ushort, | |
| }; | |
| mbstate_t :: _Mbstatet; | |
| time_t :: __time64_t; | |
| rsize_t :: _c.size_t; | |
| POINTER_64_INT :: u64; | |
| INT8 :: _c.schar; | |
| PINT8 :: ^_c.schar; | |
| INT16 :: _c.short; | |
| PINT16 :: ^_c.short; | |
| INT32 :: _c.int; | |
| PINT32 :: ^_c.int; | |
| INT64 :: i64; | |
| PINT64 :: ^i64; | |
| UINT8 :: _c.uchar; | |
| PUINT8 :: ^_c.uchar; | |
| UINT16 :: _c.ushort; | |
| PUINT16 :: ^_c.ushort; | |
| UINT32 :: _c.uint; | |
| PUINT32 :: ^_c.uint; | |
| UINT64 :: u64; | |
| PUINT64 :: ^u64; | |
| LONG32 :: _c.int; | |
| PLONG32 :: ^_c.int; | |
| ULONG32 :: _c.uint; | |
| PULONG32 :: ^_c.uint; | |
| DWORD32 :: _c.uint; | |
| PDWORD32 :: ^_c.uint; | |
| INT_PTR :: i64; | |
| PINT_PTR :: ^i64; | |
| UINT_PTR :: u64; | |
| PUINT_PTR :: ^u64; | |
| LONG_PTR :: i64; | |
| PLONG_PTR :: ^i64; | |
| ULONG_PTR :: u64; | |
| PULONG_PTR :: ^u64; | |
| SHANDLE_PTR :: i64; | |
| HANDLE_PTR :: u64; | |
| UHALF_PTR :: _c.uint; | |
| PUHALF_PTR :: ^_c.uint; | |
| HALF_PTR :: _c.int; | |
| PHALF_PTR :: ^_c.int; | |
| SIZE_T :: ULONG_PTR; | |
| PSIZE_T :: ^ULONG_PTR; | |
| SSIZE_T :: LONG_PTR; | |
| PSSIZE_T :: ^LONG_PTR; | |
| DWORD_PTR :: ULONG_PTR; | |
| PDWORD_PTR :: ^ULONG_PTR; | |
| LONG64 :: i64; | |
| PLONG64 :: ^i64; | |
| ULONG64 :: u64; | |
| PULONG64 :: ^u64; | |
| DWORD64 :: u64; | |
| PDWORD64 :: ^u64; | |
| KAFFINITY :: ULONG_PTR; | |
| PKAFFINITY :: ^KAFFINITY; | |
| PVOID :: rawptr; | |
| PVOID64 :: rawptr; | |
| CHAR :: _c.uchar; | |
| SHORT :: _c.short; | |
| LONG :: _c.long; | |
| ; | |
| WCHAR :: _c.wchar_t; | |
| PWCHAR :: ^WCHAR; | |
| LPWCH :: ^WCHAR; | |
| PWCH :: ^WCHAR; | |
| LPCWCH :: ^WCHAR; | |
| PCWCH :: ^WCHAR; | |
| NWPSTR :: ^WCHAR; | |
| LPWSTR :: ^WCHAR; | |
| PWSTR :: ^WCHAR; | |
| PZPWSTR :: ^PWSTR; | |
| PCZPWSTR :: ^PWSTR; | |
| LPUWSTR :: ^WCHAR; | |
| PUWSTR :: ^WCHAR; | |
| LPCWSTR :: ^WCHAR; | |
| PCWSTR :: ^WCHAR; | |
| PZPCWSTR :: ^PCWSTR; | |
| PCZPCWSTR :: ^PCWSTR; | |
| LPCUWSTR :: ^WCHAR; | |
| PCUWSTR :: ^WCHAR; | |
| PZZWSTR :: ^WCHAR; | |
| PCZZWSTR :: ^WCHAR; | |
| PUZZWSTR :: ^WCHAR; | |
| PCUZZWSTR :: ^WCHAR; | |
| PNZWCH :: ^WCHAR; | |
| PCNZWCH :: ^WCHAR; | |
| PUNZWCH :: ^WCHAR; | |
| PCUNZWCH :: ^WCHAR; | |
| LPCWCHAR :: ^WCHAR; | |
| PCWCHAR :: ^WCHAR; | |
| LPCUWCHAR :: ^WCHAR; | |
| PCUWCHAR :: ^WCHAR; | |
| UCSCHAR :: _c.ulong; | |
| PUCSCHAR :: ^UCSCHAR; | |
| PCUCSCHAR :: ^UCSCHAR; | |
| PUCSSTR :: ^UCSCHAR; | |
| PUUCSSTR :: ^UCSCHAR; | |
| PCUCSSTR :: ^UCSCHAR; | |
| PCUUCSSTR :: ^UCSCHAR; | |
| PUUCSCHAR :: ^UCSCHAR; | |
| PCUUCSCHAR :: ^UCSCHAR; | |
| PCHAR :: ^CHAR; | |
| LPCH :: ^CHAR; | |
| PCH :: ^CHAR; | |
| LPCCH :: ^CHAR; | |
| PCCH :: ^CHAR; | |
| NPSTR :: ^CHAR; | |
| LPSTR :: ^CHAR; | |
| PSTR :: ^CHAR; | |
| PZPSTR :: ^PSTR; | |
| PCZPSTR :: ^PSTR; | |
| LPCSTR :: ^CHAR; | |
| PCSTR :: ^CHAR; | |
| PZPCSTR :: ^PCSTR; | |
| PCZPCSTR :: ^PCSTR; | |
| PZZSTR :: ^CHAR; | |
| PCZZSTR :: ^CHAR; | |
| PNZCH :: ^CHAR; | |
| PCNZCH :: ^CHAR; | |
| TCHAR :: _c.uchar; | |
| PTCHAR :: ^_c.uchar; | |
| TBYTE :: _c.uchar; | |
| PTBYTE :: ^_c.uchar; | |
| LPTCH :: LPCH; | |
| PTCH :: LPCH; | |
| LPCTCH :: LPCCH; | |
| PCTCH :: LPCCH; | |
| PTSTR :: LPSTR; | |
| LPTSTR :: LPSTR; | |
| PUTSTR :: LPSTR; | |
| LPUTSTR :: LPSTR; | |
| PCTSTR :: LPCSTR; | |
| LPCTSTR :: LPCSTR; | |
| PCUTSTR :: LPCSTR; | |
| LPCUTSTR :: LPCSTR; | |
| PZZTSTR :: PZZSTR; | |
| PUZZTSTR :: PZZSTR; | |
| PCZZTSTR :: PCZZSTR; | |
| PCUZZTSTR :: PCZZSTR; | |
| PZPTSTR :: PZPSTR; | |
| PNZTCH :: PNZCH; | |
| PUNZTCH :: PNZCH; | |
| PCNZTCH :: PCNZCH; | |
| PCUNZTCH :: PCNZCH; | |
| PSHORT :: ^SHORT; | |
| PLONG :: ^LONG; | |
| PROCESSOR_NUMBER :: struct { | |
| Group : WORD, | |
| Number : BYTE, | |
| Reserved : BYTE, | |
| }; | |
| PPROCESSOR_NUMBER :: ^PROCESSOR_NUMBER; | |
| GROUP_AFFINITY :: struct { | |
| Mask : KAFFINITY, | |
| Group : WORD, | |
| Reserved : [3]WORD, | |
| }; | |
| PGROUP_AFFINITY :: ^GROUP_AFFINITY; | |
| HANDLE :: rawptr; | |
| PHANDLE :: ^HANDLE; | |
| FCHAR :: BYTE; | |
| FSHORT :: WORD; | |
| FLONG :: DWORD; | |
| HRESULT :: _c.long; | |
| CCHAR :: _c.uchar; | |
| LCID :: DWORD; | |
| PLCID :: PDWORD; | |
| LANGID :: WORD; | |
| /* COMPARTMENT_ID :: enum { */ | |
| COMPARTMENT_ID :: _c.int; | |
| UNSPECIFIED_COMPARTMENT_ID :: 0; | |
| DEFAULT_COMPARTMENT_ID :: UNSPECIFIED_COMPARTMENT_ID + 1; | |
| /* } */ | |
| PCOMPARTMENT_ID :: ^COMPARTMENT_ID; | |
| FLOAT128 :: struct { | |
| LowPart : i64, | |
| HighPart : i64, | |
| }; | |
| PFLOAT128 :: ^FLOAT128; | |
| LONGLONG :: i64; | |
| ULONGLONG :: u64; | |
| PLONGLONG :: ^LONGLONG; | |
| PULONGLONG :: ^ULONGLONG; | |
| USN :: LONGLONG; | |
| LARGE_INTEGER :: struct #raw_union { | |
| s : struct { | |
| LowPart : DWORD, | |
| HighPart : LONG, | |
| }, | |
| u : struct { | |
| LowPart : DWORD, | |
| HighPart : LONG, | |
| }, | |
| QuadPart : LONGLONG, | |
| }; | |
| PLARGE_INTEGER :: ^LARGE_INTEGER; | |
| ULARGE_INTEGER :: struct #raw_union { | |
| s : struct { | |
| LowPart : DWORD, | |
| HighPart : DWORD, | |
| }, | |
| u : struct { | |
| LowPart : DWORD, | |
| HighPart : DWORD, | |
| }, | |
| QuadPart : ULONGLONG, | |
| }; | |
| PULARGE_INTEGER :: ^ULARGE_INTEGER; | |
| RTL_REFERENCE_COUNT :: LONG_PTR; | |
| PRTL_REFERENCE_COUNT :: ^LONG_PTR; | |
| RTL_REFERENCE_COUNT32 :: LONG; | |
| PRTL_REFERENCE_COUNT32 :: ^LONG; | |
| LUID :: struct { | |
| LowPart : DWORD, | |
| HighPart : LONG, | |
| }; | |
| PLUID :: ^LUID; | |
| DWORDLONG :: ULONGLONG; | |
| PDWORDLONG :: ^DWORDLONG; | |
| BOOLEAN :: BYTE; | |
| PBOOLEAN :: ^BOOLEAN; | |
| LIST_ENTRY :: struct { | |
| Flink : ^LIST_ENTRY, | |
| Blink : ^LIST_ENTRY, | |
| }; | |
| PLIST_ENTRY :: ^LIST_ENTRY; | |
| PRLIST_ENTRY :: ^LIST_ENTRY; | |
| SINGLE_LIST_ENTRY :: struct { | |
| Next : ^SINGLE_LIST_ENTRY, | |
| }; | |
| PSINGLE_LIST_ENTRY :: ^SINGLE_LIST_ENTRY; | |
| LIST_ENTRY32 :: struct { | |
| Flink : DWORD, | |
| Blink : DWORD, | |
| }; | |
| PLIST_ENTRY32 :: ^LIST_ENTRY32; | |
| LIST_ENTRY64 :: struct { | |
| Flink : ULONGLONG, | |
| Blink : ULONGLONG, | |
| }; | |
| PLIST_ENTRY64 :: ^LIST_ENTRY64; | |
| GUID :: struct { | |
| Data1 : _c.ulong, | |
| Data2 : _c.ushort, | |
| Data3 : _c.ushort, | |
| Data4 : [8]_c.uchar, | |
| }; | |
| LPGUID :: ^GUID; | |
| LPCGUID :: ^GUID; | |
| IID :: GUID; | |
| LPIID :: ^IID; | |
| CLSID :: GUID; | |
| LPCLSID :: ^CLSID; | |
| FMTID :: GUID; | |
| LPFMTID :: ^FMTID; | |
| OBJECTID :: struct { | |
| Lineage : GUID, | |
| Uniquifier : DWORD, | |
| }; | |
| EXCEPTION_ROUTINE :: #type (proc "stdcall" (ExceptionRecord : ^EXCEPTION_RECORD, EstablisherFrame : PVOID, ContextRecord : ^CONTEXT, DispatcherContext : PVOID) -> EXCEPTION_DISPOSITION); | |
| PEXCEPTION_ROUTINE :: ^EXCEPTION_ROUTINE; | |
| KSPIN_LOCK :: ULONG_PTR; | |
| PKSPIN_LOCK :: ^KSPIN_LOCK; | |
| M128A :: struct { | |
| Low : ULONGLONG, | |
| High : LONGLONG, | |
| }; | |
| PM128A :: ^M128A; | |
| XSAVE_FORMAT :: struct { | |
| ControlWord : WORD, | |
| StatusWord : WORD, | |
| TagWord : BYTE, | |
| Reserved1 : BYTE, | |
| ErrorOpcode : WORD, | |
| ErrorOffset : DWORD, | |
| ErrorSelector : WORD, | |
| Reserved2 : WORD, | |
| DataOffset : DWORD, | |
| DataSelector : WORD, | |
| Reserved3 : WORD, | |
| MxCsr : DWORD, | |
| MxCsr_Mask : DWORD, | |
| FloatRegisters : [8]M128A, | |
| XmmRegisters : [16]M128A, | |
| Reserved4 : [96]BYTE, | |
| }; | |
| PXSAVE_FORMAT :: ^XSAVE_FORMAT; | |
| XSAVE_CET_U_FORMAT :: struct { | |
| Ia32CetUMsr : DWORD64, | |
| Ia32Pl3SspMsr : DWORD64, | |
| }; | |
| PXSAVE_CET_U_FORMAT :: ^XSAVE_CET_U_FORMAT; | |
| XSAVE_AREA_HEADER :: struct { | |
| Mask : DWORD64, | |
| CompactionMask : DWORD64, | |
| Reserved2 : [6]DWORD64, | |
| }; | |
| PXSAVE_AREA_HEADER :: ^XSAVE_AREA_HEADER; | |
| XSAVE_AREA :: struct { | |
| LegacyState : XSAVE_FORMAT, | |
| Header : XSAVE_AREA_HEADER, | |
| }; | |
| PXSAVE_AREA :: ^XSAVE_AREA; | |
| XSTATE_CONTEXT :: struct { | |
| Mask : DWORD64, | |
| Length : DWORD, | |
| Reserved1 : DWORD, | |
| Area : PXSAVE_AREA, | |
| Buffer : PVOID, | |
| }; | |
| PXSTATE_CONTEXT :: ^XSTATE_CONTEXT; | |
| SCOPE_TABLE_AMD64 :: struct { | |
| Count : DWORD, | |
| ScopeRecord : [1]struct { | |
| BeginAddress : DWORD, | |
| EndAddress : DWORD, | |
| HandlerAddress : DWORD, | |
| JumpTarget : DWORD, | |
| }, | |
| }; | |
| PSCOPE_TABLE_AMD64 :: ^SCOPE_TABLE_AMD64; | |
| XMM_SAVE_AREA32 :: XSAVE_FORMAT; | |
| PXMM_SAVE_AREA32 :: ^XSAVE_FORMAT; | |
| CONTEXT :: struct { | |
| P1Home : DWORD64, | |
| P2Home : DWORD64, | |
| P3Home : DWORD64, | |
| P4Home : DWORD64, | |
| P5Home : DWORD64, | |
| P6Home : DWORD64, | |
| ContextFlags : DWORD, | |
| MxCsr : DWORD, | |
| SegCs : WORD, | |
| SegDs : WORD, | |
| SegEs : WORD, | |
| SegFs : WORD, | |
| SegGs : WORD, | |
| SegSs : WORD, | |
| EFlags : DWORD, | |
| Dr0 : DWORD64, | |
| Dr1 : DWORD64, | |
| Dr2 : DWORD64, | |
| Dr3 : DWORD64, | |
| Dr6 : DWORD64, | |
| Dr7 : DWORD64, | |
| Rax : DWORD64, | |
| Rcx : DWORD64, | |
| Rdx : DWORD64, | |
| Rbx : DWORD64, | |
| Rsp : DWORD64, | |
| Rbp : DWORD64, | |
| Rsi : DWORD64, | |
| Rdi : DWORD64, | |
| R8 : DWORD64, | |
| R9 : DWORD64, | |
| R10 : DWORD64, | |
| R11 : DWORD64, | |
| R12 : DWORD64, | |
| R13 : DWORD64, | |
| R14 : DWORD64, | |
| R15 : DWORD64, | |
| Rip : DWORD64, | |
| u : struct #raw_union { | |
| FltSave : XMM_SAVE_AREA32, | |
| s : struct { | |
| Header : [2]M128A, | |
| Legacy : [8]M128A, | |
| Xmm0 : M128A, | |
| Xmm1 : M128A, | |
| Xmm2 : M128A, | |
| Xmm3 : M128A, | |
| Xmm4 : M128A, | |
| Xmm5 : M128A, | |
| Xmm6 : M128A, | |
| Xmm7 : M128A, | |
| Xmm8 : M128A, | |
| Xmm9 : M128A, | |
| Xmm10 : M128A, | |
| Xmm11 : M128A, | |
| Xmm12 : M128A, | |
| Xmm13 : M128A, | |
| Xmm14 : M128A, | |
| Xmm15 : M128A, | |
| }, | |
| }, | |
| VectorRegister : [26]M128A, | |
| VectorControl : DWORD64, | |
| DebugControl : DWORD64, | |
| LastBranchToRip : DWORD64, | |
| LastBranchFromRip : DWORD64, | |
| LastExceptionToRip : DWORD64, | |
| LastExceptionFromRip : DWORD64, | |
| }; | |
| PCONTEXT :: ^CONTEXT; | |
| RUNTIME_FUNCTION :: _IMAGE_RUNTIME_FUNCTION_ENTRY; | |
| PRUNTIME_FUNCTION :: ^_IMAGE_RUNTIME_FUNCTION_ENTRY; | |
| SCOPE_TABLE :: SCOPE_TABLE_AMD64; | |
| PSCOPE_TABLE :: ^SCOPE_TABLE_AMD64; | |
| UNWIND_HISTORY_TABLE_ENTRY :: struct { | |
| ImageBase : DWORD64, | |
| FunctionEntry : PRUNTIME_FUNCTION, | |
| }; | |
| PUNWIND_HISTORY_TABLE_ENTRY :: ^UNWIND_HISTORY_TABLE_ENTRY; | |
| UNWIND_HISTORY_TABLE :: struct { | |
| Count : DWORD, | |
| LocalHint : BYTE, | |
| GlobalHint : BYTE, | |
| Search : BYTE, | |
| Once : BYTE, | |
| LowAddress : DWORD64, | |
| HighAddress : DWORD64, | |
| Entry : [12]UNWIND_HISTORY_TABLE_ENTRY, | |
| }; | |
| PUNWIND_HISTORY_TABLE :: ^UNWIND_HISTORY_TABLE; | |
| GET_RUNTIME_FUNCTION_CALLBACK :: #type (proc(ControlPc : DWORD64, Context : PVOID) -> PRUNTIME_FUNCTION); | |
| PGET_RUNTIME_FUNCTION_CALLBACK :: ^GET_RUNTIME_FUNCTION_CALLBACK; | |
| OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK :: #type (proc(Process : HANDLE, TableAddress : PVOID, Entries : PDWORD, Functions : ^PRUNTIME_FUNCTION) -> DWORD); | |
| POUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK :: ^OUT_OF_PROCESS_FUNCTION_TABLE_CALLBACK; | |
| DISPATCHER_CONTEXT :: struct { | |
| ControlPc : DWORD64, | |
| ImageBase : DWORD64, | |
| FunctionEntry : PRUNTIME_FUNCTION, | |
| EstablisherFrame : DWORD64, | |
| TargetIp : DWORD64, | |
| ContextRecord : PCONTEXT, | |
| LanguageHandler : PEXCEPTION_ROUTINE, | |
| HandlerData : PVOID, | |
| HistoryTable : PUNWIND_HISTORY_TABLE, | |
| ScopeIndex : DWORD, | |
| Fill0 : DWORD, | |
| }; | |
| PDISPATCHER_CONTEXT :: ^DISPATCHER_CONTEXT; | |
| PEXCEPTION_FILTER :: (proc(ExceptionPointers : ^EXCEPTION_POINTERS, EstablisherFrame : PVOID) -> LONG); | |
| PTERMINATION_HANDLER :: proc(_abnormal_termination : BOOLEAN, EstablisherFrame : PVOID); | |
| KNONVOLATILE_CONTEXT_POINTERS :: struct { | |
| u : struct #raw_union { | |
| FloatingContext : [16]PM128A, | |
| s : struct { | |
| Xmm0 : PM128A, | |
| Xmm1 : PM128A, | |
| Xmm2 : PM128A, | |
| Xmm3 : PM128A, | |
| Xmm4 : PM128A, | |
| Xmm5 : PM128A, | |
| Xmm6 : PM128A, | |
| Xmm7 : PM128A, | |
| Xmm8 : PM128A, | |
| Xmm9 : PM128A, | |
| Xmm10 : PM128A, | |
| Xmm11 : PM128A, | |
| Xmm12 : PM128A, | |
| Xmm13 : PM128A, | |
| Xmm14 : PM128A, | |
| Xmm15 : PM128A, | |
| }, | |
| }, | |
| u2 : struct #raw_union { | |
| IntegerContext : [16]PDWORD64, | |
| s : struct { | |
| Rax : PDWORD64, | |
| Rcx : PDWORD64, | |
| Rdx : PDWORD64, | |
| Rbx : PDWORD64, | |
| Rsp : PDWORD64, | |
| Rbp : PDWORD64, | |
| Rsi : PDWORD64, | |
| Rdi : PDWORD64, | |
| R8 : PDWORD64, | |
| R9 : PDWORD64, | |
| R10 : PDWORD64, | |
| R11 : PDWORD64, | |
| R12 : PDWORD64, | |
| R13 : PDWORD64, | |
| R14 : PDWORD64, | |
| R15 : PDWORD64, | |
| }, | |
| }, | |
| }; | |
| PKNONVOLATILE_CONTEXT_POINTERS :: ^KNONVOLATILE_CONTEXT_POINTERS; | |
| SCOPE_TABLE_ARM :: struct { | |
| Count : DWORD, | |
| ScopeRecord : [1]struct { | |
| BeginAddress : DWORD, | |
| EndAddress : DWORD, | |
| HandlerAddress : DWORD, | |
| JumpTarget : DWORD, | |
| }, | |
| }; | |
| PSCOPE_TABLE_ARM :: ^SCOPE_TABLE_ARM; | |
| SCOPE_TABLE_ARM64 :: struct { | |
| Count : DWORD, | |
| ScopeRecord : [1]struct { | |
| BeginAddress : DWORD, | |
| EndAddress : DWORD, | |
| HandlerAddress : DWORD, | |
| JumpTarget : DWORD, | |
| }, | |
| }; | |
| PSCOPE_TABLE_ARM64 :: ^SCOPE_TABLE_ARM64; | |
| KNONVOLATILE_CONTEXT_POINTERS_ARM64 :: struct { | |
| X19 : PDWORD64, | |
| X20 : PDWORD64, | |
| X21 : PDWORD64, | |
| X22 : PDWORD64, | |
| X23 : PDWORD64, | |
| X24 : PDWORD64, | |
| X25 : PDWORD64, | |
| X26 : PDWORD64, | |
| X27 : PDWORD64, | |
| X28 : PDWORD64, | |
| Fp : PDWORD64, | |
| Lr : PDWORD64, | |
| D8 : PDWORD64, | |
| D9 : PDWORD64, | |
| D10 : PDWORD64, | |
| D11 : PDWORD64, | |
| D12 : PDWORD64, | |
| D13 : PDWORD64, | |
| D14 : PDWORD64, | |
| D15 : PDWORD64, | |
| }; | |
| PKNONVOLATILE_CONTEXT_POINTERS_ARM64 :: ^KNONVOLATILE_CONTEXT_POINTERS_ARM64; | |
| LDT_ENTRY :: struct { | |
| LimitLow : WORD, | |
| BaseLow : WORD, | |
| HighWord : struct #raw_union { | |
| Bytes : struct { | |
| BaseMid : BYTE, | |
| Flags1 : BYTE, | |
| Flags2 : BYTE, | |
| BaseHi : BYTE, | |
| }, | |
| Bits : bit_field { | |
| BaseMid : 8, | |
| Type : 5, | |
| Dpl : 2, | |
| Pres : 1, | |
| LimitHi : 4, | |
| Sys : 1, | |
| Reserved_0 : 1, | |
| Default_Big : 1, | |
| Granularity : 1, | |
| BaseHi : 8, | |
| }, | |
| }, | |
| }; | |
| PLDT_ENTRY :: ^LDT_ENTRY; | |
| WOW64_FLOATING_SAVE_AREA :: struct { | |
| ControlWord : DWORD, | |
| StatusWord : DWORD, | |
| TagWord : DWORD, | |
| ErrorOffset : DWORD, | |
| ErrorSelector : DWORD, | |
| DataOffset : DWORD, | |
| DataSelector : DWORD, | |
| RegisterArea : [80]BYTE, | |
| Cr0NpxState : DWORD, | |
| }; | |
| PWOW64_FLOATING_SAVE_AREA :: ^WOW64_FLOATING_SAVE_AREA; | |
| WOW64_CONTEXT :: struct { | |
| ContextFlags : DWORD, | |
| Dr0 : DWORD, | |
| Dr1 : DWORD, | |
| Dr2 : DWORD, | |
| Dr3 : DWORD, | |
| Dr6 : DWORD, | |
| Dr7 : DWORD, | |
| FloatSave : WOW64_FLOATING_SAVE_AREA, | |
| SegGs : DWORD, | |
| SegFs : DWORD, | |
| SegEs : DWORD, | |
| SegDs : DWORD, | |
| Edi : DWORD, | |
| Esi : DWORD, | |
| Ebx : DWORD, | |
| Edx : DWORD, | |
| Ecx : DWORD, | |
| Eax : DWORD, | |
| Ebp : DWORD, | |
| Eip : DWORD, | |
| SegCs : DWORD, | |
| EFlags : DWORD, | |
| Esp : DWORD, | |
| SegSs : DWORD, | |
| ExtendedRegisters : [512]BYTE, | |
| }; | |
| PWOW64_CONTEXT :: ^WOW64_CONTEXT; | |
| WOW64_LDT_ENTRY :: struct { | |
| LimitLow : WORD, | |
| BaseLow : WORD, | |
| HighWord : struct #raw_union { | |
| Bytes : struct { | |
| BaseMid : BYTE, | |
| Flags1 : BYTE, | |
| Flags2 : BYTE, | |
| BaseHi : BYTE, | |
| }, | |
| Bits : bit_field { | |
| BaseMid : 8, | |
| Type : 5, | |
| Dpl : 2, | |
| Pres : 1, | |
| LimitHi : 4, | |
| Sys : 1, | |
| Reserved_0 : 1, | |
| Default_Big : 1, | |
| Granularity : 1, | |
| BaseHi : 8, | |
| }, | |
| }, | |
| }; | |
| PWOW64_LDT_ENTRY :: ^WOW64_LDT_ENTRY; | |
| WOW64_DESCRIPTOR_TABLE_ENTRY :: struct { | |
| Selector : DWORD, | |
| Descriptor : WOW64_LDT_ENTRY, | |
| }; | |
| PWOW64_DESCRIPTOR_TABLE_ENTRY :: ^WOW64_DESCRIPTOR_TABLE_ENTRY; | |
| EXCEPTION_RECORD :: struct { | |
| ExceptionCode : DWORD, | |
| ExceptionFlags : DWORD, | |
| ExceptionRecord : ^EXCEPTION_RECORD, | |
| ExceptionAddress : PVOID, | |
| NumberParameters : DWORD, | |
| ExceptionInformation : [15]ULONG_PTR, | |
| }; | |
| PEXCEPTION_RECORD :: ^EXCEPTION_RECORD; | |
| EXCEPTION_RECORD32 :: struct { | |
| ExceptionCode : DWORD, | |
| ExceptionFlags : DWORD, | |
| ExceptionRecord : DWORD, | |
| ExceptionAddress : DWORD, | |
| NumberParameters : DWORD, | |
| ExceptionInformation : [15]DWORD, | |
| }; | |
| PEXCEPTION_RECORD32 :: ^EXCEPTION_RECORD32; | |
| EXCEPTION_RECORD64 :: struct { | |
| ExceptionCode : DWORD, | |
| ExceptionFlags : DWORD, | |
| ExceptionRecord : DWORD64, | |
| ExceptionAddress : DWORD64, | |
| NumberParameters : DWORD, | |
| __unusedAlignment : DWORD, | |
| ExceptionInformation : [15]DWORD64, | |
| }; | |
| PEXCEPTION_RECORD64 :: ^EXCEPTION_RECORD64; | |
| EXCEPTION_POINTERS :: struct { | |
| ExceptionRecord : PEXCEPTION_RECORD, | |
| ContextRecord : PCONTEXT, | |
| }; | |
| PEXCEPTION_POINTERS :: ^EXCEPTION_POINTERS; | |
| PACCESS_TOKEN :: PVOID; | |
| PSECURITY_DESCRIPTOR :: PVOID; | |
| PSID :: PVOID; | |
| PCLAIMS_BLOB :: PVOID; | |
| ACCESS_MASK :: DWORD; | |
| PACCESS_MASK :: ^ACCESS_MASK; | |
| GENERIC_MAPPING :: struct { | |
| GenericRead : ACCESS_MASK, | |
| GenericWrite : ACCESS_MASK, | |
| GenericExecute : ACCESS_MASK, | |
| GenericAll : ACCESS_MASK, | |
| }; | |
| PGENERIC_MAPPING :: ^GENERIC_MAPPING; | |
| LUID_AND_ATTRIBUTES :: struct { | |
| Luid : LUID, | |
| Attributes : DWORD, | |
| }; | |
| PLUID_AND_ATTRIBUTES :: ^LUID_AND_ATTRIBUTES; | |
| LUID_AND_ATTRIBUTES_ARRAY :: [1]LUID_AND_ATTRIBUTES; | |
| PLUID_AND_ATTRIBUTES_ARRAY :: ^LUID_AND_ATTRIBUTES_ARRAY; | |
| SID_IDENTIFIER_AUTHORITY :: struct { | |
| Value : [6]BYTE, | |
| }; | |
| PSID_IDENTIFIER_AUTHORITY :: ^SID_IDENTIFIER_AUTHORITY; | |
| SID :: struct { | |
| Revision : BYTE, | |
| SubAuthorityCount : BYTE, | |
| IdentifierAuthority : SID_IDENTIFIER_AUTHORITY, | |
| SubAuthority : [1]DWORD, | |
| }; | |
| PISID :: ^SID; | |
| SE_SID :: struct #raw_union { | |
| Sid : SID, | |
| Buffer : [(size_of(SID) - size_of(DWORD) + ((15) * size_of(DWORD)))]BYTE, | |
| }; | |
| PSE_SID :: ^SE_SID; | |
| /* SID_NAME_USE :: enum { */ | |
| SID_NAME_USE :: _c.int; | |
| SidTypeUser :: 1; | |
| SidTypeGroup :: SidTypeUser + 1; | |
| SidTypeDomain :: SidTypeGroup + 1; | |
| SidTypeAlias :: SidTypeDomain + 1; | |
| SidTypeWellKnownGroup :: SidTypeAlias + 1; | |
| SidTypeDeletedAccount :: SidTypeWellKnownGroup + 1; | |
| SidTypeInvalid :: SidTypeDeletedAccount + 1; | |
| SidTypeUnknown :: SidTypeInvalid + 1; | |
| SidTypeComputer :: SidTypeUnknown + 1; | |
| SidTypeLabel :: SidTypeComputer + 1; | |
| SidTypeLogonSession :: SidTypeLabel + 1; | |
| /* } */ | |
| PSID_NAME_USE :: ^SID_NAME_USE; | |
| SID_AND_ATTRIBUTES :: struct { | |
| Sid : PSID, | |
| Attributes : DWORD, | |
| }; | |
| PSID_AND_ATTRIBUTES :: ^SID_AND_ATTRIBUTES; | |
| SID_AND_ATTRIBUTES_ARRAY :: [1]SID_AND_ATTRIBUTES; | |
| PSID_AND_ATTRIBUTES_ARRAY :: ^SID_AND_ATTRIBUTES_ARRAY; | |
| SID_HASH_ENTRY :: ULONG_PTR; | |
| PSID_HASH_ENTRY :: ^ULONG_PTR; | |
| SID_AND_ATTRIBUTES_HASH :: struct { | |
| SidCount : DWORD, | |
| SidAttr : PSID_AND_ATTRIBUTES, | |
| Hash : [32]SID_HASH_ENTRY, | |
| }; | |
| PSID_AND_ATTRIBUTES_HASH :: ^SID_AND_ATTRIBUTES_HASH; | |
| /* WELL_KNOWN_SID_TYPE :: enum { */ | |
| WELL_KNOWN_SID_TYPE :: _c.int; | |
| WinNullSid :: 0; | |
| WinWorldSid :: 1; | |
| WinLocalSid :: 2; | |
| WinCreatorOwnerSid :: 3; | |
| WinCreatorGroupSid :: 4; | |
| WinCreatorOwnerServerSid :: 5; | |
| WinCreatorGroupServerSid :: 6; | |
| WinNtAuthoritySid :: 7; | |
| WinDialupSid :: 8; | |
| WinNetworkSid :: 9; | |
| WinBatchSid :: 10; | |
| WinInteractiveSid :: 11; | |
| WinServiceSid :: 12; | |
| WinAnonymousSid :: 13; | |
| WinProxySid :: 14; | |
| WinEnterpriseControllersSid :: 15; | |
| WinSelfSid :: 16; | |
| WinAuthenticatedUserSid :: 17; | |
| WinRestrictedCodeSid :: 18; | |
| WinTerminalServerSid :: 19; | |
| WinRemoteLogonIdSid :: 20; | |
| WinLogonIdsSid :: 21; | |
| WinLocalSystemSid :: 22; | |
| WinLocalServiceSid :: 23; | |
| WinNetworkServiceSid :: 24; | |
| WinBuiltinDomainSid :: 25; | |
| WinBuiltinAdministratorsSid :: 26; | |
| WinBuiltinUsersSid :: 27; | |
| WinBuiltinGuestsSid :: 28; | |
| WinBuiltinPowerUsersSid :: 29; | |
| WinBuiltinAccountOperatorsSid :: 30; | |
| WinBuiltinSystemOperatorsSid :: 31; | |
| WinBuiltinPrintOperatorsSid :: 32; | |
| WinBuiltinBackupOperatorsSid :: 33; | |
| WinBuiltinReplicatorSid :: 34; | |
| WinBuiltinPreWindows2000CompatibleAccessSid :: 35; | |
| WinBuiltinRemoteDesktopUsersSid :: 36; | |
| WinBuiltinNetworkConfigurationOperatorsSid :: 37; | |
| WinAccountAdministratorSid :: 38; | |
| WinAccountGuestSid :: 39; | |
| WinAccountKrbtgtSid :: 40; | |
| WinAccountDomainAdminsSid :: 41; | |
| WinAccountDomainUsersSid :: 42; | |
| WinAccountDomainGuestsSid :: 43; | |
| WinAccountComputersSid :: 44; | |
| WinAccountControllersSid :: 45; | |
| WinAccountCertAdminsSid :: 46; | |
| WinAccountSchemaAdminsSid :: 47; | |
| WinAccountEnterpriseAdminsSid :: 48; | |
| WinAccountPolicyAdminsSid :: 49; | |
| WinAccountRasAndIasServersSid :: 50; | |
| WinNTLMAuthenticationSid :: 51; | |
| WinDigestAuthenticationSid :: 52; | |
| WinSChannelAuthenticationSid :: 53; | |
| WinThisOrganizationSid :: 54; | |
| WinOtherOrganizationSid :: 55; | |
| WinBuiltinIncomingForestTrustBuildersSid :: 56; | |
| WinBuiltinPerfMonitoringUsersSid :: 57; | |
| WinBuiltinPerfLoggingUsersSid :: 58; | |
| WinBuiltinAuthorizationAccessSid :: 59; | |
| WinBuiltinTerminalServerLicenseServersSid :: 60; | |
| WinBuiltinDCOMUsersSid :: 61; | |
| WinBuiltinIUsersSid :: 62; | |
| WinIUserSid :: 63; | |
| WinBuiltinCryptoOperatorsSid :: 64; | |
| WinUntrustedLabelSid :: 65; | |
| WinLowLabelSid :: 66; | |
| WinMediumLabelSid :: 67; | |
| WinHighLabelSid :: 68; | |
| WinSystemLabelSid :: 69; | |
| WinWriteRestrictedCodeSid :: 70; | |
| WinCreatorOwnerRightsSid :: 71; | |
| WinCacheablePrincipalsGroupSid :: 72; | |
| WinNonCacheablePrincipalsGroupSid :: 73; | |
| WinEnterpriseReadonlyControllersSid :: 74; | |
| WinAccountReadonlyControllersSid :: 75; | |
| WinBuiltinEventLogReadersGroup :: 76; | |
| WinNewEnterpriseReadonlyControllersSid :: 77; | |
| WinBuiltinCertSvcDComAccessGroup :: 78; | |
| WinMediumPlusLabelSid :: 79; | |
| WinLocalLogonSid :: 80; | |
| WinConsoleLogonSid :: 81; | |
| WinThisOrganizationCertificateSid :: 82; | |
| WinApplicationPackageAuthoritySid :: 83; | |
| WinBuiltinAnyPackageSid :: 84; | |
| WinCapabilityInternetClientSid :: 85; | |
| WinCapabilityInternetClientServerSid :: 86; | |
| WinCapabilityPrivateNetworkClientServerSid :: 87; | |
| WinCapabilityPicturesLibrarySid :: 88; | |
| WinCapabilityVideosLibrarySid :: 89; | |
| WinCapabilityMusicLibrarySid :: 90; | |
| WinCapabilityDocumentsLibrarySid :: 91; | |
| WinCapabilitySharedUserCertificatesSid :: 92; | |
| WinCapabilityEnterpriseAuthenticationSid :: 93; | |
| WinCapabilityRemovableStorageSid :: 94; | |
| WinBuiltinRDSRemoteAccessServersSid :: 95; | |
| WinBuiltinRDSEndpointServersSid :: 96; | |
| WinBuiltinRDSManagementServersSid :: 97; | |
| WinUserModeDriversSid :: 98; | |
| WinBuiltinHyperVAdminsSid :: 99; | |
| WinAccountCloneableControllersSid :: 100; | |
| WinBuiltinAccessControlAssistanceOperatorsSid :: 101; | |
| WinBuiltinRemoteManagementUsersSid :: 102; | |
| WinAuthenticationAuthorityAssertedSid :: 103; | |
| WinAuthenticationServiceAssertedSid :: 104; | |
| WinLocalAccountSid :: 105; | |
| WinLocalAccountAndAdministratorSid :: 106; | |
| WinAccountProtectedUsersSid :: 107; | |
| WinCapabilityAppointmentsSid :: 108; | |
| WinCapabilityContactsSid :: 109; | |
| WinAccountDefaultSystemManagedSid :: 110; | |
| WinBuiltinDefaultSystemManagedGroupSid :: 111; | |
| WinBuiltinStorageReplicaAdminsSid :: 112; | |
| WinAccountKeyAdminsSid :: 113; | |
| WinAccountEnterpriseKeyAdminsSid :: 114; | |
| WinAuthenticationKeyTrustSid :: 115; | |
| WinAuthenticationKeyPropertyMFASid :: 116; | |
| WinAuthenticationKeyPropertyAttestationSid :: 117; | |
| WinAuthenticationFreshKeyAuthSid :: 118; | |
| WinBuiltinDeviceOwnersSid :: 119; | |
| /* } */ | |
| ; | |
| ACL :: struct { | |
| AclRevision : BYTE, | |
| Sbz1 : BYTE, | |
| AclSize : WORD, | |
| AceCount : WORD, | |
| Sbz2 : WORD, | |
| }; | |
| PACL :: ^ACL; | |
| ACE_HEADER :: struct { | |
| AceType : BYTE, | |
| AceFlags : BYTE, | |
| AceSize : WORD, | |
| }; | |
| PACE_HEADER :: ^ACE_HEADER; | |
| ACCESS_ALLOWED_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PACCESS_ALLOWED_ACE :: ^ACCESS_ALLOWED_ACE; | |
| ACCESS_DENIED_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PACCESS_DENIED_ACE :: ^ACCESS_DENIED_ACE; | |
| SYSTEM_AUDIT_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_AUDIT_ACE :: ^SYSTEM_AUDIT_ACE; | |
| SYSTEM_ALARM_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_ALARM_ACE :: ^SYSTEM_ALARM_ACE; | |
| SYSTEM_RESOURCE_ATTRIBUTE_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_RESOURCE_ATTRIBUTE_ACE :: ^SYSTEM_RESOURCE_ATTRIBUTE_ACE; | |
| SYSTEM_SCOPED_POLICY_ID_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_SCOPED_POLICY_ID_ACE :: ^SYSTEM_SCOPED_POLICY_ID_ACE; | |
| SYSTEM_MANDATORY_LABEL_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_MANDATORY_LABEL_ACE :: ^SYSTEM_MANDATORY_LABEL_ACE; | |
| SYSTEM_PROCESS_TRUST_LABEL_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_PROCESS_TRUST_LABEL_ACE :: ^SYSTEM_PROCESS_TRUST_LABEL_ACE; | |
| SYSTEM_ACCESS_FILTER_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_ACCESS_FILTER_ACE :: ^SYSTEM_ACCESS_FILTER_ACE; | |
| ACCESS_ALLOWED_OBJECT_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| Flags : DWORD, | |
| ObjectType : GUID, | |
| InheritedObjectType : GUID, | |
| SidStart : DWORD, | |
| }; | |
| PACCESS_ALLOWED_OBJECT_ACE :: ^ACCESS_ALLOWED_OBJECT_ACE; | |
| ACCESS_DENIED_OBJECT_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| Flags : DWORD, | |
| ObjectType : GUID, | |
| InheritedObjectType : GUID, | |
| SidStart : DWORD, | |
| }; | |
| PACCESS_DENIED_OBJECT_ACE :: ^ACCESS_DENIED_OBJECT_ACE; | |
| SYSTEM_AUDIT_OBJECT_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| Flags : DWORD, | |
| ObjectType : GUID, | |
| InheritedObjectType : GUID, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_AUDIT_OBJECT_ACE :: ^SYSTEM_AUDIT_OBJECT_ACE; | |
| SYSTEM_ALARM_OBJECT_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| Flags : DWORD, | |
| ObjectType : GUID, | |
| InheritedObjectType : GUID, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_ALARM_OBJECT_ACE :: ^SYSTEM_ALARM_OBJECT_ACE; | |
| ACCESS_ALLOWED_CALLBACK_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PACCESS_ALLOWED_CALLBACK_ACE :: ^ACCESS_ALLOWED_CALLBACK_ACE; | |
| ACCESS_DENIED_CALLBACK_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PACCESS_DENIED_CALLBACK_ACE :: ^ACCESS_DENIED_CALLBACK_ACE; | |
| SYSTEM_AUDIT_CALLBACK_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_AUDIT_CALLBACK_ACE :: ^SYSTEM_AUDIT_CALLBACK_ACE; | |
| SYSTEM_ALARM_CALLBACK_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_ALARM_CALLBACK_ACE :: ^SYSTEM_ALARM_CALLBACK_ACE; | |
| ACCESS_ALLOWED_CALLBACK_OBJECT_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| Flags : DWORD, | |
| ObjectType : GUID, | |
| InheritedObjectType : GUID, | |
| SidStart : DWORD, | |
| }; | |
| PACCESS_ALLOWED_CALLBACK_OBJECT_ACE :: ^ACCESS_ALLOWED_CALLBACK_OBJECT_ACE; | |
| ACCESS_DENIED_CALLBACK_OBJECT_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| Flags : DWORD, | |
| ObjectType : GUID, | |
| InheritedObjectType : GUID, | |
| SidStart : DWORD, | |
| }; | |
| PACCESS_DENIED_CALLBACK_OBJECT_ACE :: ^ACCESS_DENIED_CALLBACK_OBJECT_ACE; | |
| SYSTEM_AUDIT_CALLBACK_OBJECT_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| Flags : DWORD, | |
| ObjectType : GUID, | |
| InheritedObjectType : GUID, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_AUDIT_CALLBACK_OBJECT_ACE :: ^SYSTEM_AUDIT_CALLBACK_OBJECT_ACE; | |
| SYSTEM_ALARM_CALLBACK_OBJECT_ACE :: struct { | |
| Header : ACE_HEADER, | |
| Mask : ACCESS_MASK, | |
| Flags : DWORD, | |
| ObjectType : GUID, | |
| InheritedObjectType : GUID, | |
| SidStart : DWORD, | |
| }; | |
| PSYSTEM_ALARM_CALLBACK_OBJECT_ACE :: ^SYSTEM_ALARM_CALLBACK_OBJECT_ACE; | |
| /* ACL_INFORMATION_CLASS :: enum { */ | |
| ACL_INFORMATION_CLASS :: _c.int; | |
| AclRevisionInformation :: 1; | |
| AclSizeInformation :: AclRevisionInformation + 1; | |
| /* } */ | |
| ; | |
| ACL_REVISION_INFORMATION :: struct { | |
| AclRevision : DWORD, | |
| }; | |
| PACL_REVISION_INFORMATION :: ^ACL_REVISION_INFORMATION; | |
| ACL_SIZE_INFORMATION :: struct { | |
| AceCount : DWORD, | |
| AclBytesInUse : DWORD, | |
| AclBytesFree : DWORD, | |
| }; | |
| PACL_SIZE_INFORMATION :: ^ACL_SIZE_INFORMATION; | |
| SECURITY_DESCRIPTOR_CONTROL :: WORD; | |
| PSECURITY_DESCRIPTOR_CONTROL :: ^WORD; | |
| SECURITY_DESCRIPTOR_RELATIVE :: struct { | |
| Revision : BYTE, | |
| Sbz1 : BYTE, | |
| Control : SECURITY_DESCRIPTOR_CONTROL, | |
| Owner : DWORD, | |
| Group : DWORD, | |
| Sacl : DWORD, | |
| Dacl : DWORD, | |
| }; | |
| PISECURITY_DESCRIPTOR_RELATIVE :: ^SECURITY_DESCRIPTOR_RELATIVE; | |
| SECURITY_DESCRIPTOR :: struct { | |
| Revision : BYTE, | |
| Sbz1 : BYTE, | |
| Control : SECURITY_DESCRIPTOR_CONTROL, | |
| Owner : PSID, | |
| Group : PSID, | |
| Sacl : PACL, | |
| Dacl : PACL, | |
| }; | |
| PISECURITY_DESCRIPTOR :: ^SECURITY_DESCRIPTOR; | |
| SECURITY_OBJECT_AI_PARAMS :: struct { | |
| Size : DWORD, | |
| ConstraintMask : DWORD, | |
| }; | |
| PSECURITY_OBJECT_AI_PARAMS :: ^SECURITY_OBJECT_AI_PARAMS; | |
| OBJECT_TYPE_LIST :: struct { | |
| Level : WORD, | |
| Sbz : WORD, | |
| ObjectType : ^GUID, | |
| }; | |
| POBJECT_TYPE_LIST :: ^OBJECT_TYPE_LIST; | |
| /* AUDIT_EVENT_TYPE :: enum { */ | |
| AUDIT_EVENT_TYPE :: _c.int; | |
| AuditEventObjectAccess :: 0; | |
| AuditEventDirectoryServiceAccess :: AuditEventObjectAccess + 1; | |
| /* } */ | |
| PAUDIT_EVENT_TYPE :: ^AUDIT_EVENT_TYPE; | |
| PRIVILEGE_SET :: struct { | |
| PrivilegeCount : DWORD, | |
| Control : DWORD, | |
| Privilege : [1]LUID_AND_ATTRIBUTES, | |
| }; | |
| PPRIVILEGE_SET :: ^PRIVILEGE_SET; | |
| /* ACCESS_REASON_TYPE :: enum { */ | |
| ACCESS_REASON_TYPE :: _c.int; | |
| AccessReasonNone :: 0x00000000; | |
| AccessReasonAllowedAce :: 0x00010000; | |
| AccessReasonDeniedAce :: 0x00020000; | |
| AccessReasonAllowedParentAce :: 0x00030000; | |
| AccessReasonDeniedParentAce :: 0x00040000; | |
| AccessReasonNotGrantedByCape :: 0x00050000; | |
| AccessReasonNotGrantedByParentCape :: 0x00060000; | |
| AccessReasonNotGrantedToAppContainer :: 0x00070000; | |
| AccessReasonMissingPrivilege :: 0x00100000; | |
| AccessReasonFromPrivilege :: 0x00200000; | |
| AccessReasonIntegrityLevel :: 0x00300000; | |
| AccessReasonOwnership :: 0x00400000; | |
| AccessReasonNullDacl :: 0x00500000; | |
| AccessReasonEmptyDacl :: 0x00600000; | |
| AccessReasonNoSD :: 0x00700000; | |
| AccessReasonNoGrant :: 0x00800000; | |
| AccessReasonTrustLabel :: 0x00900000; | |
| AccessReasonFilterAce :: 0x00a00000; | |
| /* } */ | |
| ; | |
| ACCESS_REASON :: DWORD; | |
| ACCESS_REASONS :: struct { | |
| Data : [32]ACCESS_REASON, | |
| }; | |
| PACCESS_REASONS :: ^ACCESS_REASONS; | |
| SE_SECURITY_DESCRIPTOR :: struct { | |
| Size : DWORD, | |
| Flags : DWORD, | |
| SecurityDescriptor : PSECURITY_DESCRIPTOR, | |
| }; | |
| PSE_SECURITY_DESCRIPTOR :: ^SE_SECURITY_DESCRIPTOR; | |
| SE_ACCESS_REQUEST :: struct { | |
| Size : DWORD, | |
| SeSecurityDescriptor : PSE_SECURITY_DESCRIPTOR, | |
| DesiredAccess : ACCESS_MASK, | |
| PreviouslyGrantedAccess : ACCESS_MASK, | |
| PrincipalSelfSid : PSID, | |
| GenericMapping : PGENERIC_MAPPING, | |
| ObjectTypeListCount : DWORD, | |
| ObjectTypeList : POBJECT_TYPE_LIST, | |
| }; | |
| PSE_ACCESS_REQUEST :: ^SE_ACCESS_REQUEST; | |
| SE_ACCESS_REPLY :: struct { | |
| Size : DWORD, | |
| ResultListCount : DWORD, | |
| GrantedAccess : PACCESS_MASK, | |
| AccessStatus : PDWORD, | |
| AccessReason : PACCESS_REASONS, | |
| Privileges : ^PPRIVILEGE_SET, | |
| }; | |
| PSE_ACCESS_REPLY :: ^SE_ACCESS_REPLY; | |
| /* SECURITY_IMPERSONATION_LEVEL :: enum { */ | |
| SECURITY_IMPERSONATION_LEVEL :: _c.int; | |
| SecurityAnonymous :: 0; | |
| SecurityIdentification :: SecurityAnonymous + 1; | |
| SecurityImpersonation :: SecurityIdentification + 1; | |
| SecurityDelegation :: SecurityImpersonation + 1; | |
| /* } */ | |
| PSECURITY_IMPERSONATION_LEVEL :: ^SECURITY_IMPERSONATION_LEVEL; | |
| /* TOKEN_TYPE :: enum { */ | |
| TOKEN_TYPE :: _c.int; | |
| TokenPrimary :: 1; | |
| TokenImpersonation :: TokenPrimary + 1; | |
| /* } */ | |
| ; | |
| PTOKEN_TYPE :: ^TOKEN_TYPE; | |
| /* TOKEN_ELEVATION_TYPE :: enum { */ | |
| TOKEN_ELEVATION_TYPE :: _c.int; | |
| TokenElevationTypeDefault :: 1; | |
| TokenElevationTypeFull :: TokenElevationTypeDefault + 1; | |
| TokenElevationTypeLimited :: TokenElevationTypeFull + 1; | |
| /* } */ | |
| PTOKEN_ELEVATION_TYPE :: ^TOKEN_ELEVATION_TYPE; | |
| /* TOKEN_INFORMATION_CLASS :: enum { */ | |
| TOKEN_INFORMATION_CLASS :: _c.int; | |
| TokenUser :: 1; | |
| TokenGroups :: TokenUser + 1; | |
| TokenPrivileges :: TokenGroups + 1; | |
| TokenOwner :: TokenPrivileges + 1; | |
| TokenPrimaryGroup :: TokenOwner + 1; | |
| TokenDefaultDacl :: TokenPrimaryGroup + 1; | |
| TokenSource :: TokenDefaultDacl + 1; | |
| TokenType :: TokenSource + 1; | |
| TokenImpersonationLevel :: TokenType + 1; | |
| TokenStatistics :: TokenImpersonationLevel + 1; | |
| TokenRestrictedSids :: TokenStatistics + 1; | |
| TokenSessionId :: TokenRestrictedSids + 1; | |
| TokenGroupsAndPrivileges :: TokenSessionId + 1; | |
| TokenSessionReference :: TokenGroupsAndPrivileges + 1; | |
| TokenSandBoxInert :: TokenSessionReference + 1; | |
| TokenAuditPolicy :: TokenSandBoxInert + 1; | |
| TokenOrigin :: TokenAuditPolicy + 1; | |
| TokenElevationType :: TokenOrigin + 1; | |
| TokenLinkedToken :: TokenElevationType + 1; | |
| TokenElevation :: TokenLinkedToken + 1; | |
| TokenHasRestrictions :: TokenElevation + 1; | |
| TokenAccessInformation :: TokenHasRestrictions + 1; | |
| TokenVirtualizationAllowed :: TokenAccessInformation + 1; | |
| TokenVirtualizationEnabled :: TokenVirtualizationAllowed + 1; | |
| TokenIntegrityLevel :: TokenVirtualizationEnabled + 1; | |
| TokenUIAccess :: TokenIntegrityLevel + 1; | |
| TokenMandatoryPolicy :: TokenUIAccess + 1; | |
| TokenLogonSid :: TokenMandatoryPolicy + 1; | |
| TokenIsAppContainer :: TokenLogonSid + 1; | |
| TokenCapabilities :: TokenIsAppContainer + 1; | |
| TokenAppContainerSid :: TokenCapabilities + 1; | |
| TokenAppContainerNumber :: TokenAppContainerSid + 1; | |
| TokenUserClaimAttributes :: TokenAppContainerNumber + 1; | |
| TokenDeviceClaimAttributes :: TokenUserClaimAttributes + 1; | |
| TokenRestrictedUserClaimAttributes :: TokenDeviceClaimAttributes + 1; | |
| TokenRestrictedDeviceClaimAttributes :: TokenRestrictedUserClaimAttributes + 1; | |
| TokenDeviceGroups :: TokenRestrictedDeviceClaimAttributes + 1; | |
| TokenRestrictedDeviceGroups :: TokenDeviceGroups + 1; | |
| TokenSecurityAttributes :: TokenRestrictedDeviceGroups + 1; | |
| TokenIsRestricted :: TokenSecurityAttributes + 1; | |
| TokenProcessTrustLevel :: TokenIsRestricted + 1; | |
| TokenPrivateNameSpace :: TokenProcessTrustLevel + 1; | |
| TokenSingletonAttributes :: TokenPrivateNameSpace + 1; | |
| TokenBnoIsolation :: TokenSingletonAttributes + 1; | |
| TokenChildProcessFlags :: TokenBnoIsolation + 1; | |
| TokenIsLessPrivilegedAppContainer :: TokenChildProcessFlags + 1; | |
| TokenIsSandboxed :: TokenIsLessPrivilegedAppContainer + 1; | |
| TokenOriginatingProcessTrustLevel :: TokenIsSandboxed + 1; | |
| MaxTokenInfoClass :: TokenOriginatingProcessTrustLevel + 1; | |
| /* } */ | |
| PTOKEN_INFORMATION_CLASS :: ^TOKEN_INFORMATION_CLASS; | |
| TOKEN_USER :: struct { | |
| User : SID_AND_ATTRIBUTES, | |
| }; | |
| PTOKEN_USER :: ^TOKEN_USER; | |
| SE_TOKEN_USER :: struct { | |
| u : struct #raw_union { | |
| TokenUser : TOKEN_USER, | |
| User : SID_AND_ATTRIBUTES, | |
| }, | |
| u2 : struct #raw_union { | |
| Sid : SID, | |
| Buffer : [(size_of(SID) - size_of(DWORD) + ((15) * size_of(DWORD)))]BYTE, | |
| }, | |
| }; | |
| PSE_TOKEN_USER :: struct { | |
| u : struct #raw_union { | |
| TokenUser : TOKEN_USER, | |
| User : SID_AND_ATTRIBUTES, | |
| }, | |
| u2 : struct #raw_union { | |
| Sid : SID, | |
| Buffer : [(size_of(SID) - size_of(DWORD) + ((15) * size_of(DWORD)))]BYTE, | |
| }, | |
| }; | |
| TOKEN_GROUPS :: struct { | |
| GroupCount : DWORD, | |
| Groups : [1]SID_AND_ATTRIBUTES, | |
| }; | |
| PTOKEN_GROUPS :: ^TOKEN_GROUPS; | |
| TOKEN_PRIVILEGES :: struct { | |
| PrivilegeCount : DWORD, | |
| Privileges : [1]LUID_AND_ATTRIBUTES, | |
| }; | |
| PTOKEN_PRIVILEGES :: ^TOKEN_PRIVILEGES; | |
| TOKEN_OWNER :: struct { | |
| Owner : PSID, | |
| }; | |
| PTOKEN_OWNER :: ^TOKEN_OWNER; | |
| TOKEN_PRIMARY_GROUP :: struct { | |
| PrimaryGroup : PSID, | |
| }; | |
| PTOKEN_PRIMARY_GROUP :: ^TOKEN_PRIMARY_GROUP; | |
| TOKEN_DEFAULT_DACL :: struct { | |
| DefaultDacl : PACL, | |
| }; | |
| PTOKEN_DEFAULT_DACL :: ^TOKEN_DEFAULT_DACL; | |
| TOKEN_USER_CLAIMS :: struct { | |
| UserClaims : PCLAIMS_BLOB, | |
| }; | |
| PTOKEN_USER_CLAIMS :: ^TOKEN_USER_CLAIMS; | |
| TOKEN_DEVICE_CLAIMS :: struct { | |
| DeviceClaims : PCLAIMS_BLOB, | |
| }; | |
| PTOKEN_DEVICE_CLAIMS :: ^TOKEN_DEVICE_CLAIMS; | |
| TOKEN_GROUPS_AND_PRIVILEGES :: struct { | |
| 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, | |
| }; | |
| PTOKEN_GROUPS_AND_PRIVILEGES :: ^TOKEN_GROUPS_AND_PRIVILEGES; | |
| TOKEN_LINKED_TOKEN :: struct { | |
| LinkedToken : HANDLE, | |
| }; | |
| PTOKEN_LINKED_TOKEN :: ^TOKEN_LINKED_TOKEN; | |
| TOKEN_ELEVATION :: struct { | |
| TokenIsElevated : DWORD, | |
| }; | |
| PTOKEN_ELEVATION :: ^TOKEN_ELEVATION; | |
| TOKEN_MANDATORY_LABEL :: struct { | |
| Label : SID_AND_ATTRIBUTES, | |
| }; | |
| PTOKEN_MANDATORY_LABEL :: ^TOKEN_MANDATORY_LABEL; | |
| TOKEN_MANDATORY_POLICY :: struct { | |
| Policy : DWORD, | |
| }; | |
| PTOKEN_MANDATORY_POLICY :: ^TOKEN_MANDATORY_POLICY; | |
| PSECURITY_ATTRIBUTES_OPAQUE :: PVOID; | |
| TOKEN_ACCESS_INFORMATION :: struct { | |
| 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 :: ^TOKEN_ACCESS_INFORMATION; | |
| TOKEN_AUDIT_POLICY :: struct { | |
| PerUserPolicy : [(((59)) >> 1) + 1]BYTE, | |
| }; | |
| PTOKEN_AUDIT_POLICY :: ^TOKEN_AUDIT_POLICY; | |
| TOKEN_SOURCE :: struct { | |
| SourceName : [8]CHAR, | |
| SourceIdentifier : LUID, | |
| }; | |
| PTOKEN_SOURCE :: ^TOKEN_SOURCE; | |
| TOKEN_STATISTICS :: struct { | |
| 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 :: ^TOKEN_STATISTICS; | |
| TOKEN_CONTROL :: struct { | |
| TokenId : LUID, | |
| AuthenticationId : LUID, | |
| ModifiedId : LUID, | |
| TokenSource : TOKEN_SOURCE, | |
| }; | |
| PTOKEN_CONTROL :: ^TOKEN_CONTROL; | |
| TOKEN_ORIGIN :: struct { | |
| OriginatingLogonSession : LUID, | |
| }; | |
| PTOKEN_ORIGIN :: ^TOKEN_ORIGIN; | |
| /* MANDATORY_LEVEL :: enum { */ | |
| MANDATORY_LEVEL :: _c.int; | |
| MandatoryLevelUntrusted :: 0; | |
| MandatoryLevelLow :: MandatoryLevelUntrusted + 1; | |
| MandatoryLevelMedium :: MandatoryLevelLow + 1; | |
| MandatoryLevelHigh :: MandatoryLevelMedium + 1; | |
| MandatoryLevelSystem :: MandatoryLevelHigh + 1; | |
| MandatoryLevelSecureProcess :: MandatoryLevelSystem + 1; | |
| MandatoryLevelCount :: MandatoryLevelSecureProcess + 1; | |
| /* } */ | |
| PMANDATORY_LEVEL :: ^MANDATORY_LEVEL; | |
| TOKEN_APPCONTAINER_INFORMATION :: struct { | |
| TokenAppContainer : PSID, | |
| }; | |
| PTOKEN_APPCONTAINER_INFORMATION :: ^TOKEN_APPCONTAINER_INFORMATION; | |
| TOKEN_SID_INFORMATION :: struct { | |
| Sid : PSID, | |
| }; | |
| PTOKEN_SID_INFORMATION :: ^TOKEN_SID_INFORMATION; | |
| TOKEN_BNO_ISOLATION_INFORMATION :: struct { | |
| IsolationPrefix : PWSTR, | |
| IsolationEnabled : BOOLEAN, | |
| }; | |
| PTOKEN_BNO_ISOLATION_INFORMATION :: ^TOKEN_BNO_ISOLATION_INFORMATION; | |
| CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE :: struct { | |
| Version : DWORD64, | |
| Name : PWSTR, | |
| }; | |
| PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE :: ^CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE; | |
| CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE :: struct { | |
| pValue : PVOID, | |
| ValueLength : DWORD, | |
| }; | |
| PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE :: ^CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE; | |
| CLAIM_SECURITY_ATTRIBUTE_V1 :: struct { | |
| Name : PWSTR, | |
| ValueType : WORD, | |
| Reserved : WORD, | |
| Flags : DWORD, | |
| ValueCount : DWORD, | |
| Values : struct #raw_union { | |
| pInt64 : PLONG64, | |
| pUint64 : PDWORD64, | |
| ppString : ^PWSTR, | |
| pFqbn : PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE, | |
| pOctetString : PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE, | |
| }, | |
| }; | |
| PCLAIM_SECURITY_ATTRIBUTE_V1 :: ^CLAIM_SECURITY_ATTRIBUTE_V1; | |
| CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 :: struct { | |
| Name : DWORD, | |
| ValueType : WORD, | |
| Reserved : WORD, | |
| Flags : DWORD, | |
| ValueCount : DWORD, | |
| Values : struct #raw_union { | |
| pInt64 : [1]DWORD, | |
| pUint64 : [1]DWORD, | |
| ppString : [1]DWORD, | |
| pFqbn : [1]DWORD, | |
| pOctetString : [1]DWORD, | |
| }, | |
| }; | |
| PCLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 :: ^CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1; | |
| CLAIM_SECURITY_ATTRIBUTES_INFORMATION :: struct { | |
| Version : WORD, | |
| Reserved : WORD, | |
| AttributeCount : DWORD, | |
| Attribute : struct #raw_union { | |
| pAttributeV1 : PCLAIM_SECURITY_ATTRIBUTE_V1, | |
| }, | |
| }; | |
| PCLAIM_SECURITY_ATTRIBUTES_INFORMATION :: ^CLAIM_SECURITY_ATTRIBUTES_INFORMATION; | |
| SECURITY_CONTEXT_TRACKING_MODE :: BOOLEAN; | |
| PSECURITY_CONTEXT_TRACKING_MODE :: ^BOOLEAN; | |
| SECURITY_QUALITY_OF_SERVICE :: struct { | |
| Length : DWORD, | |
| ImpersonationLevel : SECURITY_IMPERSONATION_LEVEL, | |
| ContextTrackingMode : SECURITY_CONTEXT_TRACKING_MODE, | |
| EffectiveOnly : BOOLEAN, | |
| }; | |
| PSECURITY_QUALITY_OF_SERVICE :: ^SECURITY_QUALITY_OF_SERVICE; | |
| SE_IMPERSONATION_STATE :: struct { | |
| Token : PACCESS_TOKEN, | |
| CopyOnOpen : BOOLEAN, | |
| EffectiveOnly : BOOLEAN, | |
| Level : SECURITY_IMPERSONATION_LEVEL, | |
| }; | |
| PSE_IMPERSONATION_STATE :: ^SE_IMPERSONATION_STATE; | |
| SECURITY_INFORMATION :: DWORD; | |
| PSECURITY_INFORMATION :: ^DWORD; | |
| SE_SIGNING_LEVEL :: BYTE; | |
| PSE_SIGNING_LEVEL :: ^BYTE; | |
| /* SE_IMAGE_SIGNATURE_TYPE :: enum { */ | |
| SE_IMAGE_SIGNATURE_TYPE :: _c.int; | |
| SeImageSignatureNone :: 0; | |
| SeImageSignatureEmbedded :: SeImageSignatureNone + 1; | |
| SeImageSignatureCache :: SeImageSignatureEmbedded + 1; | |
| SeImageSignatureCatalogCached :: SeImageSignatureCache + 1; | |
| SeImageSignatureCatalogNotCached :: SeImageSignatureCatalogCached + 1; | |
| SeImageSignatureCatalogHint :: SeImageSignatureCatalogNotCached + 1; | |
| SeImageSignaturePackageCatalog :: SeImageSignatureCatalogHint + 1; | |
| /* } */ | |
| PSE_IMAGE_SIGNATURE_TYPE :: ^SE_IMAGE_SIGNATURE_TYPE; | |
| /* SE_LEARNING_MODE_DATA_TYPE :: enum { */ | |
| SE_LEARNING_MODE_DATA_TYPE :: _c.int; | |
| SeLearningModeInvalidType :: 0; | |
| SeLearningModeSettings :: SeLearningModeInvalidType + 1; | |
| SeLearningModeMax :: SeLearningModeSettings + 1; | |
| /* } */ | |
| ; | |
| SECURITY_CAPABILITIES :: struct { | |
| AppContainerSid : PSID, | |
| Capabilities : PSID_AND_ATTRIBUTES, | |
| CapabilityCount : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PSECURITY_CAPABILITIES :: ^SECURITY_CAPABILITIES; | |
| LPSECURITY_CAPABILITIES :: ^SECURITY_CAPABILITIES; | |
| JOB_SET_ARRAY :: struct { | |
| JobHandle : HANDLE, | |
| MemberLevel : DWORD, | |
| Flags : DWORD, | |
| }; | |
| PJOB_SET_ARRAY :: ^JOB_SET_ARRAY; | |
| EXCEPTION_REGISTRATION_RECORD :: struct { | |
| Next : ^EXCEPTION_REGISTRATION_RECORD, | |
| Handler : PEXCEPTION_ROUTINE, | |
| }; | |
| PEXCEPTION_REGISTRATION_RECORD :: ^EXCEPTION_REGISTRATION_RECORD; | |
| NT_TIB :: struct { | |
| ExceptionList : ^EXCEPTION_REGISTRATION_RECORD, | |
| StackBase : PVOID, | |
| StackLimit : PVOID, | |
| SubSystemTib : PVOID, | |
| FiberData : PVOID, | |
| ArbitraryUserPointer : PVOID, | |
| Self : ^NT_TIB, | |
| }; | |
| PNT_TIB :: ^NT_TIB; | |
| NT_TIB32 :: struct { | |
| ExceptionList : DWORD, | |
| StackBase : DWORD, | |
| StackLimit : DWORD, | |
| SubSystemTib : DWORD, | |
| FiberData : DWORD, | |
| ArbitraryUserPointer : DWORD, | |
| Self : DWORD, | |
| }; | |
| PNT_TIB32 :: ^NT_TIB32; | |
| NT_TIB64 :: struct { | |
| ExceptionList : DWORD64, | |
| StackBase : DWORD64, | |
| StackLimit : DWORD64, | |
| SubSystemTib : DWORD64, | |
| FiberData : DWORD64, | |
| ArbitraryUserPointer : DWORD64, | |
| Self : DWORD64, | |
| }; | |
| PNT_TIB64 :: ^NT_TIB64; | |
| UMS_CREATE_THREAD_ATTRIBUTES :: struct { | |
| UmsVersion : DWORD, | |
| UmsContext : PVOID, | |
| UmsCompletionList : PVOID, | |
| }; | |
| PUMS_CREATE_THREAD_ATTRIBUTES :: ^UMS_CREATE_THREAD_ATTRIBUTES; | |
| WOW64_ARCHITECTURE_INFORMATION :: bit_field { | |
| Machine : 16, | |
| KernelMode : 1, | |
| UserMode : 1, | |
| Native : 1, | |
| Process : 1, | |
| ReservedZero0 : 12, | |
| }; | |
| QUOTA_LIMITS :: struct { | |
| PagedPoolLimit : SIZE_T, | |
| NonPagedPoolLimit : SIZE_T, | |
| MinimumWorkingSetSize : SIZE_T, | |
| MaximumWorkingSetSize : SIZE_T, | |
| PagefileLimit : SIZE_T, | |
| TimeLimit : LARGE_INTEGER, | |
| }; | |
| PQUOTA_LIMITS :: ^QUOTA_LIMITS; | |
| RATE_QUOTA_LIMIT :: struct #raw_union { | |
| RateData : DWORD, | |
| s : bit_field { | |
| RatePercent : 7, | |
| Reserved0 : 25, | |
| }, | |
| }; | |
| PRATE_QUOTA_LIMIT :: ^RATE_QUOTA_LIMIT; | |
| QUOTA_LIMITS_EX :: struct { | |
| PagedPoolLimit : SIZE_T, | |
| NonPagedPoolLimit : SIZE_T, | |
| MinimumWorkingSetSize : SIZE_T, | |
| MaximumWorkingSetSize : SIZE_T, | |
| PagefileLimit : SIZE_T, | |
| TimeLimit : LARGE_INTEGER, | |
| WorkingSetLimit : SIZE_T, | |
| Reserved2 : SIZE_T, | |
| Reserved3 : SIZE_T, | |
| Reserved4 : SIZE_T, | |
| Flags : DWORD, | |
| CpuRateLimit : RATE_QUOTA_LIMIT, | |
| }; | |
| PQUOTA_LIMITS_EX :: ^QUOTA_LIMITS_EX; | |
| IO_COUNTERS :: struct { | |
| ReadOperationCount : ULONGLONG, | |
| WriteOperationCount : ULONGLONG, | |
| OtherOperationCount : ULONGLONG, | |
| ReadTransferCount : ULONGLONG, | |
| WriteTransferCount : ULONGLONG, | |
| OtherTransferCount : ULONGLONG, | |
| }; | |
| PIO_COUNTERS :: ^IO_COUNTERS; | |
| /* HARDWARE_COUNTER_TYPE :: enum { */ | |
| HARDWARE_COUNTER_TYPE :: _c.int; | |
| PMCCounter :: 0; | |
| MaxHardwareCounterType :: PMCCounter + 1; | |
| /* } */ | |
| PHARDWARE_COUNTER_TYPE :: ^HARDWARE_COUNTER_TYPE; | |
| /* PROCESS_MITIGATION_POLICY :: enum { */ | |
| PROCESS_MITIGATION_POLICY :: _c.int; | |
| ProcessDEPPolicy :: 0; | |
| ProcessASLRPolicy :: ProcessDEPPolicy + 1; | |
| ProcessDynamicCodePolicy :: ProcessASLRPolicy + 1; | |
| ProcessStrictHandleCheckPolicy :: ProcessDynamicCodePolicy + 1; | |
| ProcessSystemCallDisablePolicy :: ProcessStrictHandleCheckPolicy + 1; | |
| ProcessMitigationOptionsMask :: ProcessSystemCallDisablePolicy + 1; | |
| ProcessExtensionPointDisablePolicy :: ProcessMitigationOptionsMask + 1; | |
| ProcessControlFlowGuardPolicy :: ProcessExtensionPointDisablePolicy + 1; | |
| ProcessSignaturePolicy :: ProcessControlFlowGuardPolicy + 1; | |
| ProcessFontDisablePolicy :: ProcessSignaturePolicy + 1; | |
| ProcessImageLoadPolicy :: ProcessFontDisablePolicy + 1; | |
| ProcessSystemCallFilterPolicy :: ProcessImageLoadPolicy + 1; | |
| ProcessPayloadRestrictionPolicy :: ProcessSystemCallFilterPolicy + 1; | |
| ProcessChildProcessPolicy :: ProcessPayloadRestrictionPolicy + 1; | |
| ProcessSideChannelIsolationPolicy :: ProcessChildProcessPolicy + 1; | |
| MaxProcessMitigationPolicy :: ProcessSideChannelIsolationPolicy + 1; | |
| /* } */ | |
| PPROCESS_MITIGATION_POLICY :: ^PROCESS_MITIGATION_POLICY; | |
| PROCESS_MITIGATION_ASLR_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| EnableBottomUpRandomization : 1, | |
| EnableForceRelocateImages : 1, | |
| EnableHighEntropy : 1, | |
| DisallowStrippedImages : 1, | |
| ReservedFlags : 28, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_ASLR_POLICY :: ^PROCESS_MITIGATION_ASLR_POLICY; | |
| PROCESS_MITIGATION_DEP_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| Enable : 1, | |
| DisableAtlThunkEmulation : 1, | |
| ReservedFlags : 30, | |
| }, | |
| }, | |
| Permanent : BOOLEAN, | |
| }; | |
| PPROCESS_MITIGATION_DEP_POLICY :: ^PROCESS_MITIGATION_DEP_POLICY; | |
| PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| RaiseExceptionOnInvalidHandleReference : 1, | |
| HandleExceptionsPermanentlyEnabled : 1, | |
| ReservedFlags : 30, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY :: ^PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY; | |
| PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| DisallowWin32kSystemCalls : 1, | |
| AuditDisallowWin32kSystemCalls : 1, | |
| ReservedFlags : 30, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY :: ^PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY; | |
| PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| DisableExtensionPoints : 1, | |
| ReservedFlags : 31, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY :: ^PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY; | |
| PROCESS_MITIGATION_DYNAMIC_CODE_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| ProhibitDynamicCode : 1, | |
| AllowThreadOptOut : 1, | |
| AllowRemoteDowngrade : 1, | |
| AuditProhibitDynamicCode : 1, | |
| ReservedFlags : 28, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_DYNAMIC_CODE_POLICY :: ^PROCESS_MITIGATION_DYNAMIC_CODE_POLICY; | |
| PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| EnableControlFlowGuard : 1, | |
| EnableExportSuppression : 1, | |
| StrictMode : 1, | |
| ReservedFlags : 29, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY :: ^PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY; | |
| PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| MicrosoftSignedOnly : 1, | |
| StoreSignedOnly : 1, | |
| MitigationOptIn : 1, | |
| AuditMicrosoftSignedOnly : 1, | |
| AuditStoreSignedOnly : 1, | |
| ReservedFlags : 27, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_BINARY_SIGNATURE_POLICY :: ^PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY; | |
| PROCESS_MITIGATION_FONT_DISABLE_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| DisableNonSystemFonts : 1, | |
| AuditNonSystemFontLoading : 1, | |
| ReservedFlags : 30, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_FONT_DISABLE_POLICY :: ^PROCESS_MITIGATION_FONT_DISABLE_POLICY; | |
| PROCESS_MITIGATION_IMAGE_LOAD_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| NoRemoteImages : 1, | |
| NoLowMandatoryLabelImages : 1, | |
| PreferSystem32Images : 1, | |
| AuditNoRemoteImages : 1, | |
| AuditNoLowMandatoryLabelImages : 1, | |
| ReservedFlags : 27, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_IMAGE_LOAD_POLICY :: ^PROCESS_MITIGATION_IMAGE_LOAD_POLICY; | |
| PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| FilterId : 4, | |
| ReservedFlags : 28, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY :: ^PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY; | |
| PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| EnableExportAddressFilter : 1, | |
| AuditExportAddressFilter : 1, | |
| EnableExportAddressFilterPlus : 1, | |
| AuditExportAddressFilterPlus : 1, | |
| EnableImportAddressFilter : 1, | |
| AuditImportAddressFilter : 1, | |
| EnableRopStackPivot : 1, | |
| AuditRopStackPivot : 1, | |
| EnableRopCallerCheck : 1, | |
| AuditRopCallerCheck : 1, | |
| EnableRopSimExec : 1, | |
| AuditRopSimExec : 1, | |
| ReservedFlags : 20, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY :: ^PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY; | |
| PROCESS_MITIGATION_CHILD_PROCESS_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| NoChildProcessCreation : 1, | |
| AuditNoChildProcessCreation : 1, | |
| AllowSecureProcessCreation : 1, | |
| ReservedFlags : 29, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_CHILD_PROCESS_POLICY :: ^PROCESS_MITIGATION_CHILD_PROCESS_POLICY; | |
| PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY :: struct { | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| SmtBranchTargetIsolation : 1, | |
| IsolateSecurityDomain : 1, | |
| DisablePageCombine : 1, | |
| SpeculativeStoreBypassDisable : 1, | |
| ReservedFlags : 28, | |
| }, | |
| }, | |
| }; | |
| PPROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY :: ^PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY; | |
| JOBOBJECT_BASIC_ACCOUNTING_INFORMATION :: struct { | |
| TotalUserTime : LARGE_INTEGER, | |
| TotalKernelTime : LARGE_INTEGER, | |
| ThisPeriodTotalUserTime : LARGE_INTEGER, | |
| ThisPeriodTotalKernelTime : LARGE_INTEGER, | |
| TotalPageFaultCount : DWORD, | |
| TotalProcesses : DWORD, | |
| ActiveProcesses : DWORD, | |
| TotalTerminatedProcesses : DWORD, | |
| }; | |
| PJOBOBJECT_BASIC_ACCOUNTING_INFORMATION :: ^JOBOBJECT_BASIC_ACCOUNTING_INFORMATION; | |
| JOBOBJECT_BASIC_LIMIT_INFORMATION :: struct { | |
| PerProcessUserTimeLimit : LARGE_INTEGER, | |
| PerJobUserTimeLimit : LARGE_INTEGER, | |
| LimitFlags : DWORD, | |
| MinimumWorkingSetSize : SIZE_T, | |
| MaximumWorkingSetSize : SIZE_T, | |
| ActiveProcessLimit : DWORD, | |
| Affinity : ULONG_PTR, | |
| PriorityClass : DWORD, | |
| SchedulingClass : DWORD, | |
| }; | |
| PJOBOBJECT_BASIC_LIMIT_INFORMATION :: ^JOBOBJECT_BASIC_LIMIT_INFORMATION; | |
| JOBOBJECT_EXTENDED_LIMIT_INFORMATION :: struct { | |
| BasicLimitInformation : JOBOBJECT_BASIC_LIMIT_INFORMATION, | |
| IoInfo : IO_COUNTERS, | |
| ProcessMemoryLimit : SIZE_T, | |
| JobMemoryLimit : SIZE_T, | |
| PeakProcessMemoryUsed : SIZE_T, | |
| PeakJobMemoryUsed : SIZE_T, | |
| }; | |
| PJOBOBJECT_EXTENDED_LIMIT_INFORMATION :: ^JOBOBJECT_EXTENDED_LIMIT_INFORMATION; | |
| JOBOBJECT_BASIC_PROCESS_ID_LIST :: struct { | |
| NumberOfAssignedProcesses : DWORD, | |
| NumberOfProcessIdsInList : DWORD, | |
| ProcessIdList : [1]ULONG_PTR, | |
| }; | |
| PJOBOBJECT_BASIC_PROCESS_ID_LIST :: ^JOBOBJECT_BASIC_PROCESS_ID_LIST; | |
| JOBOBJECT_BASIC_UI_RESTRICTIONS :: struct { | |
| UIRestrictionsClass : DWORD, | |
| }; | |
| PJOBOBJECT_BASIC_UI_RESTRICTIONS :: ^JOBOBJECT_BASIC_UI_RESTRICTIONS; | |
| JOBOBJECT_SECURITY_LIMIT_INFORMATION :: struct { | |
| SecurityLimitFlags : DWORD, | |
| JobToken : HANDLE, | |
| SidsToDisable : PTOKEN_GROUPS, | |
| PrivilegesToDelete : PTOKEN_PRIVILEGES, | |
| RestrictedSids : PTOKEN_GROUPS, | |
| }; | |
| PJOBOBJECT_SECURITY_LIMIT_INFORMATION :: ^JOBOBJECT_SECURITY_LIMIT_INFORMATION; | |
| JOBOBJECT_END_OF_JOB_TIME_INFORMATION :: struct { | |
| EndOfJobTimeAction : DWORD, | |
| }; | |
| PJOBOBJECT_END_OF_JOB_TIME_INFORMATION :: ^JOBOBJECT_END_OF_JOB_TIME_INFORMATION; | |
| JOBOBJECT_ASSOCIATE_COMPLETION_PORT :: struct { | |
| CompletionKey : PVOID, | |
| CompletionPort : HANDLE, | |
| }; | |
| PJOBOBJECT_ASSOCIATE_COMPLETION_PORT :: ^JOBOBJECT_ASSOCIATE_COMPLETION_PORT; | |
| JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION :: struct { | |
| BasicInfo : JOBOBJECT_BASIC_ACCOUNTING_INFORMATION, | |
| IoInfo : IO_COUNTERS, | |
| }; | |
| PJOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION :: ^JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION; | |
| JOBOBJECT_JOBSET_INFORMATION :: struct { | |
| MemberLevel : DWORD, | |
| }; | |
| PJOBOBJECT_JOBSET_INFORMATION :: ^JOBOBJECT_JOBSET_INFORMATION; | |
| /* JOBOBJECT_RATE_CONTROL_TOLERANCE :: enum { */ | |
| JOBOBJECT_RATE_CONTROL_TOLERANCE :: _c.int; | |
| ToleranceLow :: 1; | |
| ToleranceMedium :: ToleranceLow + 1; | |
| ToleranceHigh :: ToleranceMedium + 1; | |
| /* } */ | |
| PJOBOBJECT_RATE_CONTROL_TOLERANCE :: ^JOBOBJECT_RATE_CONTROL_TOLERANCE; | |
| /* JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL :: enum { */ | |
| JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL :: _c.int; | |
| ToleranceIntervalShort :: 1; | |
| ToleranceIntervalMedium :: ToleranceIntervalShort + 1; | |
| ToleranceIntervalLong :: ToleranceIntervalMedium + 1; | |
| /* } */ | |
| PJOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL :: ^JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL; | |
| JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION :: struct { | |
| IoReadBytesLimit : DWORD64, | |
| IoWriteBytesLimit : DWORD64, | |
| PerJobUserTimeLimit : LARGE_INTEGER, | |
| JobMemoryLimit : DWORD64, | |
| RateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| RateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL, | |
| LimitFlags : DWORD, | |
| }; | |
| PJOBOBJECT_NOTIFICATION_LIMIT_INFORMATION :: ^JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION; | |
| JOBOBJECT_NOTIFICATION_LIMIT_INFORMATION_2 :: struct { | |
| IoReadBytesLimit : DWORD64, | |
| IoWriteBytesLimit : DWORD64, | |
| PerJobUserTimeLimit : LARGE_INTEGER, | |
| u : struct #raw_union { | |
| JobHighMemoryLimit : DWORD64, | |
| JobMemoryLimit : DWORD64, | |
| }, | |
| u2 : struct #raw_union { | |
| RateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| CpuRateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| }, | |
| u3 : struct #raw_union { | |
| RateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL, | |
| CpuRateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL, | |
| }, | |
| LimitFlags : DWORD, | |
| IoRateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| JobLowMemoryLimit : DWORD64, | |
| IoRateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL, | |
| NetRateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| NetRateControlToleranceInterval : JOBOBJECT_RATE_CONTROL_TOLERANCE_INTERVAL, | |
| }; | |
| JOBOBJECT_LIMIT_VIOLATION_INFORMATION :: struct { | |
| LimitFlags : DWORD, | |
| ViolationLimitFlags : DWORD, | |
| IoReadBytes : DWORD64, | |
| IoReadBytesLimit : DWORD64, | |
| IoWriteBytes : DWORD64, | |
| IoWriteBytesLimit : DWORD64, | |
| PerJobUserTime : LARGE_INTEGER, | |
| PerJobUserTimeLimit : LARGE_INTEGER, | |
| JobMemory : DWORD64, | |
| JobMemoryLimit : DWORD64, | |
| RateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| RateControlToleranceLimit : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| }; | |
| PJOBOBJECT_LIMIT_VIOLATION_INFORMATION :: ^JOBOBJECT_LIMIT_VIOLATION_INFORMATION; | |
| JOBOBJECT_LIMIT_VIOLATION_INFORMATION_2 :: struct { | |
| LimitFlags : DWORD, | |
| ViolationLimitFlags : DWORD, | |
| IoReadBytes : DWORD64, | |
| IoReadBytesLimit : DWORD64, | |
| IoWriteBytes : DWORD64, | |
| IoWriteBytesLimit : DWORD64, | |
| PerJobUserTime : LARGE_INTEGER, | |
| PerJobUserTimeLimit : LARGE_INTEGER, | |
| JobMemory : DWORD64, | |
| u : struct #raw_union { | |
| JobHighMemoryLimit : DWORD64, | |
| JobMemoryLimit : DWORD64, | |
| }, | |
| u2 : struct #raw_union { | |
| RateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| CpuRateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| }, | |
| u3 : struct #raw_union { | |
| RateControlToleranceLimit : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| CpuRateControlToleranceLimit : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| }, | |
| JobLowMemoryLimit : DWORD64, | |
| IoRateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| IoRateControlToleranceLimit : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| NetRateControlTolerance : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| NetRateControlToleranceLimit : JOBOBJECT_RATE_CONTROL_TOLERANCE, | |
| }; | |
| JOBOBJECT_CPU_RATE_CONTROL_INFORMATION :: struct { | |
| ControlFlags : DWORD, | |
| u : struct #raw_union { | |
| CpuRate : DWORD, | |
| Weight : DWORD, | |
| s : struct { | |
| MinRate : WORD, | |
| MaxRate : WORD, | |
| }, | |
| }, | |
| }; | |
| PJOBOBJECT_CPU_RATE_CONTROL_INFORMATION :: ^JOBOBJECT_CPU_RATE_CONTROL_INFORMATION; | |
| /* JOB_OBJECT_NET_RATE_CONTROL_FLAGS :: enum { */ | |
| JOB_OBJECT_NET_RATE_CONTROL_FLAGS :: _c.int; | |
| JOB_OBJECT_NET_RATE_CONTROL_ENABLE :: 0x1; | |
| JOB_OBJECT_NET_RATE_CONTROL_MAX_BANDWIDTH :: 0x2; | |
| JOB_OBJECT_NET_RATE_CONTROL_DSCP_TAG :: 0x4; | |
| JOB_OBJECT_NET_RATE_CONTROL_VALID_FLAGS :: 0x7; | |
| /* } */ | |
| ; | |
| ; | |
| JOBOBJECT_NET_RATE_CONTROL_INFORMATION :: struct { | |
| MaxBandwidth : DWORD64, | |
| ControlFlags : JOB_OBJECT_NET_RATE_CONTROL_FLAGS, | |
| DscpTag : BYTE, | |
| }; | |
| /* JOB_OBJECT_IO_RATE_CONTROL_FLAGS :: enum { */ | |
| JOB_OBJECT_IO_RATE_CONTROL_FLAGS :: _c.int; | |
| JOB_OBJECT_IO_RATE_CONTROL_ENABLE :: 0x1; | |
| JOB_OBJECT_IO_RATE_CONTROL_STANDALONE_VOLUME :: 0x2; | |
| JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ALL :: 0x4; | |
| JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ON_SOFT_CAP :: 0x8; | |
| JOB_OBJECT_IO_RATE_CONTROL_VALID_FLAGS :: JOB_OBJECT_IO_RATE_CONTROL_ENABLE | JOB_OBJECT_IO_RATE_CONTROL_STANDALONE_VOLUME | JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ALL | JOB_OBJECT_IO_RATE_CONTROL_FORCE_UNIT_ACCESS_ON_SOFT_CAP; | |
| /* } */ | |
| ; | |
| JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE :: struct { | |
| MaxIops : LONG64, | |
| MaxBandwidth : LONG64, | |
| ReservationIops : LONG64, | |
| VolumeName : PWSTR, | |
| BaseIoSize : DWORD, | |
| ControlFlags : JOB_OBJECT_IO_RATE_CONTROL_FLAGS, | |
| VolumeNameLength : WORD, | |
| }; | |
| JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V1 :: JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE; | |
| JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V2 :: struct { | |
| MaxIops : LONG64, | |
| MaxBandwidth : LONG64, | |
| ReservationIops : LONG64, | |
| VolumeName : PWSTR, | |
| BaseIoSize : DWORD, | |
| ControlFlags : JOB_OBJECT_IO_RATE_CONTROL_FLAGS, | |
| VolumeNameLength : WORD, | |
| CriticalReservationIops : LONG64, | |
| ReservationBandwidth : LONG64, | |
| CriticalReservationBandwidth : LONG64, | |
| MaxTimePercent : LONG64, | |
| ReservationTimePercent : LONG64, | |
| CriticalReservationTimePercent : LONG64, | |
| }; | |
| JOBOBJECT_IO_RATE_CONTROL_INFORMATION_NATIVE_V3 :: struct { | |
| MaxIops : LONG64, | |
| MaxBandwidth : LONG64, | |
| ReservationIops : LONG64, | |
| VolumeName : PWSTR, | |
| BaseIoSize : DWORD, | |
| ControlFlags : JOB_OBJECT_IO_RATE_CONTROL_FLAGS, | |
| VolumeNameLength : WORD, | |
| CriticalReservationIops : LONG64, | |
| ReservationBandwidth : LONG64, | |
| CriticalReservationBandwidth : LONG64, | |
| MaxTimePercent : LONG64, | |
| ReservationTimePercent : LONG64, | |
| CriticalReservationTimePercent : LONG64, | |
| SoftMaxIops : LONG64, | |
| SoftMaxBandwidth : LONG64, | |
| SoftMaxTimePercent : LONG64, | |
| LimitExcessNotifyIops : LONG64, | |
| LimitExcessNotifyBandwidth : LONG64, | |
| LimitExcessNotifyTimePercent : LONG64, | |
| }; | |
| /* JOBOBJECT_IO_ATTRIBUTION_CONTROL_FLAGS :: enum { */ | |
| JOBOBJECT_IO_ATTRIBUTION_CONTROL_FLAGS :: _c.int; | |
| JOBOBJECT_IO_ATTRIBUTION_CONTROL_ENABLE :: 0x1; | |
| JOBOBJECT_IO_ATTRIBUTION_CONTROL_DISABLE :: 0x2; | |
| JOBOBJECT_IO_ATTRIBUTION_CONTROL_VALID_FLAGS :: 0x3; | |
| /* } */ | |
| ; | |
| JOBOBJECT_IO_ATTRIBUTION_STATS :: struct { | |
| IoCount : ULONG_PTR, | |
| TotalNonOverlappedQueueTime : ULONGLONG, | |
| TotalNonOverlappedServiceTime : ULONGLONG, | |
| TotalSize : ULONGLONG, | |
| }; | |
| PJOBOBJECT_IO_ATTRIBUTION_STATS :: ^JOBOBJECT_IO_ATTRIBUTION_STATS; | |
| JOBOBJECT_IO_ATTRIBUTION_INFORMATION :: struct { | |
| ControlFlags : DWORD, | |
| ReadStats : JOBOBJECT_IO_ATTRIBUTION_STATS, | |
| WriteStats : JOBOBJECT_IO_ATTRIBUTION_STATS, | |
| }; | |
| PJOBOBJECT_IO_ATTRIBUTION_INFORMATION :: ^JOBOBJECT_IO_ATTRIBUTION_INFORMATION; | |
| /* JOBOBJECTINFOCLASS :: enum { */ | |
| JOBOBJECTINFOCLASS :: _c.int; | |
| JobObjectBasicAccountingInformation :: 1; | |
| JobObjectBasicLimitInformation :: JobObjectBasicAccountingInformation + 1; | |
| JobObjectBasicProcessIdList :: JobObjectBasicLimitInformation + 1; | |
| JobObjectBasicUIRestrictions :: JobObjectBasicProcessIdList + 1; | |
| JobObjectSecurityLimitInformation :: JobObjectBasicUIRestrictions + 1; | |
| JobObjectEndOfJobTimeInformation :: JobObjectSecurityLimitInformation + 1; | |
| JobObjectAssociateCompletionPortInformation :: JobObjectEndOfJobTimeInformation + 1; | |
| JobObjectBasicAndIoAccountingInformation :: JobObjectAssociateCompletionPortInformation + 1; | |
| JobObjectExtendedLimitInformation :: JobObjectBasicAndIoAccountingInformation + 1; | |
| JobObjectJobSetInformation :: JobObjectExtendedLimitInformation + 1; | |
| JobObjectGroupInformation :: JobObjectJobSetInformation + 1; | |
| JobObjectNotificationLimitInformation :: JobObjectGroupInformation + 1; | |
| JobObjectLimitViolationInformation :: JobObjectNotificationLimitInformation + 1; | |
| JobObjectGroupInformationEx :: JobObjectLimitViolationInformation + 1; | |
| JobObjectCpuRateControlInformation :: JobObjectGroupInformationEx + 1; | |
| JobObjectCompletionFilter :: JobObjectCpuRateControlInformation + 1; | |
| JobObjectCompletionCounter :: JobObjectCompletionFilter + 1; | |
| JobObjectReserved1Information :: 18; | |
| JobObjectReserved2Information :: JobObjectReserved1Information + 1; | |
| JobObjectReserved3Information :: JobObjectReserved2Information + 1; | |
| JobObjectReserved4Information :: JobObjectReserved3Information + 1; | |
| JobObjectReserved5Information :: JobObjectReserved4Information + 1; | |
| JobObjectReserved6Information :: JobObjectReserved5Information + 1; | |
| JobObjectReserved7Information :: JobObjectReserved6Information + 1; | |
| JobObjectReserved8Information :: JobObjectReserved7Information + 1; | |
| JobObjectReserved9Information :: JobObjectReserved8Information + 1; | |
| JobObjectReserved10Information :: JobObjectReserved9Information + 1; | |
| JobObjectReserved11Information :: JobObjectReserved10Information + 1; | |
| JobObjectReserved12Information :: JobObjectReserved11Information + 1; | |
| JobObjectReserved13Information :: JobObjectReserved12Information + 1; | |
| JobObjectReserved14Information :: 31; | |
| JobObjectNetRateControlInformation :: JobObjectReserved14Information + 1; | |
| JobObjectNotificationLimitInformation2 :: JobObjectNetRateControlInformation + 1; | |
| JobObjectLimitViolationInformation2 :: JobObjectNotificationLimitInformation2 + 1; | |
| JobObjectCreateSilo :: JobObjectLimitViolationInformation2 + 1; | |
| JobObjectSiloBasicInformation :: JobObjectCreateSilo + 1; | |
| JobObjectReserved15Information :: 37; | |
| JobObjectReserved16Information :: 38; | |
| JobObjectReserved17Information :: 39; | |
| JobObjectReserved18Information :: 40; | |
| JobObjectReserved19Information :: 41; | |
| JobObjectReserved20Information :: 42; | |
| JobObjectReserved21Information :: 43; | |
| JobObjectReserved22Information :: 44; | |
| JobObjectReserved23Information :: 45; | |
| JobObjectReserved24Information :: 46; | |
| JobObjectReserved25Information :: 47; | |
| MaxJobObjectInfoClass :: JobObjectReserved25Information + 1; | |
| /* } */ | |
| ; | |
| SILOOBJECT_BASIC_INFORMATION :: struct { | |
| SiloId : DWORD, | |
| SiloParentId : DWORD, | |
| NumberOfProcesses : DWORD, | |
| IsInServerSilo : BOOLEAN, | |
| Reserved : [3]BYTE, | |
| }; | |
| PSILOOBJECT_BASIC_INFORMATION :: ^SILOOBJECT_BASIC_INFORMATION; | |
| /* SERVERSILO_STATE :: enum { */ | |
| SERVERSILO_STATE :: _c.int; | |
| SERVERSILO_INITING :: 0; | |
| SERVERSILO_STARTED :: SERVERSILO_INITING + 1; | |
| SERVERSILO_SHUTTING_DOWN :: SERVERSILO_STARTED + 1; | |
| SERVERSILO_TERMINATING :: SERVERSILO_SHUTTING_DOWN + 1; | |
| SERVERSILO_TERMINATED :: SERVERSILO_TERMINATING + 1; | |
| /* } */ | |
| PSERVERSILO_STATE :: ^SERVERSILO_STATE; | |
| SERVERSILO_BASIC_INFORMATION :: struct { | |
| ServiceSessionId : DWORD, | |
| State : SERVERSILO_STATE, | |
| ExitStatus : DWORD, | |
| }; | |
| PSERVERSILO_BASIC_INFORMATION :: ^SERVERSILO_BASIC_INFORMATION; | |
| /* FIRMWARE_TYPE :: enum { */ | |
| FIRMWARE_TYPE :: _c.int; | |
| FirmwareTypeUnknown :: 0; | |
| FirmwareTypeBios :: FirmwareTypeUnknown + 1; | |
| FirmwareTypeUefi :: FirmwareTypeBios + 1; | |
| FirmwareTypeMax :: FirmwareTypeUefi + 1; | |
| /* } */ | |
| PFIRMWARE_TYPE :: ^FIRMWARE_TYPE; | |
| /* LOGICAL_PROCESSOR_RELATIONSHIP :: enum { */ | |
| LOGICAL_PROCESSOR_RELATIONSHIP :: _c.int; | |
| RelationProcessorCore :: 0; | |
| RelationNumaNode :: RelationProcessorCore + 1; | |
| RelationCache :: RelationNumaNode + 1; | |
| RelationProcessorPackage :: RelationCache + 1; | |
| RelationGroup :: RelationProcessorPackage + 1; | |
| RelationAll :: 0xffff; | |
| /* } */ | |
| ; | |
| /* PROCESSOR_CACHE_TYPE :: enum { */ | |
| PROCESSOR_CACHE_TYPE :: _c.int; | |
| CacheUnified :: 0; | |
| CacheInstruction :: CacheUnified + 1; | |
| CacheData :: CacheInstruction + 1; | |
| CacheTrace :: CacheData + 1; | |
| /* } */ | |
| ; | |
| CACHE_DESCRIPTOR :: struct { | |
| Level : BYTE, | |
| Associativity : BYTE, | |
| LineSize : WORD, | |
| Size : DWORD, | |
| Type : PROCESSOR_CACHE_TYPE, | |
| }; | |
| PCACHE_DESCRIPTOR :: ^CACHE_DESCRIPTOR; | |
| SYSTEM_LOGICAL_PROCESSOR_INFORMATION :: struct { | |
| ProcessorMask : ULONG_PTR, | |
| Relationship : LOGICAL_PROCESSOR_RELATIONSHIP, | |
| u : struct #raw_union { | |
| ProcessorCore : struct { | |
| Flags : BYTE, | |
| }, | |
| NumaNode : struct { | |
| NodeNumber : DWORD, | |
| }, | |
| Cache : CACHE_DESCRIPTOR, | |
| Reserved : [2]ULONGLONG, | |
| }, | |
| }; | |
| PSYSTEM_LOGICAL_PROCESSOR_INFORMATION :: ^SYSTEM_LOGICAL_PROCESSOR_INFORMATION; | |
| PROCESSOR_RELATIONSHIP :: struct { | |
| Flags : BYTE, | |
| EfficiencyClass : BYTE, | |
| Reserved : [20]BYTE, | |
| GroupCount : WORD, | |
| GroupMask : [1]GROUP_AFFINITY, | |
| }; | |
| PPROCESSOR_RELATIONSHIP :: ^PROCESSOR_RELATIONSHIP; | |
| NUMA_NODE_RELATIONSHIP :: struct { | |
| NodeNumber : DWORD, | |
| Reserved : [20]BYTE, | |
| GroupMask : GROUP_AFFINITY, | |
| }; | |
| PNUMA_NODE_RELATIONSHIP :: ^NUMA_NODE_RELATIONSHIP; | |
| CACHE_RELATIONSHIP :: struct { | |
| Level : BYTE, | |
| Associativity : BYTE, | |
| LineSize : WORD, | |
| CacheSize : DWORD, | |
| Type : PROCESSOR_CACHE_TYPE, | |
| Reserved : [20]BYTE, | |
| GroupMask : GROUP_AFFINITY, | |
| }; | |
| PCACHE_RELATIONSHIP :: ^CACHE_RELATIONSHIP; | |
| PROCESSOR_GROUP_INFO :: struct { | |
| MaximumProcessorCount : BYTE, | |
| ActiveProcessorCount : BYTE, | |
| Reserved : [38]BYTE, | |
| ActiveProcessorMask : KAFFINITY, | |
| }; | |
| PPROCESSOR_GROUP_INFO :: ^PROCESSOR_GROUP_INFO; | |
| GROUP_RELATIONSHIP :: struct { | |
| MaximumGroupCount : WORD, | |
| ActiveGroupCount : WORD, | |
| Reserved : [20]BYTE, | |
| GroupInfo : [1]PROCESSOR_GROUP_INFO, | |
| }; | |
| PGROUP_RELATIONSHIP :: ^GROUP_RELATIONSHIP; | |
| SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX :: struct { | |
| Relationship : LOGICAL_PROCESSOR_RELATIONSHIP, | |
| Size : DWORD, | |
| u : struct #raw_union { | |
| Processor : PROCESSOR_RELATIONSHIP, | |
| NumaNode : NUMA_NODE_RELATIONSHIP, | |
| Cache : CACHE_RELATIONSHIP, | |
| Group : GROUP_RELATIONSHIP, | |
| }, | |
| }; | |
| PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX :: ^SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX; | |
| /* CPU_SET_INFORMATION_TYPE :: enum { */ | |
| CPU_SET_INFORMATION_TYPE :: _c.int; | |
| CpuSetInformation :: 0; | |
| /* } */ | |
| PCPU_SET_INFORMATION_TYPE :: ^CPU_SET_INFORMATION_TYPE; | |
| SYSTEM_CPU_SET_INFORMATION :: struct { | |
| Size : DWORD, | |
| Type : CPU_SET_INFORMATION_TYPE, | |
| u : struct #raw_union { | |
| CpuSet : struct { | |
| Id : DWORD, | |
| Group : WORD, | |
| LogicalProcessorIndex : BYTE, | |
| CoreIndex : BYTE, | |
| LastLevelCacheIndex : BYTE, | |
| NumaNodeIndex : BYTE, | |
| EfficiencyClass : BYTE, | |
| u2 : struct #raw_union { | |
| AllFlags : BYTE, | |
| s : bit_field { | |
| Parked : 1, | |
| Allocated : 1, | |
| AllocatedToTargetProcess : 1, | |
| RealTime : 1, | |
| ReservedFlags : 4, | |
| }, | |
| }, | |
| using _ : struct #raw_union { | |
| Reserved : DWORD, | |
| SchedulingClass : BYTE, | |
| }, | |
| AllocationTag : DWORD64, | |
| }, | |
| }, | |
| }; | |
| PSYSTEM_CPU_SET_INFORMATION :: ^SYSTEM_CPU_SET_INFORMATION; | |
| SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION :: struct { | |
| CycleTime : DWORD64, | |
| }; | |
| PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION :: ^SYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION; | |
| XSTATE_FEATURE :: struct { | |
| Offset : DWORD, | |
| Size : DWORD, | |
| }; | |
| PXSTATE_FEATURE :: ^XSTATE_FEATURE; | |
| XSTATE_CONFIGURATION :: struct { | |
| EnabledFeatures : DWORD64, | |
| EnabledVolatileFeatures : DWORD64, | |
| Size : DWORD, | |
| using _ : struct #raw_union { | |
| ControlFlags : DWORD, | |
| using _ : bit_field { | |
| OptimizedSave : 1, | |
| CompactionEnabled : 1, | |
| }, | |
| }, | |
| Features : [(64)]XSTATE_FEATURE, | |
| EnabledSupervisorFeatures : DWORD64, | |
| AlignedFeatures : DWORD64, | |
| AllFeatureSize : DWORD, | |
| AllFeatures : [(64)]DWORD, | |
| EnabledUserVisibleSupervisorFeatures : DWORD64, | |
| }; | |
| PXSTATE_CONFIGURATION :: ^XSTATE_CONFIGURATION; | |
| MEMORY_BASIC_INFORMATION :: struct { | |
| BaseAddress : PVOID, | |
| AllocationBase : PVOID, | |
| AllocationProtect : DWORD, | |
| RegionSize : SIZE_T, | |
| State : DWORD, | |
| Protect : DWORD, | |
| Type : DWORD, | |
| }; | |
| PMEMORY_BASIC_INFORMATION :: ^MEMORY_BASIC_INFORMATION; | |
| MEMORY_BASIC_INFORMATION32 :: struct { | |
| BaseAddress : DWORD, | |
| AllocationBase : DWORD, | |
| AllocationProtect : DWORD, | |
| RegionSize : DWORD, | |
| State : DWORD, | |
| Protect : DWORD, | |
| Type : DWORD, | |
| }; | |
| PMEMORY_BASIC_INFORMATION32 :: ^MEMORY_BASIC_INFORMATION32; | |
| MEMORY_BASIC_INFORMATION64 :: struct { | |
| BaseAddress : ULONGLONG, | |
| AllocationBase : ULONGLONG, | |
| AllocationProtect : DWORD, | |
| __alignment1 : DWORD, | |
| RegionSize : ULONGLONG, | |
| State : DWORD, | |
| Protect : DWORD, | |
| Type : DWORD, | |
| __alignment2 : DWORD, | |
| }; | |
| PMEMORY_BASIC_INFORMATION64 :: ^MEMORY_BASIC_INFORMATION64; | |
| CFG_CALL_TARGET_INFO :: struct { | |
| Offset : ULONG_PTR, | |
| Flags : ULONG_PTR, | |
| }; | |
| PCFG_CALL_TARGET_INFO :: ^CFG_CALL_TARGET_INFO; | |
| MEM_ADDRESS_REQUIREMENTS :: struct { | |
| LowestStartingAddress : PVOID, | |
| HighestEndingAddress : PVOID, | |
| Alignment : SIZE_T, | |
| }; | |
| PMEM_ADDRESS_REQUIREMENTS :: ^MEM_ADDRESS_REQUIREMENTS; | |
| /* MEM_EXTENDED_PARAMETER_TYPE :: enum { */ | |
| MEM_EXTENDED_PARAMETER_TYPE :: _c.int; | |
| MemExtendedParameterInvalidType :: 0; | |
| MemExtendedParameterAddressRequirements :: MemExtendedParameterInvalidType + 1; | |
| MemExtendedParameterNumaNode :: MemExtendedParameterAddressRequirements + 1; | |
| MemExtendedParameterPartitionHandle :: MemExtendedParameterNumaNode + 1; | |
| MemExtendedParameterUserPhysicalHandle :: MemExtendedParameterPartitionHandle + 1; | |
| MemExtendedParameterAttributeFlags :: MemExtendedParameterUserPhysicalHandle + 1; | |
| MemExtendedParameterMax :: MemExtendedParameterAttributeFlags + 1; | |
| /* } */ | |
| PMEM_EXTENDED_PARAMETER_TYPE :: ^MEM_EXTENDED_PARAMETER_TYPE; | |
| MEM_EXTENDED_PARAMETER :: struct { | |
| s : bit_field { | |
| Type : 8, | |
| Reserved : 64 - 8, | |
| }, | |
| u : struct #raw_union { | |
| ULong64 : DWORD64, | |
| Pointer : PVOID, | |
| Size : SIZE_T, | |
| Handle : HANDLE, | |
| ULong : DWORD, | |
| }, | |
| }; | |
| PMEM_EXTENDED_PARAMETER :: ^MEM_EXTENDED_PARAMETER; | |
| /* MEM_SECTION_EXTENDED_PARAMETER_TYPE :: enum { */ | |
| MEM_SECTION_EXTENDED_PARAMETER_TYPE :: _c.int; | |
| MemSectionExtendedParameterInvalidType :: 0; | |
| MemSectionExtendedParameterUserPhysicalFlags :: MemSectionExtendedParameterInvalidType + 1; | |
| MemSectionExtendedParameterNumaNode :: MemSectionExtendedParameterUserPhysicalFlags + 1; | |
| MemSectionExtendedParameterMax :: MemSectionExtendedParameterNumaNode + 1; | |
| /* } */ | |
| PMEM_SECTION_EXTENDED_PARAMETER_TYPE :: ^MEM_SECTION_EXTENDED_PARAMETER_TYPE; | |
| ENCLAVE_CREATE_INFO_SGX :: struct { | |
| Secs : [4096]BYTE, | |
| }; | |
| PENCLAVE_CREATE_INFO_SGX :: ^ENCLAVE_CREATE_INFO_SGX; | |
| ENCLAVE_INIT_INFO_SGX :: struct { | |
| SigStruct : [1808]BYTE, | |
| Reserved1 : [240]BYTE, | |
| EInitToken : [304]BYTE, | |
| Reserved2 : [1744]BYTE, | |
| }; | |
| PENCLAVE_INIT_INFO_SGX :: ^ENCLAVE_INIT_INFO_SGX; | |
| ENCLAVE_CREATE_INFO_VBS :: struct { | |
| Flags : DWORD, | |
| OwnerID : [32]BYTE, | |
| }; | |
| PENCLAVE_CREATE_INFO_VBS :: ^ENCLAVE_CREATE_INFO_VBS; | |
| ENCLAVE_CREATE_INFO_VBS_BASIC :: struct { | |
| Flags : DWORD, | |
| OwnerID : [32]BYTE, | |
| }; | |
| PENCLAVE_CREATE_INFO_VBS_BASIC :: ^ENCLAVE_CREATE_INFO_VBS_BASIC; | |
| ENCLAVE_LOAD_DATA_VBS_BASIC :: struct { | |
| PageType : DWORD, | |
| }; | |
| PENCLAVE_LOAD_DATA_VBS_BASIC :: ^ENCLAVE_LOAD_DATA_VBS_BASIC; | |
| ENCLAVE_INIT_INFO_VBS_BASIC :: struct { | |
| FamilyId : [16]BYTE, | |
| ImageId : [16]BYTE, | |
| EnclaveSize : ULONGLONG, | |
| EnclaveSvn : DWORD, | |
| Reserved : DWORD, | |
| u : struct #raw_union { | |
| SignatureInfoHandle : HANDLE, | |
| Unused : ULONGLONG, | |
| }, | |
| }; | |
| PENCLAVE_INIT_INFO_VBS_BASIC :: ^ENCLAVE_INIT_INFO_VBS_BASIC; | |
| ENCLAVE_INIT_INFO_VBS :: struct { | |
| Length : DWORD, | |
| ThreadCount : DWORD, | |
| }; | |
| PENCLAVE_INIT_INFO_VBS :: ^ENCLAVE_INIT_INFO_VBS; | |
| ENCLAVE_TARGET_FUNCTION :: #type (proc(PVOID) -> PVOID); | |
| PENCLAVE_TARGET_FUNCTION :: ^ENCLAVE_TARGET_FUNCTION; | |
| LPENCLAVE_TARGET_FUNCTION :: PENCLAVE_TARGET_FUNCTION; | |
| FILE_ID_128 :: struct { | |
| Identifier : [16]BYTE, | |
| }; | |
| PFILE_ID_128 :: ^FILE_ID_128; | |
| FILE_NOTIFY_INFORMATION :: struct { | |
| NextEntryOffset : DWORD, | |
| Action : DWORD, | |
| FileNameLength : DWORD, | |
| FileName : [1]WCHAR, | |
| }; | |
| PFILE_NOTIFY_INFORMATION :: ^FILE_NOTIFY_INFORMATION; | |
| FILE_NOTIFY_EXTENDED_INFORMATION :: struct { | |
| NextEntryOffset : DWORD, | |
| Action : DWORD, | |
| CreationTime : LARGE_INTEGER, | |
| LastModificationTime : LARGE_INTEGER, | |
| LastChangeTime : LARGE_INTEGER, | |
| LastAccessTime : LARGE_INTEGER, | |
| AllocatedLength : LARGE_INTEGER, | |
| FileSize : LARGE_INTEGER, | |
| FileAttributes : DWORD, | |
| ReparsePointTag : DWORD, | |
| FileId : LARGE_INTEGER, | |
| ParentFileId : LARGE_INTEGER, | |
| FileNameLength : DWORD, | |
| FileName : [1]WCHAR, | |
| }; | |
| PFILE_NOTIFY_EXTENDED_INFORMATION :: ^FILE_NOTIFY_EXTENDED_INFORMATION; | |
| FILE_SEGMENT_ELEMENT :: struct #raw_union { | |
| Buffer : PVOID64, | |
| Alignment : ULONGLONG, | |
| }; | |
| PFILE_SEGMENT_ELEMENT :: ^FILE_SEGMENT_ELEMENT; | |
| REPARSE_GUID_DATA_BUFFER :: struct { | |
| ReparseTag : DWORD, | |
| ReparseDataLength : WORD, | |
| Reserved : WORD, | |
| ReparseGuid : GUID, | |
| GenericReparseBuffer : struct { | |
| DataBuffer : [1]BYTE, | |
| }, | |
| }; | |
| PREPARSE_GUID_DATA_BUFFER :: ^REPARSE_GUID_DATA_BUFFER; | |
| SCRUB_DATA_INPUT :: struct { | |
| Size : DWORD, | |
| Flags : DWORD, | |
| MaximumIos : DWORD, | |
| ObjectId : [4]DWORD, | |
| Reserved : [25]DWORD, | |
| ResumeContext : [816]BYTE, | |
| }; | |
| PSCRUB_DATA_INPUT :: ^SCRUB_DATA_INPUT; | |
| SCRUB_PARITY_EXTENT :: struct { | |
| Offset : LONGLONG, | |
| Length : ULONGLONG, | |
| }; | |
| PSCRUB_PARITY_EXTENT :: ^SCRUB_PARITY_EXTENT; | |
| SCRUB_PARITY_EXTENT_DATA :: struct { | |
| Size : WORD, | |
| Flags : WORD, | |
| NumberOfParityExtents : WORD, | |
| MaximumNumberOfParityExtents : WORD, | |
| ParityExtents : [1]SCRUB_PARITY_EXTENT, | |
| }; | |
| PSCRUB_PARITY_EXTENT_DATA :: ^SCRUB_PARITY_EXTENT_DATA; | |
| SCRUB_DATA_OUTPUT :: struct { | |
| Size : DWORD, | |
| Flags : DWORD, | |
| Status : DWORD, | |
| ErrorFileOffset : ULONGLONG, | |
| ErrorLength : ULONGLONG, | |
| NumberOfBytesRepaired : ULONGLONG, | |
| NumberOfBytesFailed : ULONGLONG, | |
| InternalFileReference : ULONGLONG, | |
| ResumeContextLength : WORD, | |
| ParityExtentDataOffset : WORD, | |
| Reserved : [9]DWORD, | |
| NumberOfMetadataBytesProcessed : ULONGLONG, | |
| NumberOfDataBytesProcessed : ULONGLONG, | |
| TotalNumberOfMetadataBytesInUse : ULONGLONG, | |
| TotalNumberOfDataBytesInUse : ULONGLONG, | |
| ResumeContext : [816]BYTE, | |
| }; | |
| PSCRUB_DATA_OUTPUT :: ^SCRUB_DATA_OUTPUT; | |
| /* SharedVirtualDiskSupportType :: enum { */ | |
| SharedVirtualDiskSupportType :: _c.int; | |
| SharedVirtualDisksUnsupported :: 0; | |
| SharedVirtualDisksSupported :: 1; | |
| SharedVirtualDiskSnapshotsSupported :: 3; | |
| SharedVirtualDiskCDPSnapshotsSupported :: 7; | |
| /* } */ | |
| ; | |
| /* SharedVirtualDiskHandleState :: enum { */ | |
| SharedVirtualDiskHandleState :: _c.int; | |
| SharedVirtualDiskHandleStateNone :: 0; | |
| SharedVirtualDiskHandleStateFileShared :: 1; | |
| SharedVirtualDiskHandleStateHandleShared :: 3; | |
| /* } */ | |
| ; | |
| SHARED_VIRTUAL_DISK_SUPPORT :: struct { | |
| SharedVirtualDiskSupport : SharedVirtualDiskSupportType, | |
| HandleState : SharedVirtualDiskHandleState, | |
| }; | |
| PSHARED_VIRTUAL_DISK_SUPPORT :: ^SHARED_VIRTUAL_DISK_SUPPORT; | |
| REARRANGE_FILE_DATA :: struct { | |
| SourceStartingOffset : ULONGLONG, | |
| TargetOffset : ULONGLONG, | |
| SourceFileHandle : HANDLE, | |
| Length : DWORD, | |
| Flags : DWORD, | |
| }; | |
| PREARRANGE_FILE_DATA :: ^REARRANGE_FILE_DATA; | |
| REARRANGE_FILE_DATA32 :: struct { | |
| SourceStartingOffset : ULONGLONG, | |
| TargetOffset : ULONGLONG, | |
| SourceFileHandle : UINT32, | |
| Length : DWORD, | |
| Flags : DWORD, | |
| }; | |
| PREARRANGE_FILE_DATA32 :: ^REARRANGE_FILE_DATA32; | |
| SHUFFLE_FILE_DATA :: struct { | |
| StartingOffset : LONGLONG, | |
| Length : LONGLONG, | |
| Flags : DWORD, | |
| }; | |
| PSHUFFLE_FILE_DATA :: ^SHUFFLE_FILE_DATA; | |
| NETWORK_APP_INSTANCE_EA :: struct { | |
| AppInstanceID : GUID, | |
| CsvFlags : DWORD, | |
| }; | |
| PNETWORK_APP_INSTANCE_EA :: ^NETWORK_APP_INSTANCE_EA; | |
| /* SYSTEM_POWER_STATE :: enum { */ | |
| SYSTEM_POWER_STATE :: _c.int; | |
| PowerSystemUnspecified :: 0; | |
| PowerSystemWorking :: 1; | |
| PowerSystemSleeping1 :: 2; | |
| PowerSystemSleeping2 :: 3; | |
| PowerSystemSleeping3 :: 4; | |
| PowerSystemHibernate :: 5; | |
| PowerSystemShutdown :: 6; | |
| PowerSystemMaximum :: 7; | |
| /* } */ | |
| PSYSTEM_POWER_STATE :: ^SYSTEM_POWER_STATE; | |
| /* POWER_ACTION :: enum { */ | |
| POWER_ACTION :: _c.int; | |
| PowerActionNone :: 0; | |
| PowerActionReserved :: PowerActionNone + 1; | |
| PowerActionSleep :: PowerActionReserved + 1; | |
| PowerActionHibernate :: PowerActionSleep + 1; | |
| PowerActionShutdown :: PowerActionHibernate + 1; | |
| PowerActionShutdownReset :: PowerActionShutdown + 1; | |
| PowerActionShutdownOff :: PowerActionShutdownReset + 1; | |
| PowerActionWarmEject :: PowerActionShutdownOff + 1; | |
| PowerActionDisplayOff :: PowerActionWarmEject + 1; | |
| /* } */ | |
| PPOWER_ACTION :: ^POWER_ACTION; | |
| /* DEVICE_POWER_STATE :: enum { */ | |
| DEVICE_POWER_STATE :: _c.int; | |
| PowerDeviceUnspecified :: 0; | |
| PowerDeviceD0 :: PowerDeviceUnspecified + 1; | |
| PowerDeviceD1 :: PowerDeviceD0 + 1; | |
| PowerDeviceD2 :: PowerDeviceD1 + 1; | |
| PowerDeviceD3 :: PowerDeviceD2 + 1; | |
| PowerDeviceMaximum :: PowerDeviceD3 + 1; | |
| /* } */ | |
| PDEVICE_POWER_STATE :: ^DEVICE_POWER_STATE; | |
| /* MONITOR_DISPLAY_STATE :: enum { */ | |
| MONITOR_DISPLAY_STATE :: _c.int; | |
| PowerMonitorOff :: 0; | |
| PowerMonitorOn :: PowerMonitorOff + 1; | |
| PowerMonitorDim :: PowerMonitorOn + 1; | |
| /* } */ | |
| PMONITOR_DISPLAY_STATE :: ^MONITOR_DISPLAY_STATE; | |
| /* USER_ACTIVITY_PRESENCE :: enum { */ | |
| USER_ACTIVITY_PRESENCE :: _c.int; | |
| PowerUserPresent :: 0; | |
| PowerUserNotPresent :: PowerUserPresent + 1; | |
| PowerUserInactive :: PowerUserNotPresent + 1; | |
| PowerUserMaximum :: PowerUserInactive + 1; | |
| PowerUserInvalid :: PowerUserMaximum; | |
| /* } */ | |
| PUSER_ACTIVITY_PRESENCE :: ^USER_ACTIVITY_PRESENCE; | |
| EXECUTION_STATE :: DWORD; | |
| PEXECUTION_STATE :: ^DWORD; | |
| /* LATENCY_TIME :: enum { */ | |
| LATENCY_TIME :: _c.int; | |
| LT_DONT_CARE :: 0; | |
| LT_LOWEST_LATENCY :: LT_DONT_CARE + 1; | |
| /* } */ | |
| ; | |
| /* POWER_REQUEST_TYPE :: enum { */ | |
| POWER_REQUEST_TYPE :: _c.int; | |
| PowerRequestDisplayRequired :: 0; | |
| PowerRequestSystemRequired :: PowerRequestDisplayRequired + 1; | |
| PowerRequestAwayModeRequired :: PowerRequestSystemRequired + 1; | |
| PowerRequestExecutionRequired :: PowerRequestAwayModeRequired + 1; | |
| /* } */ | |
| PPOWER_REQUEST_TYPE :: ^POWER_REQUEST_TYPE; | |
| CM_POWER_DATA :: struct { | |
| PD_Size : DWORD, | |
| PD_MostRecentPowerState : DEVICE_POWER_STATE, | |
| PD_Capabilities : DWORD, | |
| PD_D1Latency : DWORD, | |
| PD_D2Latency : DWORD, | |
| PD_D3Latency : DWORD, | |
| PD_PowerStateMapping : [7]DEVICE_POWER_STATE, | |
| PD_DeepestSystemWake : SYSTEM_POWER_STATE, | |
| }; | |
| PCM_POWER_DATA :: ^CM_POWER_DATA; | |
| /* POWER_INFORMATION_LEVEL :: enum { */ | |
| POWER_INFORMATION_LEVEL :: _c.int; | |
| SystemPowerPolicyAc :: 0; | |
| SystemPowerPolicyDc :: SystemPowerPolicyAc + 1; | |
| VerifySystemPolicyAc :: SystemPowerPolicyDc + 1; | |
| VerifySystemPolicyDc :: VerifySystemPolicyAc + 1; | |
| SystemPowerCapabilities :: VerifySystemPolicyDc + 1; | |
| SystemBatteryState :: SystemPowerCapabilities + 1; | |
| SystemPowerStateHandler :: SystemBatteryState + 1; | |
| ProcessorStateHandler :: SystemPowerStateHandler + 1; | |
| SystemPowerPolicyCurrent :: ProcessorStateHandler + 1; | |
| AdministratorPowerPolicy :: SystemPowerPolicyCurrent + 1; | |
| SystemReserveHiberFile :: AdministratorPowerPolicy + 1; | |
| ProcessorInformation :: SystemReserveHiberFile + 1; | |
| SystemPowerInformation :: ProcessorInformation + 1; | |
| ProcessorStateHandler2 :: SystemPowerInformation + 1; | |
| LastWakeTime :: ProcessorStateHandler2 + 1; | |
| LastSleepTime :: LastWakeTime + 1; | |
| SystemExecutionState :: LastSleepTime + 1; | |
| SystemPowerStateNotifyHandler :: SystemExecutionState + 1; | |
| ProcessorPowerPolicyAc :: SystemPowerStateNotifyHandler + 1; | |
| ProcessorPowerPolicyDc :: ProcessorPowerPolicyAc + 1; | |
| VerifyProcessorPowerPolicyAc :: ProcessorPowerPolicyDc + 1; | |
| VerifyProcessorPowerPolicyDc :: VerifyProcessorPowerPolicyAc + 1; | |
| ProcessorPowerPolicyCurrent :: VerifyProcessorPowerPolicyDc + 1; | |
| SystemPowerStateLogging :: ProcessorPowerPolicyCurrent + 1; | |
| SystemPowerLoggingEntry :: SystemPowerStateLogging + 1; | |
| SetPowerSettingValue :: SystemPowerLoggingEntry + 1; | |
| NotifyUserPowerSetting :: SetPowerSettingValue + 1; | |
| PowerInformationLevelUnused0 :: NotifyUserPowerSetting + 1; | |
| SystemMonitorHiberBootPowerOff :: PowerInformationLevelUnused0 + 1; | |
| SystemVideoState :: SystemMonitorHiberBootPowerOff + 1; | |
| TraceApplicationPowerMessage :: SystemVideoState + 1; | |
| TraceApplicationPowerMessageEnd :: TraceApplicationPowerMessage + 1; | |
| ProcessorPerfStates :: TraceApplicationPowerMessageEnd + 1; | |
| ProcessorIdleStates :: ProcessorPerfStates + 1; | |
| ProcessorCap :: ProcessorIdleStates + 1; | |
| SystemWakeSource :: ProcessorCap + 1; | |
| SystemHiberFileInformation :: SystemWakeSource + 1; | |
| TraceServicePowerMessage :: SystemHiberFileInformation + 1; | |
| ProcessorLoad :: TraceServicePowerMessage + 1; | |
| PowerShutdownNotification :: ProcessorLoad + 1; | |
| MonitorCapabilities :: PowerShutdownNotification + 1; | |
| SessionPowerInit :: MonitorCapabilities + 1; | |
| SessionDisplayState :: SessionPowerInit + 1; | |
| PowerRequestCreate :: SessionDisplayState + 1; | |
| PowerRequestAction :: PowerRequestCreate + 1; | |
| GetPowerRequestList :: PowerRequestAction + 1; | |
| ProcessorInformationEx :: GetPowerRequestList + 1; | |
| NotifyUserModeLegacyPowerEvent :: ProcessorInformationEx + 1; | |
| GroupPark :: NotifyUserModeLegacyPowerEvent + 1; | |
| ProcessorIdleDomains :: GroupPark + 1; | |
| WakeTimerList :: ProcessorIdleDomains + 1; | |
| SystemHiberFileSize :: WakeTimerList + 1; | |
| ProcessorIdleStatesHv :: SystemHiberFileSize + 1; | |
| ProcessorPerfStatesHv :: ProcessorIdleStatesHv + 1; | |
| ProcessorPerfCapHv :: ProcessorPerfStatesHv + 1; | |
| ProcessorSetIdle :: ProcessorPerfCapHv + 1; | |
| LogicalProcessorIdling :: ProcessorSetIdle + 1; | |
| UserPresence :: LogicalProcessorIdling + 1; | |
| PowerSettingNotificationName :: UserPresence + 1; | |
| GetPowerSettingValue :: PowerSettingNotificationName + 1; | |
| IdleResiliency :: GetPowerSettingValue + 1; | |
| SessionRITState :: IdleResiliency + 1; | |
| SessionConnectNotification :: SessionRITState + 1; | |
| SessionPowerCleanup :: SessionConnectNotification + 1; | |
| SessionLockState :: SessionPowerCleanup + 1; | |
| SystemHiberbootState :: SessionLockState + 1; | |
| PlatformInformation :: SystemHiberbootState + 1; | |
| PdcInvocation :: PlatformInformation + 1; | |
| MonitorInvocation :: PdcInvocation + 1; | |
| FirmwareTableInformationRegistered :: MonitorInvocation + 1; | |
| SetShutdownSelectedTime :: FirmwareTableInformationRegistered + 1; | |
| SuspendResumeInvocation :: SetShutdownSelectedTime + 1; | |
| PlmPowerRequestCreate :: SuspendResumeInvocation + 1; | |
| ScreenOff :: PlmPowerRequestCreate + 1; | |
| CsDeviceNotification :: ScreenOff + 1; | |
| PlatformRole :: CsDeviceNotification + 1; | |
| LastResumePerformance :: PlatformRole + 1; | |
| DisplayBurst :: LastResumePerformance + 1; | |
| ExitLatencySamplingPercentage :: DisplayBurst + 1; | |
| RegisterSpmPowerSettings :: ExitLatencySamplingPercentage + 1; | |
| PlatformIdleStates :: RegisterSpmPowerSettings + 1; | |
| ProcessorIdleVeto :: PlatformIdleStates + 1; | |
| PlatformIdleVeto :: ProcessorIdleVeto + 1; | |
| SystemBatteryStatePrecise :: PlatformIdleVeto + 1; | |
| ThermalEvent :: SystemBatteryStatePrecise + 1; | |
| PowerRequestActionInternal :: ThermalEvent + 1; | |
| BatteryDeviceState :: PowerRequestActionInternal + 1; | |
| PowerInformationInternal :: BatteryDeviceState + 1; | |
| ThermalStandby :: PowerInformationInternal + 1; | |
| SystemHiberFileType :: ThermalStandby + 1; | |
| PhysicalPowerButtonPress :: SystemHiberFileType + 1; | |
| QueryPotentialDripsConstraint :: PhysicalPowerButtonPress + 1; | |
| EnergyTrackerCreate :: QueryPotentialDripsConstraint + 1; | |
| EnergyTrackerQuery :: EnergyTrackerCreate + 1; | |
| UpdateBlackBoxRecorder :: EnergyTrackerQuery + 1; | |
| PowerInformationLevelMaximum :: UpdateBlackBoxRecorder + 1; | |
| /* } */ | |
| ; | |
| /* POWER_USER_PRESENCE_TYPE :: enum { */ | |
| POWER_USER_PRESENCE_TYPE :: _c.int; | |
| UserNotPresent :: 0; | |
| UserPresent :: 1; | |
| UserUnknown :: 0xff; | |
| /* } */ | |
| PPOWER_USER_PRESENCE_TYPE :: ^POWER_USER_PRESENCE_TYPE; | |
| POWER_USER_PRESENCE :: struct { | |
| UserPresence : POWER_USER_PRESENCE_TYPE, | |
| }; | |
| PPOWER_USER_PRESENCE :: ^POWER_USER_PRESENCE; | |
| POWER_SESSION_CONNECT :: struct { | |
| Connected : BOOLEAN, | |
| Console : BOOLEAN, | |
| }; | |
| PPOWER_SESSION_CONNECT :: ^POWER_SESSION_CONNECT; | |
| POWER_SESSION_TIMEOUTS :: struct { | |
| InputTimeout : DWORD, | |
| DisplayTimeout : DWORD, | |
| }; | |
| PPOWER_SESSION_TIMEOUTS :: ^POWER_SESSION_TIMEOUTS; | |
| POWER_SESSION_RIT_STATE :: struct { | |
| Active : BOOLEAN, | |
| LastInputTime : DWORD, | |
| }; | |
| PPOWER_SESSION_RIT_STATE :: ^POWER_SESSION_RIT_STATE; | |
| POWER_SESSION_WINLOGON :: struct { | |
| SessionId : DWORD, | |
| Console : BOOLEAN, | |
| Locked : BOOLEAN, | |
| }; | |
| PPOWER_SESSION_WINLOGON :: ^POWER_SESSION_WINLOGON; | |
| POWER_IDLE_RESILIENCY :: struct { | |
| CoalescingTimeout : DWORD, | |
| IdleResiliencyPeriod : DWORD, | |
| }; | |
| PPOWER_IDLE_RESILIENCY :: ^POWER_IDLE_RESILIENCY; | |
| /* POWER_MONITOR_REQUEST_REASON :: enum { */ | |
| POWER_MONITOR_REQUEST_REASON :: _c.int; | |
| MonitorRequestReasonUnknown :: 0; | |
| MonitorRequestReasonPowerButton :: MonitorRequestReasonUnknown + 1; | |
| MonitorRequestReasonRemoteConnection :: MonitorRequestReasonPowerButton + 1; | |
| MonitorRequestReasonScMonitorpower :: MonitorRequestReasonRemoteConnection + 1; | |
| MonitorRequestReasonUserInput :: MonitorRequestReasonScMonitorpower + 1; | |
| MonitorRequestReasonAcDcDisplayBurst :: MonitorRequestReasonUserInput + 1; | |
| MonitorRequestReasonUserDisplayBurst :: MonitorRequestReasonAcDcDisplayBurst + 1; | |
| MonitorRequestReasonPoSetSystemState :: MonitorRequestReasonUserDisplayBurst + 1; | |
| MonitorRequestReasonSetThreadExecutionState :: MonitorRequestReasonPoSetSystemState + 1; | |
| MonitorRequestReasonFullWake :: MonitorRequestReasonSetThreadExecutionState + 1; | |
| MonitorRequestReasonSessionUnlock :: MonitorRequestReasonFullWake + 1; | |
| MonitorRequestReasonScreenOffRequest :: MonitorRequestReasonSessionUnlock + 1; | |
| MonitorRequestReasonIdleTimeout :: MonitorRequestReasonScreenOffRequest + 1; | |
| MonitorRequestReasonPolicyChange :: MonitorRequestReasonIdleTimeout + 1; | |
| MonitorRequestReasonSleepButton :: MonitorRequestReasonPolicyChange + 1; | |
| MonitorRequestReasonLid :: MonitorRequestReasonSleepButton + 1; | |
| MonitorRequestReasonBatteryCountChange :: MonitorRequestReasonLid + 1; | |
| MonitorRequestReasonGracePeriod :: MonitorRequestReasonBatteryCountChange + 1; | |
| MonitorRequestReasonPnP :: MonitorRequestReasonGracePeriod + 1; | |
| MonitorRequestReasonDP :: MonitorRequestReasonPnP + 1; | |
| MonitorRequestReasonSxTransition :: MonitorRequestReasonDP + 1; | |
| MonitorRequestReasonSystemIdle :: MonitorRequestReasonSxTransition + 1; | |
| MonitorRequestReasonNearProximity :: MonitorRequestReasonSystemIdle + 1; | |
| MonitorRequestReasonThermalStandby :: MonitorRequestReasonNearProximity + 1; | |
| MonitorRequestReasonResumePdc :: MonitorRequestReasonThermalStandby + 1; | |
| MonitorRequestReasonResumeS4 :: MonitorRequestReasonResumePdc + 1; | |
| MonitorRequestReasonTerminal :: MonitorRequestReasonResumeS4 + 1; | |
| MonitorRequestReasonPdcSignal :: MonitorRequestReasonTerminal + 1; | |
| MonitorRequestReasonAcDcDisplayBurstSuppressed :: MonitorRequestReasonPdcSignal + 1; | |
| MonitorRequestReasonSystemStateEntered :: MonitorRequestReasonAcDcDisplayBurstSuppressed + 1; | |
| MonitorRequestReasonWinrt :: MonitorRequestReasonSystemStateEntered + 1; | |
| MonitorRequestReasonUserInputKeyboard :: MonitorRequestReasonWinrt + 1; | |
| MonitorRequestReasonUserInputMouse :: MonitorRequestReasonUserInputKeyboard + 1; | |
| MonitorRequestReasonUserInputTouch :: MonitorRequestReasonUserInputMouse + 1; | |
| MonitorRequestReasonUserInputPen :: MonitorRequestReasonUserInputTouch + 1; | |
| MonitorRequestReasonUserInputAccelerometer :: MonitorRequestReasonUserInputPen + 1; | |
| MonitorRequestReasonUserInputHid :: MonitorRequestReasonUserInputAccelerometer + 1; | |
| MonitorRequestReasonUserInputPoUserPresent :: MonitorRequestReasonUserInputHid + 1; | |
| MonitorRequestReasonUserInputSessionSwitch :: MonitorRequestReasonUserInputPoUserPresent + 1; | |
| MonitorRequestReasonUserInputInitialization :: MonitorRequestReasonUserInputSessionSwitch + 1; | |
| MonitorRequestReasonPdcSignalWindowsMobilePwrNotif :: MonitorRequestReasonUserInputInitialization + 1; | |
| MonitorRequestReasonPdcSignalWindowsMobileShell :: MonitorRequestReasonPdcSignalWindowsMobilePwrNotif + 1; | |
| MonitorRequestReasonPdcSignalHeyCortana :: MonitorRequestReasonPdcSignalWindowsMobileShell + 1; | |
| MonitorRequestReasonPdcSignalHolographicShell :: MonitorRequestReasonPdcSignalHeyCortana + 1; | |
| MonitorRequestReasonPdcSignalFingerprint :: MonitorRequestReasonPdcSignalHolographicShell + 1; | |
| MonitorRequestReasonDirectedDrips :: MonitorRequestReasonPdcSignalFingerprint + 1; | |
| MonitorRequestReasonMax :: MonitorRequestReasonDirectedDrips + 1; | |
| /* } */ | |
| ; | |
| /* POWER_MONITOR_REQUEST_TYPE :: enum { */ | |
| POWER_MONITOR_REQUEST_TYPE :: _c.int; | |
| MonitorRequestTypeOff :: 0; | |
| MonitorRequestTypeOnAndPresent :: MonitorRequestTypeOff + 1; | |
| MonitorRequestTypeToggleOn :: MonitorRequestTypeOnAndPresent + 1; | |
| /* } */ | |
| ; | |
| POWER_MONITOR_INVOCATION :: struct { | |
| Console : BOOLEAN, | |
| RequestReason : POWER_MONITOR_REQUEST_REASON, | |
| }; | |
| PPOWER_MONITOR_INVOCATION :: ^POWER_MONITOR_INVOCATION; | |
| RESUME_PERFORMANCE :: struct { | |
| PostTimeMs : DWORD, | |
| TotalResumeTimeMs : ULONGLONG, | |
| ResumeCompleteTimestamp : ULONGLONG, | |
| }; | |
| PRESUME_PERFORMANCE :: ^RESUME_PERFORMANCE; | |
| /* SYSTEM_POWER_CONDITION :: enum { */ | |
| SYSTEM_POWER_CONDITION :: _c.int; | |
| PoAc :: 0; | |
| PoDc :: PoAc + 1; | |
| PoHot :: PoDc + 1; | |
| PoConditionMaximum :: PoHot + 1; | |
| /* } */ | |
| ; | |
| SET_POWER_SETTING_VALUE :: struct { | |
| Version : DWORD, | |
| Guid : GUID, | |
| PowerCondition : SYSTEM_POWER_CONDITION, | |
| DataLength : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PSET_POWER_SETTING_VALUE :: ^SET_POWER_SETTING_VALUE; | |
| NOTIFY_USER_POWER_SETTING :: struct { | |
| Guid : GUID, | |
| }; | |
| PNOTIFY_USER_POWER_SETTING :: ^NOTIFY_USER_POWER_SETTING; | |
| APPLICATIONLAUNCH_SETTING_VALUE :: struct { | |
| ActivationTime : LARGE_INTEGER, | |
| Flags : DWORD, | |
| ButtonInstanceID : DWORD, | |
| }; | |
| PAPPLICATIONLAUNCH_SETTING_VALUE :: ^APPLICATIONLAUNCH_SETTING_VALUE; | |
| /* POWER_PLATFORM_ROLE :: enum { */ | |
| POWER_PLATFORM_ROLE :: _c.int; | |
| PlatformRoleUnspecified :: 0; | |
| PlatformRoleDesktop :: PlatformRoleUnspecified + 1; | |
| PlatformRoleMobile :: PlatformRoleDesktop + 1; | |
| PlatformRoleWorkstation :: PlatformRoleMobile + 1; | |
| PlatformRoleEnterpriseServer :: PlatformRoleWorkstation + 1; | |
| PlatformRoleSOHOServer :: PlatformRoleEnterpriseServer + 1; | |
| PlatformRoleAppliancePC :: PlatformRoleSOHOServer + 1; | |
| PlatformRolePerformanceServer :: PlatformRoleAppliancePC + 1; | |
| PlatformRoleSlate :: PlatformRolePerformanceServer + 1; | |
| PlatformRoleMaximum :: PlatformRoleSlate + 1; | |
| /* } */ | |
| PPOWER_PLATFORM_ROLE :: ^POWER_PLATFORM_ROLE; | |
| POWER_PLATFORM_INFORMATION :: struct { | |
| AoAc : BOOLEAN, | |
| }; | |
| PPOWER_PLATFORM_INFORMATION :: ^POWER_PLATFORM_INFORMATION; | |
| BATTERY_REPORTING_SCALE :: struct { | |
| Granularity : DWORD, | |
| Capacity : DWORD, | |
| }; | |
| PBATTERY_REPORTING_SCALE :: ^BATTERY_REPORTING_SCALE; | |
| PPM_WMI_LEGACY_PERFSTATE :: struct { | |
| Frequency : DWORD, | |
| Flags : DWORD, | |
| PercentFrequency : DWORD, | |
| }; | |
| PPPM_WMI_LEGACY_PERFSTATE :: ^PPM_WMI_LEGACY_PERFSTATE; | |
| PPM_WMI_IDLE_STATE :: struct { | |
| Latency : DWORD, | |
| Power : DWORD, | |
| TimeCheck : DWORD, | |
| PromotePercent : BYTE, | |
| DemotePercent : BYTE, | |
| StateType : BYTE, | |
| Reserved : BYTE, | |
| StateFlags : DWORD, | |
| Context : DWORD, | |
| IdleHandler : DWORD, | |
| Reserved1 : DWORD, | |
| }; | |
| PPPM_WMI_IDLE_STATE :: ^PPM_WMI_IDLE_STATE; | |
| PPM_WMI_IDLE_STATES :: struct { | |
| Type : DWORD, | |
| Count : DWORD, | |
| TargetState : DWORD, | |
| OldState : DWORD, | |
| TargetProcessors : DWORD64, | |
| State : [1]PPM_WMI_IDLE_STATE, | |
| }; | |
| PPPM_WMI_IDLE_STATES :: ^PPM_WMI_IDLE_STATES; | |
| PPM_WMI_IDLE_STATES_EX :: struct { | |
| Type : DWORD, | |
| Count : DWORD, | |
| TargetState : DWORD, | |
| OldState : DWORD, | |
| TargetProcessors : PVOID, | |
| State : [1]PPM_WMI_IDLE_STATE, | |
| }; | |
| PPPM_WMI_IDLE_STATES_EX :: ^PPM_WMI_IDLE_STATES_EX; | |
| PPM_WMI_PERF_STATE :: struct { | |
| Frequency : DWORD, | |
| Power : DWORD, | |
| PercentFrequency : BYTE, | |
| IncreaseLevel : BYTE, | |
| DecreaseLevel : BYTE, | |
| Type : BYTE, | |
| IncreaseTime : DWORD, | |
| DecreaseTime : DWORD, | |
| Control : DWORD64, | |
| Status : DWORD64, | |
| HitCount : DWORD, | |
| Reserved1 : DWORD, | |
| Reserved2 : DWORD64, | |
| Reserved3 : DWORD64, | |
| }; | |
| PPPM_WMI_PERF_STATE :: ^PPM_WMI_PERF_STATE; | |
| PPM_WMI_PERF_STATES :: struct { | |
| Count : DWORD, | |
| MaxFrequency : DWORD, | |
| CurrentState : DWORD, | |
| MaxPerfState : DWORD, | |
| MinPerfState : DWORD, | |
| LowestPerfState : DWORD, | |
| ThermalConstraint : DWORD, | |
| BusyAdjThreshold : BYTE, | |
| PolicyType : BYTE, | |
| Type : BYTE, | |
| Reserved : BYTE, | |
| TimerInterval : DWORD, | |
| TargetProcessors : DWORD64, | |
| PStateHandler : DWORD, | |
| PStateContext : DWORD, | |
| TStateHandler : DWORD, | |
| TStateContext : DWORD, | |
| FeedbackHandler : DWORD, | |
| Reserved1 : DWORD, | |
| Reserved2 : DWORD64, | |
| State : [1]PPM_WMI_PERF_STATE, | |
| }; | |
| PPPM_WMI_PERF_STATES :: ^PPM_WMI_PERF_STATES; | |
| PPM_WMI_PERF_STATES_EX :: struct { | |
| Count : DWORD, | |
| MaxFrequency : DWORD, | |
| CurrentState : DWORD, | |
| MaxPerfState : DWORD, | |
| MinPerfState : DWORD, | |
| LowestPerfState : DWORD, | |
| ThermalConstraint : DWORD, | |
| BusyAdjThreshold : BYTE, | |
| PolicyType : BYTE, | |
| Type : BYTE, | |
| Reserved : BYTE, | |
| TimerInterval : DWORD, | |
| TargetProcessors : PVOID, | |
| PStateHandler : DWORD, | |
| PStateContext : DWORD, | |
| TStateHandler : DWORD, | |
| TStateContext : DWORD, | |
| FeedbackHandler : DWORD, | |
| Reserved1 : DWORD, | |
| Reserved2 : DWORD64, | |
| State : [1]PPM_WMI_PERF_STATE, | |
| }; | |
| PPPM_WMI_PERF_STATES_EX :: ^PPM_WMI_PERF_STATES_EX; | |
| PPM_IDLE_STATE_ACCOUNTING :: struct { | |
| IdleTransitions : DWORD, | |
| FailedTransitions : DWORD, | |
| InvalidBucketIndex : DWORD, | |
| TotalTime : DWORD64, | |
| IdleTimeBuckets : [6]DWORD, | |
| }; | |
| PPPM_IDLE_STATE_ACCOUNTING :: ^PPM_IDLE_STATE_ACCOUNTING; | |
| PPM_IDLE_ACCOUNTING :: struct { | |
| StateCount : DWORD, | |
| TotalTransitions : DWORD, | |
| ResetCount : DWORD, | |
| StartTime : DWORD64, | |
| State : [1]PPM_IDLE_STATE_ACCOUNTING, | |
| }; | |
| PPPM_IDLE_ACCOUNTING :: ^PPM_IDLE_ACCOUNTING; | |
| PPM_IDLE_STATE_BUCKET_EX :: struct { | |
| TotalTimeUs : DWORD64, | |
| MinTimeUs : DWORD, | |
| MaxTimeUs : DWORD, | |
| Count : DWORD, | |
| }; | |
| PPPM_IDLE_STATE_BUCKET_EX :: ^PPM_IDLE_STATE_BUCKET_EX; | |
| PPM_IDLE_STATE_ACCOUNTING_EX :: struct { | |
| TotalTime : DWORD64, | |
| IdleTransitions : DWORD, | |
| FailedTransitions : DWORD, | |
| InvalidBucketIndex : DWORD, | |
| MinTimeUs : DWORD, | |
| MaxTimeUs : DWORD, | |
| CancelledTransitions : DWORD, | |
| IdleTimeBuckets : [16]PPM_IDLE_STATE_BUCKET_EX, | |
| }; | |
| PPPM_IDLE_STATE_ACCOUNTING_EX :: ^PPM_IDLE_STATE_ACCOUNTING_EX; | |
| PPM_IDLE_ACCOUNTING_EX :: struct { | |
| StateCount : DWORD, | |
| TotalTransitions : DWORD, | |
| ResetCount : DWORD, | |
| AbortCount : DWORD, | |
| StartTime : DWORD64, | |
| State : [1]PPM_IDLE_STATE_ACCOUNTING_EX, | |
| }; | |
| PPPM_IDLE_ACCOUNTING_EX :: ^PPM_IDLE_ACCOUNTING_EX; | |
| PPM_PERFSTATE_EVENT :: struct { | |
| State : DWORD, | |
| Status : DWORD, | |
| Latency : DWORD, | |
| Speed : DWORD, | |
| Processor : DWORD, | |
| }; | |
| PPPM_PERFSTATE_EVENT :: ^PPM_PERFSTATE_EVENT; | |
| PPM_PERFSTATE_DOMAIN_EVENT :: struct { | |
| State : DWORD, | |
| Latency : DWORD, | |
| Speed : DWORD, | |
| Processors : DWORD64, | |
| }; | |
| PPPM_PERFSTATE_DOMAIN_EVENT :: ^PPM_PERFSTATE_DOMAIN_EVENT; | |
| PPM_IDLESTATE_EVENT :: struct { | |
| NewState : DWORD, | |
| OldState : DWORD, | |
| Processors : DWORD64, | |
| }; | |
| PPPM_IDLESTATE_EVENT :: ^PPM_IDLESTATE_EVENT; | |
| PPM_THERMALCHANGE_EVENT :: struct { | |
| ThermalConstraint : DWORD, | |
| Processors : DWORD64, | |
| }; | |
| PPPM_THERMALCHANGE_EVENT :: ^PPM_THERMALCHANGE_EVENT; | |
| PPM_THERMAL_POLICY_EVENT :: struct { | |
| Mode : BYTE, | |
| Processors : DWORD64, | |
| }; | |
| PPPM_THERMAL_POLICY_EVENT :: ^PPM_THERMAL_POLICY_EVENT; | |
| POWER_ACTION_POLICY :: struct { | |
| Action : POWER_ACTION, | |
| Flags : DWORD, | |
| EventCode : DWORD, | |
| }; | |
| PPOWER_ACTION_POLICY :: ^POWER_ACTION_POLICY; | |
| SYSTEM_POWER_LEVEL :: struct { | |
| Enable : BOOLEAN, | |
| Spare : [3]BYTE, | |
| BatteryLevel : DWORD, | |
| PowerPolicy : POWER_ACTION_POLICY, | |
| MinSystemState : SYSTEM_POWER_STATE, | |
| }; | |
| PSYSTEM_POWER_LEVEL :: ^SYSTEM_POWER_LEVEL; | |
| SYSTEM_POWER_POLICY :: struct { | |
| Revision : DWORD, | |
| PowerButton : POWER_ACTION_POLICY, | |
| SleepButton : POWER_ACTION_POLICY, | |
| LidClose : POWER_ACTION_POLICY, | |
| LidOpenWake : SYSTEM_POWER_STATE, | |
| Reserved : DWORD, | |
| Idle : POWER_ACTION_POLICY, | |
| IdleTimeout : DWORD, | |
| IdleSensitivity : BYTE, | |
| DynamicThrottle : BYTE, | |
| Spare2 : [2]BYTE, | |
| MinSleep : SYSTEM_POWER_STATE, | |
| MaxSleep : SYSTEM_POWER_STATE, | |
| ReducedLatencySleep : SYSTEM_POWER_STATE, | |
| WinLogonFlags : DWORD, | |
| Spare3 : DWORD, | |
| DozeS4Timeout : DWORD, | |
| BroadcastCapacityResolution : DWORD, | |
| DischargePolicy : [4]SYSTEM_POWER_LEVEL, | |
| VideoTimeout : DWORD, | |
| VideoDimDisplay : BOOLEAN, | |
| VideoReserved : [3]DWORD, | |
| SpindownTimeout : DWORD, | |
| OptimizeForPower : BOOLEAN, | |
| FanThrottleTolerance : BYTE, | |
| ForcedThrottle : BYTE, | |
| MinThrottle : BYTE, | |
| OverThrottled : POWER_ACTION_POLICY, | |
| }; | |
| PSYSTEM_POWER_POLICY :: ^SYSTEM_POWER_POLICY; | |
| PROCESSOR_IDLESTATE_INFO :: struct { | |
| TimeCheck : DWORD, | |
| DemotePercent : BYTE, | |
| PromotePercent : BYTE, | |
| Spare : [2]BYTE, | |
| }; | |
| PPROCESSOR_IDLESTATE_INFO :: ^PROCESSOR_IDLESTATE_INFO; | |
| PROCESSOR_IDLESTATE_POLICY :: struct { | |
| Revision : WORD, | |
| Flags : struct #raw_union { | |
| AsWORD : WORD, | |
| s : bit_field { | |
| AllowScaling : 1, | |
| Disabled : 1, | |
| Reserved : 14, | |
| }, | |
| }, | |
| PolicyCount : DWORD, | |
| Policy : [0x3]PROCESSOR_IDLESTATE_INFO, | |
| }; | |
| PPROCESSOR_IDLESTATE_POLICY :: ^PROCESSOR_IDLESTATE_POLICY; | |
| PROCESSOR_POWER_POLICY_INFO :: struct { | |
| TimeCheck : DWORD, | |
| DemoteLimit : DWORD, | |
| PromoteLimit : DWORD, | |
| DemotePercent : BYTE, | |
| PromotePercent : BYTE, | |
| Spare : [2]BYTE, | |
| using _ : bit_field { | |
| AllowDemotion : 1, | |
| AllowPromotion : 1, | |
| Reserved : 30, | |
| }, | |
| }; | |
| PPROCESSOR_POWER_POLICY_INFO :: ^PROCESSOR_POWER_POLICY_INFO; | |
| PROCESSOR_POWER_POLICY :: struct { | |
| Revision : DWORD, | |
| DynamicThrottle : BYTE, | |
| Spare : [3]BYTE, | |
| using _ : bit_field { | |
| DisableCStates : 1, | |
| Reserved : 31, | |
| }, | |
| PolicyCount : DWORD, | |
| Policy : [3]PROCESSOR_POWER_POLICY_INFO, | |
| }; | |
| PPROCESSOR_POWER_POLICY :: ^PROCESSOR_POWER_POLICY; | |
| PROCESSOR_PERFSTATE_POLICY :: struct { | |
| Revision : DWORD, | |
| MaxThrottle : BYTE, | |
| MinThrottle : BYTE, | |
| BusyAdjThreshold : BYTE, | |
| u : struct #raw_union { | |
| Spare : BYTE, | |
| Flags : struct #raw_union { | |
| AsBYTE : BYTE, | |
| s : bit_field { | |
| NoDomainAccounting : 1, | |
| IncreasePolicy : 2, | |
| DecreasePolicy : 2, | |
| Reserved : 3, | |
| }, | |
| }, | |
| }, | |
| TimeCheck : DWORD, | |
| IncreaseTime : DWORD, | |
| DecreaseTime : DWORD, | |
| IncreasePercent : DWORD, | |
| DecreasePercent : DWORD, | |
| }; | |
| PPROCESSOR_PERFSTATE_POLICY :: ^PROCESSOR_PERFSTATE_POLICY; | |
| ADMINISTRATOR_POWER_POLICY :: struct { | |
| MinSleep : SYSTEM_POWER_STATE, | |
| MaxSleep : SYSTEM_POWER_STATE, | |
| MinVideoTimeout : DWORD, | |
| MaxVideoTimeout : DWORD, | |
| MinSpindownTimeout : DWORD, | |
| MaxSpindownTimeout : DWORD, | |
| }; | |
| PADMINISTRATOR_POWER_POLICY :: ^ADMINISTRATOR_POWER_POLICY; | |
| /* HIBERFILE_BUCKET_SIZE :: enum { */ | |
| HIBERFILE_BUCKET_SIZE :: _c.int; | |
| HiberFileBucket1GB :: 0; | |
| HiberFileBucket2GB :: HiberFileBucket1GB + 1; | |
| HiberFileBucket4GB :: HiberFileBucket2GB + 1; | |
| HiberFileBucket8GB :: HiberFileBucket4GB + 1; | |
| HiberFileBucket16GB :: HiberFileBucket8GB + 1; | |
| HiberFileBucket32GB :: HiberFileBucket16GB + 1; | |
| HiberFileBucketUnlimited :: HiberFileBucket32GB + 1; | |
| HiberFileBucketMax :: HiberFileBucketUnlimited + 1; | |
| /* } */ | |
| PHIBERFILE_BUCKET_SIZE :: ^HIBERFILE_BUCKET_SIZE; | |
| HIBERFILE_BUCKET :: struct { | |
| MaxPhysicalMemory : DWORD64, | |
| PhysicalMemoryPercent : [0x03]DWORD, | |
| }; | |
| PHIBERFILE_BUCKET :: ^HIBERFILE_BUCKET; | |
| SYSTEM_POWER_CAPABILITIES :: struct { | |
| PowerButtonPresent : BOOLEAN, | |
| SleepButtonPresent : BOOLEAN, | |
| LidPresent : BOOLEAN, | |
| SystemS1 : BOOLEAN, | |
| SystemS2 : BOOLEAN, | |
| SystemS3 : BOOLEAN, | |
| SystemS4 : BOOLEAN, | |
| SystemS5 : BOOLEAN, | |
| HiberFilePresent : BOOLEAN, | |
| FullWake : BOOLEAN, | |
| VideoDimPresent : BOOLEAN, | |
| ApmPresent : BOOLEAN, | |
| UpsPresent : BOOLEAN, | |
| ThermalControl : BOOLEAN, | |
| ProcessorThrottle : BOOLEAN, | |
| ProcessorMinThrottle : BYTE, | |
| ProcessorMaxThrottle : BYTE, | |
| FastSystemS4 : BOOLEAN, | |
| Hiberboot : BOOLEAN, | |
| WakeAlarmPresent : BOOLEAN, | |
| AoAc : BOOLEAN, | |
| DiskSpinDown : BOOLEAN, | |
| HiberFileType : BYTE, | |
| AoAcConnectivitySupported : BOOLEAN, | |
| spare3 : [6]BYTE, | |
| SystemBatteriesPresent : BOOLEAN, | |
| BatteriesAreShortTerm : BOOLEAN, | |
| BatteryScale : [3]BATTERY_REPORTING_SCALE, | |
| AcOnLineWake : SYSTEM_POWER_STATE, | |
| SoftLidWake : SYSTEM_POWER_STATE, | |
| RtcWake : SYSTEM_POWER_STATE, | |
| MinDeviceWakeState : SYSTEM_POWER_STATE, | |
| DefaultLowLatencyWake : SYSTEM_POWER_STATE, | |
| }; | |
| PSYSTEM_POWER_CAPABILITIES :: ^SYSTEM_POWER_CAPABILITIES; | |
| SYSTEM_BATTERY_STATE :: struct { | |
| AcOnLine : BOOLEAN, | |
| BatteryPresent : BOOLEAN, | |
| Charging : BOOLEAN, | |
| Discharging : BOOLEAN, | |
| Spare1 : [3]BOOLEAN, | |
| Tag : BYTE, | |
| MaxCapacity : DWORD, | |
| RemainingCapacity : DWORD, | |
| Rate : DWORD, | |
| EstimatedTime : DWORD, | |
| DefaultAlert1 : DWORD, | |
| DefaultAlert2 : DWORD, | |
| }; | |
| PSYSTEM_BATTERY_STATE :: ^SYSTEM_BATTERY_STATE; | |
| IMAGE_DOS_HEADER :: struct { | |
| e_magic : WORD, | |
| e_cblp : WORD, | |
| e_cp : WORD, | |
| e_crlc : WORD, | |
| e_cparhdr : WORD, | |
| e_minalloc : WORD, | |
| e_maxalloc : WORD, | |
| e_ss : WORD, | |
| e_sp : WORD, | |
| e_csum : WORD, | |
| e_ip : WORD, | |
| e_cs : WORD, | |
| e_lfarlc : WORD, | |
| e_ovno : WORD, | |
| e_res : [4]WORD, | |
| e_oemid : WORD, | |
| e_oeminfo : WORD, | |
| e_res2 : [10]WORD, | |
| e_lfanew : LONG, | |
| }; | |
| PIMAGE_DOS_HEADER :: ^IMAGE_DOS_HEADER; | |
| IMAGE_OS2_HEADER :: struct { | |
| ne_magic : WORD, | |
| ne_ver : CHAR, | |
| ne_rev : CHAR, | |
| ne_enttab : WORD, | |
| ne_cbenttab : WORD, | |
| ne_crc : LONG, | |
| ne_flags : WORD, | |
| ne_autodata : WORD, | |
| ne_heap : WORD, | |
| ne_stack : WORD, | |
| ne_csip : LONG, | |
| ne_sssp : LONG, | |
| ne_cseg : WORD, | |
| ne_cmod : WORD, | |
| ne_cbnrestab : WORD, | |
| ne_segtab : WORD, | |
| ne_rsrctab : WORD, | |
| ne_restab : WORD, | |
| ne_modtab : WORD, | |
| ne_imptab : WORD, | |
| ne_nrestab : LONG, | |
| ne_cmovent : WORD, | |
| ne_align : WORD, | |
| ne_cres : WORD, | |
| ne_exetyp : BYTE, | |
| ne_flagsothers : BYTE, | |
| ne_pretthunks : WORD, | |
| ne_psegrefbytes : WORD, | |
| ne_swaparea : WORD, | |
| ne_expver : WORD, | |
| }; | |
| PIMAGE_OS2_HEADER :: ^IMAGE_OS2_HEADER; | |
| IMAGE_VXD_HEADER :: struct { | |
| e32_magic : WORD, | |
| e32_border : BYTE, | |
| e32_worder : BYTE, | |
| e32_level : DWORD, | |
| e32_cpu : WORD, | |
| e32_os : WORD, | |
| e32_ver : DWORD, | |
| e32_mflags : DWORD, | |
| e32_mpages : DWORD, | |
| e32_startobj : DWORD, | |
| e32_eip : DWORD, | |
| e32_stackobj : DWORD, | |
| e32_esp : DWORD, | |
| e32_pagesize : DWORD, | |
| e32_lastpagesize : DWORD, | |
| e32_fixupsize : DWORD, | |
| e32_fixupsum : DWORD, | |
| e32_ldrsize : DWORD, | |
| e32_ldrsum : DWORD, | |
| e32_objtab : DWORD, | |
| e32_objcnt : DWORD, | |
| e32_objmap : DWORD, | |
| e32_itermap : DWORD, | |
| e32_rsrctab : DWORD, | |
| e32_rsrccnt : DWORD, | |
| e32_restab : DWORD, | |
| e32_enttab : DWORD, | |
| e32_dirtab : DWORD, | |
| e32_dircnt : DWORD, | |
| e32_fpagetab : DWORD, | |
| e32_frectab : DWORD, | |
| e32_impmod : DWORD, | |
| e32_impmodcnt : DWORD, | |
| e32_impproc : DWORD, | |
| e32_pagesum : DWORD, | |
| e32_datapage : DWORD, | |
| e32_preload : DWORD, | |
| e32_nrestab : DWORD, | |
| e32_cbnrestab : DWORD, | |
| e32_nressum : DWORD, | |
| e32_autodata : DWORD, | |
| e32_debuginfo : DWORD, | |
| e32_debuglen : DWORD, | |
| e32_instpreload : DWORD, | |
| e32_instdemand : DWORD, | |
| e32_heapsize : DWORD, | |
| e32_res3 : [12]BYTE, | |
| e32_winresoff : DWORD, | |
| e32_winreslen : DWORD, | |
| e32_devid : WORD, | |
| e32_ddkver : WORD, | |
| }; | |
| PIMAGE_VXD_HEADER :: ^IMAGE_VXD_HEADER; | |
| IMAGE_FILE_HEADER :: struct { | |
| Machine : WORD, | |
| NumberOfSections : WORD, | |
| TimeDateStamp : DWORD, | |
| PointerToSymbolTable : DWORD, | |
| NumberOfSymbols : DWORD, | |
| SizeOfOptionalHeader : WORD, | |
| Characteristics : WORD, | |
| }; | |
| PIMAGE_FILE_HEADER :: ^IMAGE_FILE_HEADER; | |
| IMAGE_DATA_DIRECTORY :: struct { | |
| VirtualAddress : DWORD, | |
| Size : DWORD, | |
| }; | |
| PIMAGE_DATA_DIRECTORY :: ^IMAGE_DATA_DIRECTORY; | |
| IMAGE_OPTIONAL_HEADER32 :: struct { | |
| Magic : WORD, | |
| MajorLinkerVersion : BYTE, | |
| MinorLinkerVersion : BYTE, | |
| SizeOfCode : DWORD, | |
| SizeOfInitializedData : DWORD, | |
| SizeOfUninitializedData : DWORD, | |
| AddressOfEntryPoint : DWORD, | |
| BaseOfCode : DWORD, | |
| BaseOfData : DWORD, | |
| ImageBase : DWORD, | |
| SectionAlignment : DWORD, | |
| FileAlignment : DWORD, | |
| MajorOperatingSystemVersion : WORD, | |
| MinorOperatingSystemVersion : WORD, | |
| MajorImageVersion : WORD, | |
| MinorImageVersion : WORD, | |
| MajorSubsystemVersion : WORD, | |
| MinorSubsystemVersion : WORD, | |
| Win32VersionValue : DWORD, | |
| SizeOfImage : DWORD, | |
| SizeOfHeaders : DWORD, | |
| CheckSum : DWORD, | |
| Subsystem : WORD, | |
| DllCharacteristics : WORD, | |
| SizeOfStackReserve : DWORD, | |
| SizeOfStackCommit : DWORD, | |
| SizeOfHeapReserve : DWORD, | |
| SizeOfHeapCommit : DWORD, | |
| LoaderFlags : DWORD, | |
| NumberOfRvaAndSizes : DWORD, | |
| DataDirectory : [16]IMAGE_DATA_DIRECTORY, | |
| }; | |
| PIMAGE_OPTIONAL_HEADER32 :: ^IMAGE_OPTIONAL_HEADER32; | |
| IMAGE_ROM_OPTIONAL_HEADER :: struct { | |
| Magic : WORD, | |
| MajorLinkerVersion : BYTE, | |
| MinorLinkerVersion : BYTE, | |
| SizeOfCode : DWORD, | |
| SizeOfInitializedData : DWORD, | |
| SizeOfUninitializedData : DWORD, | |
| AddressOfEntryPoint : DWORD, | |
| BaseOfCode : DWORD, | |
| BaseOfData : DWORD, | |
| BaseOfBss : DWORD, | |
| GprMask : DWORD, | |
| CprMask : [4]DWORD, | |
| GpValue : DWORD, | |
| }; | |
| PIMAGE_ROM_OPTIONAL_HEADER :: ^IMAGE_ROM_OPTIONAL_HEADER; | |
| IMAGE_OPTIONAL_HEADER64 :: struct { | |
| Magic : WORD, | |
| MajorLinkerVersion : BYTE, | |
| MinorLinkerVersion : BYTE, | |
| SizeOfCode : DWORD, | |
| SizeOfInitializedData : DWORD, | |
| SizeOfUninitializedData : DWORD, | |
| AddressOfEntryPoint : DWORD, | |
| BaseOfCode : DWORD, | |
| ImageBase : ULONGLONG, | |
| SectionAlignment : DWORD, | |
| FileAlignment : DWORD, | |
| MajorOperatingSystemVersion : WORD, | |
| MinorOperatingSystemVersion : WORD, | |
| MajorImageVersion : WORD, | |
| MinorImageVersion : WORD, | |
| MajorSubsystemVersion : WORD, | |
| MinorSubsystemVersion : WORD, | |
| Win32VersionValue : DWORD, | |
| SizeOfImage : DWORD, | |
| SizeOfHeaders : DWORD, | |
| CheckSum : DWORD, | |
| Subsystem : WORD, | |
| DllCharacteristics : WORD, | |
| SizeOfStackReserve : ULONGLONG, | |
| SizeOfStackCommit : ULONGLONG, | |
| SizeOfHeapReserve : ULONGLONG, | |
| SizeOfHeapCommit : ULONGLONG, | |
| LoaderFlags : DWORD, | |
| NumberOfRvaAndSizes : DWORD, | |
| DataDirectory : [16]IMAGE_DATA_DIRECTORY, | |
| }; | |
| PIMAGE_OPTIONAL_HEADER64 :: ^IMAGE_OPTIONAL_HEADER64; | |
| IMAGE_OPTIONAL_HEADER :: IMAGE_OPTIONAL_HEADER64; | |
| PIMAGE_OPTIONAL_HEADER :: PIMAGE_OPTIONAL_HEADER64; | |
| IMAGE_NT_HEADERS64 :: struct { | |
| Signature : DWORD, | |
| FileHeader : IMAGE_FILE_HEADER, | |
| OptionalHeader : IMAGE_OPTIONAL_HEADER64, | |
| }; | |
| PIMAGE_NT_HEADERS64 :: ^IMAGE_NT_HEADERS64; | |
| IMAGE_NT_HEADERS32 :: struct { | |
| Signature : DWORD, | |
| FileHeader : IMAGE_FILE_HEADER, | |
| OptionalHeader : IMAGE_OPTIONAL_HEADER32, | |
| }; | |
| PIMAGE_NT_HEADERS32 :: ^IMAGE_NT_HEADERS32; | |
| IMAGE_ROM_HEADERS :: struct { | |
| FileHeader : IMAGE_FILE_HEADER, | |
| OptionalHeader : IMAGE_ROM_OPTIONAL_HEADER, | |
| }; | |
| PIMAGE_ROM_HEADERS :: ^IMAGE_ROM_HEADERS; | |
| IMAGE_NT_HEADERS :: IMAGE_NT_HEADERS64; | |
| PIMAGE_NT_HEADERS :: PIMAGE_NT_HEADERS64; | |
| ANON_OBJECT_HEADER :: struct { | |
| Sig1 : WORD, | |
| Sig2 : WORD, | |
| Version : WORD, | |
| Machine : WORD, | |
| TimeDateStamp : DWORD, | |
| ClassID : CLSID, | |
| SizeOfData : DWORD, | |
| }; | |
| ANON_OBJECT_HEADER_V2 :: struct { | |
| Sig1 : WORD, | |
| Sig2 : WORD, | |
| Version : WORD, | |
| Machine : WORD, | |
| TimeDateStamp : DWORD, | |
| ClassID : CLSID, | |
| SizeOfData : DWORD, | |
| Flags : DWORD, | |
| MetaDataSize : DWORD, | |
| MetaDataOffset : DWORD, | |
| }; | |
| ANON_OBJECT_HEADER_BIGOBJ :: struct { | |
| Sig1 : WORD, | |
| Sig2 : WORD, | |
| Version : WORD, | |
| Machine : WORD, | |
| TimeDateStamp : DWORD, | |
| ClassID : CLSID, | |
| SizeOfData : DWORD, | |
| Flags : DWORD, | |
| MetaDataSize : DWORD, | |
| MetaDataOffset : DWORD, | |
| NumberOfSections : DWORD, | |
| PointerToSymbolTable : DWORD, | |
| NumberOfSymbols : DWORD, | |
| }; | |
| IMAGE_SECTION_HEADER :: struct { | |
| Name : [8]BYTE, | |
| Misc : struct #raw_union { | |
| PhysicalAddress : DWORD, | |
| VirtualSize : DWORD, | |
| }, | |
| VirtualAddress : DWORD, | |
| SizeOfRawData : DWORD, | |
| PointerToRawData : DWORD, | |
| PointerToRelocations : DWORD, | |
| PointerToLinenumbers : DWORD, | |
| NumberOfRelocations : WORD, | |
| NumberOfLinenumbers : WORD, | |
| Characteristics : DWORD, | |
| }; | |
| PIMAGE_SECTION_HEADER :: ^IMAGE_SECTION_HEADER; | |
| IMAGE_SYMBOL :: struct { | |
| N : struct #raw_union { | |
| ShortName : [8]BYTE, | |
| Name : struct { | |
| Short : DWORD, | |
| Long : DWORD, | |
| }, | |
| LongName : [2]DWORD, | |
| }, | |
| Value : DWORD, | |
| SectionNumber : SHORT, | |
| Type : WORD, | |
| StorageClass : BYTE, | |
| NumberOfAuxSymbols : BYTE, | |
| }; | |
| PIMAGE_SYMBOL :: ^IMAGE_SYMBOL; | |
| IMAGE_SYMBOL_EX :: struct { | |
| N : struct #raw_union { | |
| ShortName : [8]BYTE, | |
| Name : struct { | |
| Short : DWORD, | |
| Long : DWORD, | |
| }, | |
| LongName : [2]DWORD, | |
| }, | |
| Value : DWORD, | |
| SectionNumber : LONG, | |
| Type : WORD, | |
| StorageClass : BYTE, | |
| NumberOfAuxSymbols : BYTE, | |
| }; | |
| PIMAGE_SYMBOL_EX :: ^IMAGE_SYMBOL_EX; | |
| IMAGE_AUX_SYMBOL_TOKEN_DEF :: struct { | |
| bAuxType : BYTE, | |
| bReserved : BYTE, | |
| SymbolTableIndex : DWORD, | |
| rgbReserved : [12]BYTE, | |
| }; | |
| PIMAGE_AUX_SYMBOL_TOKEN_DEF :: ^IMAGE_AUX_SYMBOL_TOKEN_DEF; | |
| IMAGE_AUX_SYMBOL :: struct #raw_union { | |
| Sym : struct { | |
| TagIndex : DWORD, | |
| Misc : struct #raw_union { | |
| LnSz : struct { | |
| Linenumber : WORD, | |
| Size : WORD, | |
| }, | |
| TotalSize : DWORD, | |
| }, | |
| FcnAry : struct #raw_union { | |
| Function : struct { | |
| PointerToLinenumber : DWORD, | |
| PointerToNextFunction : DWORD, | |
| }, | |
| Array : struct { | |
| Dimension : [4]WORD, | |
| }, | |
| }, | |
| TvIndex : WORD, | |
| }, | |
| File : struct { | |
| Name : [18]BYTE, | |
| }, | |
| Section : struct { | |
| Length : DWORD, | |
| NumberOfRelocations : WORD, | |
| NumberOfLinenumbers : WORD, | |
| CheckSum : DWORD, | |
| Number : SHORT, | |
| Selection : BYTE, | |
| bReserved : BYTE, | |
| HighNumber : SHORT, | |
| }, | |
| TokenDef : IMAGE_AUX_SYMBOL_TOKEN_DEF, | |
| CRC : struct { | |
| crc : DWORD, | |
| rgbReserved : [14]BYTE, | |
| }, | |
| }; | |
| PIMAGE_AUX_SYMBOL :: ^IMAGE_AUX_SYMBOL; | |
| IMAGE_AUX_SYMBOL_EX :: struct #raw_union { | |
| Sym : struct { | |
| WeakDefaultSymIndex : DWORD, | |
| WeakSearchType : DWORD, | |
| rgbReserved : [12]BYTE, | |
| }, | |
| File : struct { | |
| Name : [size_of(IMAGE_SYMBOL_EX)]BYTE, | |
| }, | |
| Section : struct { | |
| Length : DWORD, | |
| NumberOfRelocations : WORD, | |
| NumberOfLinenumbers : WORD, | |
| CheckSum : DWORD, | |
| Number : SHORT, | |
| Selection : BYTE, | |
| bReserved : BYTE, | |
| HighNumber : SHORT, | |
| rgbReserved : [2]BYTE, | |
| }, | |
| s : struct { | |
| TokenDef : IMAGE_AUX_SYMBOL_TOKEN_DEF, | |
| rgbReserved : [2]BYTE, | |
| }, | |
| CRC : struct { | |
| crc : DWORD, | |
| rgbReserved : [16]BYTE, | |
| }, | |
| }; | |
| PIMAGE_AUX_SYMBOL_EX :: ^IMAGE_AUX_SYMBOL_EX; | |
| /* IMAGE_AUX_SYMBOL_TYPE :: enum { */ | |
| IMAGE_AUX_SYMBOL_TYPE :: _c.int; | |
| IMAGE_AUX_SYMBOL_TYPE_TOKEN_DEF :: 1; | |
| /* } */ | |
| ; | |
| IMAGE_RELOCATION :: struct { | |
| u : struct #raw_union { | |
| VirtualAddress : DWORD, | |
| RelocCount : DWORD, | |
| }, | |
| SymbolTableIndex : DWORD, | |
| Type : WORD, | |
| }; | |
| PIMAGE_RELOCATION :: ^IMAGE_RELOCATION; | |
| IMAGE_LINENUMBER :: struct { | |
| Type : struct #raw_union { | |
| SymbolTableIndex : DWORD, | |
| VirtualAddress : DWORD, | |
| }, | |
| Linenumber : WORD, | |
| }; | |
| PIMAGE_LINENUMBER :: ^IMAGE_LINENUMBER; | |
| IMAGE_BASE_RELOCATION :: struct { | |
| VirtualAddress : DWORD, | |
| SizeOfBlock : DWORD, | |
| }; | |
| PIMAGE_BASE_RELOCATION :: ^IMAGE_BASE_RELOCATION; | |
| IMAGE_ARCHIVE_MEMBER_HEADER :: struct { | |
| Name : [16]BYTE, | |
| Date : [12]BYTE, | |
| UserID : [6]BYTE, | |
| GroupID : [6]BYTE, | |
| Mode : [8]BYTE, | |
| Size : [10]BYTE, | |
| EndHeader : [2]BYTE, | |
| }; | |
| PIMAGE_ARCHIVE_MEMBER_HEADER :: ^IMAGE_ARCHIVE_MEMBER_HEADER; | |
| IMAGE_EXPORT_DIRECTORY :: struct { | |
| Characteristics : DWORD, | |
| TimeDateStamp : DWORD, | |
| MajorVersion : WORD, | |
| MinorVersion : WORD, | |
| Name : DWORD, | |
| Base : DWORD, | |
| NumberOfFunctions : DWORD, | |
| NumberOfNames : DWORD, | |
| AddressOfFunctions : DWORD, | |
| AddressOfNames : DWORD, | |
| AddressOfNameOrdinals : DWORD, | |
| }; | |
| PIMAGE_EXPORT_DIRECTORY :: ^IMAGE_EXPORT_DIRECTORY; | |
| IMAGE_IMPORT_BY_NAME :: struct { | |
| Hint : WORD, | |
| Name : [1]CHAR, | |
| }; | |
| PIMAGE_IMPORT_BY_NAME :: ^IMAGE_IMPORT_BY_NAME; | |
| IMAGE_THUNK_DATA64 :: struct { | |
| u1 : struct #raw_union { | |
| ForwarderString : ULONGLONG, | |
| Function : ULONGLONG, | |
| Ordinal : ULONGLONG, | |
| AddressOfData : ULONGLONG, | |
| }, | |
| }; | |
| PIMAGE_THUNK_DATA64 :: ^IMAGE_THUNK_DATA64; | |
| IMAGE_THUNK_DATA32 :: struct { | |
| u1 : struct #raw_union { | |
| ForwarderString : DWORD, | |
| Function : DWORD, | |
| Ordinal : DWORD, | |
| AddressOfData : DWORD, | |
| }, | |
| }; | |
| PIMAGE_THUNK_DATA32 :: ^IMAGE_THUNK_DATA32; | |
| PIMAGE_TLS_CALLBACK :: proc "stdcall" (DllHandle : PVOID, Reason : DWORD, Reserved : PVOID); | |
| IMAGE_TLS_DIRECTORY64 :: struct { | |
| StartAddressOfRawData : ULONGLONG, | |
| EndAddressOfRawData : ULONGLONG, | |
| AddressOfIndex : ULONGLONG, | |
| AddressOfCallBacks : ULONGLONG, | |
| SizeOfZeroFill : DWORD, | |
| u : struct #raw_union { | |
| Characteristics : DWORD, | |
| s : bit_field { | |
| Reserved0 : 20, | |
| Alignment : 4, | |
| Reserved1 : 8, | |
| }, | |
| }, | |
| }; | |
| PIMAGE_TLS_DIRECTORY64 :: ^IMAGE_TLS_DIRECTORY64; | |
| IMAGE_TLS_DIRECTORY32 :: struct { | |
| StartAddressOfRawData : DWORD, | |
| EndAddressOfRawData : DWORD, | |
| AddressOfIndex : DWORD, | |
| AddressOfCallBacks : DWORD, | |
| SizeOfZeroFill : DWORD, | |
| u : struct #raw_union { | |
| Characteristics : DWORD, | |
| s : bit_field { | |
| Reserved0 : 20, | |
| Alignment : 4, | |
| Reserved1 : 8, | |
| }, | |
| }, | |
| }; | |
| PIMAGE_TLS_DIRECTORY32 :: ^IMAGE_TLS_DIRECTORY32; | |
| IMAGE_THUNK_DATA :: IMAGE_THUNK_DATA64; | |
| PIMAGE_THUNK_DATA :: PIMAGE_THUNK_DATA64; | |
| IMAGE_TLS_DIRECTORY :: IMAGE_TLS_DIRECTORY64; | |
| PIMAGE_TLS_DIRECTORY :: PIMAGE_TLS_DIRECTORY64; | |
| IMAGE_IMPORT_DESCRIPTOR :: struct { | |
| u : struct #raw_union { | |
| Characteristics : DWORD, | |
| OriginalFirstThunk : DWORD, | |
| }, | |
| TimeDateStamp : DWORD, | |
| ForwarderChain : DWORD, | |
| Name : DWORD, | |
| FirstThunk : DWORD, | |
| }; | |
| PIMAGE_IMPORT_DESCRIPTOR :: ^IMAGE_IMPORT_DESCRIPTOR; | |
| IMAGE_BOUND_IMPORT_DESCRIPTOR :: struct { | |
| TimeDateStamp : DWORD, | |
| OffsetModuleName : WORD, | |
| NumberOfModuleForwarderRefs : WORD, | |
| }; | |
| PIMAGE_BOUND_IMPORT_DESCRIPTOR :: ^IMAGE_BOUND_IMPORT_DESCRIPTOR; | |
| IMAGE_BOUND_FORWARDER_REF :: struct { | |
| TimeDateStamp : DWORD, | |
| OffsetModuleName : WORD, | |
| Reserved : WORD, | |
| }; | |
| PIMAGE_BOUND_FORWARDER_REF :: ^IMAGE_BOUND_FORWARDER_REF; | |
| IMAGE_DELAYLOAD_DESCRIPTOR :: struct { | |
| Attributes : struct #raw_union { | |
| AllAttributes : DWORD, | |
| s : bit_field { | |
| RvaBased : 1, | |
| ReservedAttributes : 31, | |
| }, | |
| }, | |
| DllNameRVA : DWORD, | |
| ModuleHandleRVA : DWORD, | |
| ImportAddressTableRVA : DWORD, | |
| ImportNameTableRVA : DWORD, | |
| BoundImportAddressTableRVA : DWORD, | |
| UnloadInformationTableRVA : DWORD, | |
| TimeDateStamp : DWORD, | |
| }; | |
| PIMAGE_DELAYLOAD_DESCRIPTOR :: ^IMAGE_DELAYLOAD_DESCRIPTOR; | |
| PCIMAGE_DELAYLOAD_DESCRIPTOR :: ^IMAGE_DELAYLOAD_DESCRIPTOR; | |
| IMAGE_RESOURCE_DIRECTORY :: struct { | |
| Characteristics : DWORD, | |
| TimeDateStamp : DWORD, | |
| MajorVersion : WORD, | |
| MinorVersion : WORD, | |
| NumberOfNamedEntries : WORD, | |
| NumberOfIdEntries : WORD, | |
| }; | |
| PIMAGE_RESOURCE_DIRECTORY :: ^IMAGE_RESOURCE_DIRECTORY; | |
| IMAGE_RESOURCE_DIRECTORY_ENTRY :: struct { | |
| u : struct #raw_union { | |
| s : bit_field { | |
| NameOffset : 31, | |
| NameIsString : 1, | |
| }, | |
| Name : DWORD, | |
| Id : WORD, | |
| }, | |
| u2 : struct #raw_union { | |
| OffsetToData : DWORD, | |
| s2 : bit_field { | |
| OffsetToDirectory : 31, | |
| DataIsDirectory : 1, | |
| }, | |
| }, | |
| }; | |
| PIMAGE_RESOURCE_DIRECTORY_ENTRY :: ^IMAGE_RESOURCE_DIRECTORY_ENTRY; | |
| IMAGE_RESOURCE_DIRECTORY_STRING :: struct { | |
| Length : WORD, | |
| NameString : [1]CHAR, | |
| }; | |
| PIMAGE_RESOURCE_DIRECTORY_STRING :: ^IMAGE_RESOURCE_DIRECTORY_STRING; | |
| IMAGE_RESOURCE_DIR_STRING_U :: struct { | |
| Length : WORD, | |
| NameString : [1]WCHAR, | |
| }; | |
| PIMAGE_RESOURCE_DIR_STRING_U :: ^IMAGE_RESOURCE_DIR_STRING_U; | |
| IMAGE_RESOURCE_DATA_ENTRY :: struct { | |
| OffsetToData : DWORD, | |
| Size : DWORD, | |
| CodePage : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PIMAGE_RESOURCE_DATA_ENTRY :: ^IMAGE_RESOURCE_DATA_ENTRY; | |
| IMAGE_LOAD_CONFIG_CODE_INTEGRITY :: struct { | |
| Flags : WORD, | |
| Catalog : WORD, | |
| CatalogOffset : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PIMAGE_LOAD_CONFIG_CODE_INTEGRITY :: ^IMAGE_LOAD_CONFIG_CODE_INTEGRITY; | |
| IMAGE_DYNAMIC_RELOCATION_TABLE :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| }; | |
| PIMAGE_DYNAMIC_RELOCATION_TABLE :: ^IMAGE_DYNAMIC_RELOCATION_TABLE; | |
| IMAGE_DYNAMIC_RELOCATION32 :: struct { | |
| Symbol : DWORD, | |
| BaseRelocSize : DWORD, | |
| }; | |
| PIMAGE_DYNAMIC_RELOCATION32 :: ^IMAGE_DYNAMIC_RELOCATION32; | |
| IMAGE_DYNAMIC_RELOCATION64 :: struct { | |
| Symbol : ULONGLONG, | |
| BaseRelocSize : DWORD, | |
| }; | |
| PIMAGE_DYNAMIC_RELOCATION64 :: ^IMAGE_DYNAMIC_RELOCATION64; | |
| IMAGE_DYNAMIC_RELOCATION32_V2 :: struct { | |
| HeaderSize : DWORD, | |
| FixupInfoSize : DWORD, | |
| Symbol : DWORD, | |
| SymbolGroup : DWORD, | |
| Flags : DWORD, | |
| }; | |
| PIMAGE_DYNAMIC_RELOCATION32_V2 :: ^IMAGE_DYNAMIC_RELOCATION32_V2; | |
| IMAGE_DYNAMIC_RELOCATION64_V2 :: struct { | |
| HeaderSize : DWORD, | |
| FixupInfoSize : DWORD, | |
| Symbol : ULONGLONG, | |
| SymbolGroup : DWORD, | |
| Flags : DWORD, | |
| }; | |
| PIMAGE_DYNAMIC_RELOCATION64_V2 :: ^IMAGE_DYNAMIC_RELOCATION64_V2; | |
| IMAGE_DYNAMIC_RELOCATION :: IMAGE_DYNAMIC_RELOCATION64; | |
| PIMAGE_DYNAMIC_RELOCATION :: PIMAGE_DYNAMIC_RELOCATION64; | |
| IMAGE_DYNAMIC_RELOCATION_V2 :: IMAGE_DYNAMIC_RELOCATION64_V2; | |
| PIMAGE_DYNAMIC_RELOCATION_V2 :: PIMAGE_DYNAMIC_RELOCATION64_V2; | |
| IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER :: struct { | |
| PrologueByteCount : BYTE, | |
| }; | |
| PIMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER :: ^IMAGE_PROLOGUE_DYNAMIC_RELOCATION_HEADER; | |
| IMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER :: struct { | |
| EpilogueCount : DWORD, | |
| EpilogueByteCount : BYTE, | |
| BranchDescriptorElementSize : BYTE, | |
| BranchDescriptorCount : WORD, | |
| }; | |
| PIMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER :: ^IMAGE_EPILOGUE_DYNAMIC_RELOCATION_HEADER; | |
| IMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: bit_field { | |
| PageRelativeOffset : 12, | |
| IndirectCall : 1, | |
| IATIndex : 19, | |
| }; | |
| PIMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: ^IMAGE_IMPORT_CONTROL_TRANSFER_DYNAMIC_RELOCATION; | |
| IMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: bit_field { | |
| PageRelativeOffset : 12, | |
| IndirectCall : 1, | |
| RexWPrefix : 1, | |
| CfgCheck : 1, | |
| Reserved : 1, | |
| }; | |
| PIMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION :: ^IMAGE_INDIR_CONTROL_TRANSFER_DYNAMIC_RELOCATION; | |
| IMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION :: bit_field { | |
| PageRelativeOffset : 12, | |
| RegisterNumber : 4, | |
| }; | |
| PIMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION :: ^IMAGE_SWITCHTABLE_BRANCH_DYNAMIC_RELOCATION; | |
| IMAGE_LOAD_CONFIG_DIRECTORY32 :: struct { | |
| Size : DWORD, | |
| TimeDateStamp : DWORD, | |
| MajorVersion : WORD, | |
| MinorVersion : WORD, | |
| GlobalFlagsClear : DWORD, | |
| GlobalFlagsSet : DWORD, | |
| CriticalSectionDefaultTimeout : DWORD, | |
| DeCommitFreeBlockThreshold : DWORD, | |
| DeCommitTotalFreeThreshold : DWORD, | |
| LockPrefixTable : DWORD, | |
| MaximumAllocationSize : DWORD, | |
| VirtualMemoryThreshold : DWORD, | |
| ProcessHeapFlags : DWORD, | |
| ProcessAffinityMask : DWORD, | |
| CSDVersion : WORD, | |
| DependentLoadFlags : WORD, | |
| EditList : DWORD, | |
| SecurityCookie : DWORD, | |
| SEHandlerTable : DWORD, | |
| SEHandlerCount : DWORD, | |
| GuardCFCheckFunctionPointer : DWORD, | |
| GuardCFDispatchFunctionPointer : DWORD, | |
| GuardCFFunctionTable : DWORD, | |
| GuardCFFunctionCount : DWORD, | |
| GuardFlags : DWORD, | |
| CodeIntegrity : IMAGE_LOAD_CONFIG_CODE_INTEGRITY, | |
| GuardAddressTakenIatEntryTable : DWORD, | |
| GuardAddressTakenIatEntryCount : DWORD, | |
| GuardLongJumpTargetTable : DWORD, | |
| GuardLongJumpTargetCount : DWORD, | |
| DynamicValueRelocTable : DWORD, | |
| CHPEMetadataPointer : DWORD, | |
| GuardRFFailureRoutine : DWORD, | |
| GuardRFFailureRoutineFunctionPointer : DWORD, | |
| DynamicValueRelocTableOffset : DWORD, | |
| DynamicValueRelocTableSection : WORD, | |
| Reserved2 : WORD, | |
| GuardRFVerifyStackPointerFunctionPointer : DWORD, | |
| HotPatchTableOffset : DWORD, | |
| Reserved3 : DWORD, | |
| EnclaveConfigurationPointer : DWORD, | |
| VolatileMetadataPointer : DWORD, | |
| }; | |
| PIMAGE_LOAD_CONFIG_DIRECTORY32 :: ^IMAGE_LOAD_CONFIG_DIRECTORY32; | |
| IMAGE_LOAD_CONFIG_DIRECTORY64 :: struct { | |
| Size : DWORD, | |
| TimeDateStamp : DWORD, | |
| MajorVersion : WORD, | |
| MinorVersion : WORD, | |
| GlobalFlagsClear : DWORD, | |
| GlobalFlagsSet : DWORD, | |
| CriticalSectionDefaultTimeout : DWORD, | |
| DeCommitFreeBlockThreshold : ULONGLONG, | |
| DeCommitTotalFreeThreshold : ULONGLONG, | |
| LockPrefixTable : ULONGLONG, | |
| MaximumAllocationSize : ULONGLONG, | |
| VirtualMemoryThreshold : ULONGLONG, | |
| ProcessAffinityMask : ULONGLONG, | |
| ProcessHeapFlags : DWORD, | |
| CSDVersion : WORD, | |
| DependentLoadFlags : WORD, | |
| EditList : ULONGLONG, | |
| SecurityCookie : ULONGLONG, | |
| SEHandlerTable : ULONGLONG, | |
| SEHandlerCount : ULONGLONG, | |
| GuardCFCheckFunctionPointer : ULONGLONG, | |
| GuardCFDispatchFunctionPointer : ULONGLONG, | |
| GuardCFFunctionTable : ULONGLONG, | |
| GuardCFFunctionCount : ULONGLONG, | |
| GuardFlags : DWORD, | |
| CodeIntegrity : IMAGE_LOAD_CONFIG_CODE_INTEGRITY, | |
| GuardAddressTakenIatEntryTable : ULONGLONG, | |
| GuardAddressTakenIatEntryCount : ULONGLONG, | |
| GuardLongJumpTargetTable : ULONGLONG, | |
| GuardLongJumpTargetCount : ULONGLONG, | |
| DynamicValueRelocTable : ULONGLONG, | |
| CHPEMetadataPointer : ULONGLONG, | |
| GuardRFFailureRoutine : ULONGLONG, | |
| GuardRFFailureRoutineFunctionPointer : ULONGLONG, | |
| DynamicValueRelocTableOffset : DWORD, | |
| DynamicValueRelocTableSection : WORD, | |
| Reserved2 : WORD, | |
| GuardRFVerifyStackPointerFunctionPointer : ULONGLONG, | |
| HotPatchTableOffset : DWORD, | |
| Reserved3 : DWORD, | |
| EnclaveConfigurationPointer : ULONGLONG, | |
| VolatileMetadataPointer : ULONGLONG, | |
| }; | |
| PIMAGE_LOAD_CONFIG_DIRECTORY64 :: ^IMAGE_LOAD_CONFIG_DIRECTORY64; | |
| IMAGE_LOAD_CONFIG_DIRECTORY :: IMAGE_LOAD_CONFIG_DIRECTORY64; | |
| PIMAGE_LOAD_CONFIG_DIRECTORY :: PIMAGE_LOAD_CONFIG_DIRECTORY64; | |
| IMAGE_HOT_PATCH_INFO :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| SequenceNumber : DWORD, | |
| BaseImageList : DWORD, | |
| BaseImageCount : DWORD, | |
| BufferOffset : DWORD, | |
| ExtraPatchSize : DWORD, | |
| }; | |
| PIMAGE_HOT_PATCH_INFO :: ^IMAGE_HOT_PATCH_INFO; | |
| IMAGE_HOT_PATCH_BASE :: struct { | |
| SequenceNumber : DWORD, | |
| Flags : DWORD, | |
| OriginalTimeDateStamp : DWORD, | |
| OriginalCheckSum : DWORD, | |
| CodeIntegrityInfo : DWORD, | |
| CodeIntegritySize : DWORD, | |
| PatchTable : DWORD, | |
| BufferOffset : DWORD, | |
| }; | |
| PIMAGE_HOT_PATCH_BASE :: ^IMAGE_HOT_PATCH_BASE; | |
| IMAGE_HOT_PATCH_HASHES :: struct { | |
| SHA256 : [32]BYTE, | |
| SHA1 : [20]BYTE, | |
| }; | |
| PIMAGE_HOT_PATCH_HASHES :: ^IMAGE_HOT_PATCH_HASHES; | |
| IMAGE_CE_RUNTIME_FUNCTION_ENTRY :: struct { | |
| FuncStart : DWORD, | |
| using _ : bit_field { | |
| PrologLen : 8, | |
| FuncLen : 22, | |
| ThirtyTwoBit : 1, | |
| ExceptionFlag : 1, | |
| }, | |
| }; | |
| PIMAGE_CE_RUNTIME_FUNCTION_ENTRY :: ^IMAGE_CE_RUNTIME_FUNCTION_ENTRY; | |
| IMAGE_ARM_RUNTIME_FUNCTION_ENTRY :: struct { | |
| BeginAddress : DWORD, | |
| u : struct #raw_union { | |
| UnwindData : DWORD, | |
| s : bit_field { | |
| Flag : 2, | |
| FunctionLength : 11, | |
| Ret : 2, | |
| H : 1, | |
| Reg : 3, | |
| R : 1, | |
| L : 1, | |
| C : 1, | |
| StackAdjust : 10, | |
| }, | |
| }, | |
| }; | |
| PIMAGE_ARM_RUNTIME_FUNCTION_ENTRY :: ^IMAGE_ARM_RUNTIME_FUNCTION_ENTRY; | |
| IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY :: struct { | |
| BeginAddress : DWORD, | |
| u : struct #raw_union { | |
| UnwindData : DWORD, | |
| s : bit_field { | |
| Flag : 2, | |
| FunctionLength : 11, | |
| RegF : 3, | |
| RegI : 4, | |
| H : 1, | |
| CR : 2, | |
| FrameSize : 9, | |
| }, | |
| }, | |
| }; | |
| PIMAGE_ARM64_RUNTIME_FUNCTION_ENTRY :: ^IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY; | |
| IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY :: struct { | |
| BeginAddress : ULONGLONG, | |
| EndAddress : ULONGLONG, | |
| ExceptionHandler : ULONGLONG, | |
| HandlerData : ULONGLONG, | |
| PrologEndAddress : ULONGLONG, | |
| }; | |
| PIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY :: ^IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY; | |
| IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY :: struct { | |
| BeginAddress : DWORD, | |
| EndAddress : DWORD, | |
| ExceptionHandler : DWORD, | |
| HandlerData : DWORD, | |
| PrologEndAddress : DWORD, | |
| }; | |
| PIMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY :: ^IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY; | |
| _IMAGE_RUNTIME_FUNCTION_ENTRY :: struct { | |
| BeginAddress : DWORD, | |
| EndAddress : DWORD, | |
| u : struct #raw_union { | |
| UnwindInfoAddress : DWORD, | |
| UnwindData : DWORD, | |
| }, | |
| }; | |
| _PIMAGE_RUNTIME_FUNCTION_ENTRY :: ^_IMAGE_RUNTIME_FUNCTION_ENTRY; | |
| IMAGE_IA64_RUNTIME_FUNCTION_ENTRY :: _IMAGE_RUNTIME_FUNCTION_ENTRY; | |
| PIMAGE_IA64_RUNTIME_FUNCTION_ENTRY :: _PIMAGE_RUNTIME_FUNCTION_ENTRY; | |
| IMAGE_RUNTIME_FUNCTION_ENTRY :: _IMAGE_RUNTIME_FUNCTION_ENTRY; | |
| PIMAGE_RUNTIME_FUNCTION_ENTRY :: _PIMAGE_RUNTIME_FUNCTION_ENTRY; | |
| IMAGE_ENCLAVE_CONFIG32 :: struct { | |
| Size : DWORD, | |
| MinimumRequiredConfigSize : DWORD, | |
| PolicyFlags : DWORD, | |
| NumberOfImports : DWORD, | |
| ImportList : DWORD, | |
| ImportEntrySize : DWORD, | |
| FamilyID : [16]BYTE, | |
| ImageID : [16]BYTE, | |
| ImageVersion : DWORD, | |
| SecurityVersion : DWORD, | |
| EnclaveSize : DWORD, | |
| NumberOfThreads : DWORD, | |
| EnclaveFlags : DWORD, | |
| }; | |
| PIMAGE_ENCLAVE_CONFIG32 :: ^IMAGE_ENCLAVE_CONFIG32; | |
| IMAGE_ENCLAVE_CONFIG64 :: struct { | |
| Size : DWORD, | |
| MinimumRequiredConfigSize : DWORD, | |
| PolicyFlags : DWORD, | |
| NumberOfImports : DWORD, | |
| ImportList : DWORD, | |
| ImportEntrySize : DWORD, | |
| FamilyID : [16]BYTE, | |
| ImageID : [16]BYTE, | |
| ImageVersion : DWORD, | |
| SecurityVersion : DWORD, | |
| EnclaveSize : ULONGLONG, | |
| NumberOfThreads : DWORD, | |
| EnclaveFlags : DWORD, | |
| }; | |
| PIMAGE_ENCLAVE_CONFIG64 :: ^IMAGE_ENCLAVE_CONFIG64; | |
| IMAGE_ENCLAVE_CONFIG :: IMAGE_ENCLAVE_CONFIG64; | |
| PIMAGE_ENCLAVE_CONFIG :: PIMAGE_ENCLAVE_CONFIG64; | |
| IMAGE_ENCLAVE_IMPORT :: struct { | |
| MatchType : DWORD, | |
| MinimumSecurityVersion : DWORD, | |
| UniqueOrAuthorID : [32]BYTE, | |
| FamilyID : [16]BYTE, | |
| ImageID : [16]BYTE, | |
| ImportName : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PIMAGE_ENCLAVE_IMPORT :: ^IMAGE_ENCLAVE_IMPORT; | |
| IMAGE_DEBUG_DIRECTORY :: struct { | |
| Characteristics : DWORD, | |
| TimeDateStamp : DWORD, | |
| MajorVersion : WORD, | |
| MinorVersion : WORD, | |
| Type : DWORD, | |
| SizeOfData : DWORD, | |
| AddressOfRawData : DWORD, | |
| PointerToRawData : DWORD, | |
| }; | |
| PIMAGE_DEBUG_DIRECTORY :: ^IMAGE_DEBUG_DIRECTORY; | |
| IMAGE_COFF_SYMBOLS_HEADER :: struct { | |
| NumberOfSymbols : DWORD, | |
| LvaToFirstSymbol : DWORD, | |
| NumberOfLinenumbers : DWORD, | |
| LvaToFirstLinenumber : DWORD, | |
| RvaToFirstByteOfCode : DWORD, | |
| RvaToLastByteOfCode : DWORD, | |
| RvaToFirstByteOfData : DWORD, | |
| RvaToLastByteOfData : DWORD, | |
| }; | |
| PIMAGE_COFF_SYMBOLS_HEADER :: ^IMAGE_COFF_SYMBOLS_HEADER; | |
| FPO_DATA :: struct { | |
| ulOffStart : DWORD, | |
| cbProcSize : DWORD, | |
| cdwLocals : DWORD, | |
| cdwParams : WORD, | |
| using _ : bit_field { | |
| cbProlog : 8, | |
| cbRegs : 3, | |
| fHasSEH : 1, | |
| fUseBP : 1, | |
| reserved : 1, | |
| cbFrame : 2, | |
| }, | |
| }; | |
| PFPO_DATA :: ^FPO_DATA; | |
| IMAGE_DEBUG_MISC :: struct { | |
| DataType : DWORD, | |
| Length : DWORD, | |
| Unicode : BOOLEAN, | |
| Reserved : [3]BYTE, | |
| Data : [1]BYTE, | |
| }; | |
| PIMAGE_DEBUG_MISC :: ^IMAGE_DEBUG_MISC; | |
| IMAGE_FUNCTION_ENTRY :: struct { | |
| StartingAddress : DWORD, | |
| EndingAddress : DWORD, | |
| EndOfPrologue : DWORD, | |
| }; | |
| PIMAGE_FUNCTION_ENTRY :: ^IMAGE_FUNCTION_ENTRY; | |
| IMAGE_FUNCTION_ENTRY64 :: struct { | |
| StartingAddress : ULONGLONG, | |
| EndingAddress : ULONGLONG, | |
| u : struct #raw_union { | |
| EndOfPrologue : ULONGLONG, | |
| UnwindInfoAddress : ULONGLONG, | |
| }, | |
| }; | |
| PIMAGE_FUNCTION_ENTRY64 :: ^IMAGE_FUNCTION_ENTRY64; | |
| IMAGE_SEPARATE_DEBUG_HEADER :: struct { | |
| Signature : WORD, | |
| Flags : WORD, | |
| Machine : WORD, | |
| Characteristics : WORD, | |
| TimeDateStamp : DWORD, | |
| CheckSum : DWORD, | |
| ImageBase : DWORD, | |
| SizeOfImage : DWORD, | |
| NumberOfSections : DWORD, | |
| ExportedNamesSize : DWORD, | |
| DebugDirectorySize : DWORD, | |
| SectionAlignment : DWORD, | |
| Reserved : [2]DWORD, | |
| }; | |
| PIMAGE_SEPARATE_DEBUG_HEADER :: ^IMAGE_SEPARATE_DEBUG_HEADER; | |
| NON_PAGED_DEBUG_INFO :: struct { | |
| Signature : WORD, | |
| Flags : WORD, | |
| Size : DWORD, | |
| Machine : WORD, | |
| Characteristics : WORD, | |
| TimeDateStamp : DWORD, | |
| CheckSum : DWORD, | |
| SizeOfImage : DWORD, | |
| ImageBase : ULONGLONG, | |
| }; | |
| PNON_PAGED_DEBUG_INFO :: ^NON_PAGED_DEBUG_INFO; | |
| IMAGE_ARCHITECTURE_HEADER :: struct { | |
| using _ : bit_field { | |
| AmaskValue : 1, | |
| _ : 7, | |
| AmaskShift : 8, | |
| _ : 16, | |
| }, | |
| FirstEntryRVA : DWORD, | |
| }; | |
| PIMAGE_ARCHITECTURE_HEADER :: ^IMAGE_ARCHITECTURE_HEADER; | |
| IMAGE_ARCHITECTURE_ENTRY :: struct { | |
| FixupInstRVA : DWORD, | |
| NewInst : DWORD, | |
| }; | |
| PIMAGE_ARCHITECTURE_ENTRY :: ^IMAGE_ARCHITECTURE_ENTRY; | |
| IMPORT_OBJECT_HEADER :: struct { | |
| Sig1 : WORD, | |
| Sig2 : WORD, | |
| Version : WORD, | |
| Machine : WORD, | |
| TimeDateStamp : DWORD, | |
| SizeOfData : DWORD, | |
| u : struct #raw_union { | |
| Ordinal : WORD, | |
| Hint : WORD, | |
| }, | |
| using _ : bit_field { | |
| Type : 2, | |
| NameType : 3, | |
| Reserved : 11, | |
| }, | |
| }; | |
| /* IMPORT_OBJECT_TYPE :: enum { */ | |
| IMPORT_OBJECT_TYPE :: _c.int; | |
| IMPORT_OBJECT_CODE :: 0; | |
| IMPORT_OBJECT_DATA :: 1; | |
| IMPORT_OBJECT_CONST :: 2; | |
| /* } */ | |
| ; | |
| /* IMPORT_OBJECT_NAME_TYPE :: enum { */ | |
| IMPORT_OBJECT_NAME_TYPE :: _c.int; | |
| IMPORT_OBJECT_ORDINAL :: 0; | |
| IMPORT_OBJECT_NAME :: 1; | |
| IMPORT_OBJECT_NAME_NO_PREFIX :: 2; | |
| IMPORT_OBJECT_NAME_UNDECORATE :: 3; | |
| IMPORT_OBJECT_NAME_EXPORTAS :: 4; | |
| /* } */ | |
| ; | |
| /* ReplacesCorHdrNumericDefines :: enum { */ | |
| ReplacesCorHdrNumericDefines :: _c.int; | |
| COMIMAGE_FLAGS_ILONLY :: 0x00000001; | |
| COMIMAGE_FLAGS_32BITREQUIRED :: 0x00000002; | |
| COMIMAGE_FLAGS_IL_LIBRARY :: 0x00000004; | |
| COMIMAGE_FLAGS_STRONGNAMESIGNED :: 0x00000008; | |
| COMIMAGE_FLAGS_NATIVE_ENTRYPOINT :: 0x00000010; | |
| COMIMAGE_FLAGS_TRACKDEBUGDATA :: 0x00010000; | |
| COMIMAGE_FLAGS_32BITPREFERRED :: 0x00020000; | |
| COR_VERSION_MAJOR_V2 :: 2; | |
| COR_VERSION_MAJOR :: COR_VERSION_MAJOR_V2; | |
| COR_VERSION_MINOR :: 5; | |
| COR_DELETED_NAME_LENGTH :: 8; | |
| COR_VTABLEGAP_NAME_LENGTH :: 8; | |
| NATIVE_TYPE_MAX_CB :: 1; | |
| COR_ILMETHOD_SECT_SMALL_MAX_DATASIZE :: 0xFF; | |
| IMAGE_COR_MIH_METHODRVA :: 0x01; | |
| IMAGE_COR_MIH_EHRVA :: 0x02; | |
| IMAGE_COR_MIH_BASICBLOCK :: 0x08; | |
| COR_VTABLE_32BIT :: 0x01; | |
| COR_VTABLE_64BIT :: 0x02; | |
| COR_VTABLE_FROM_UNMANAGED :: 0x04; | |
| COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN :: 0x08; | |
| COR_VTABLE_CALL_MOST_DERIVED :: 0x10; | |
| IMAGE_COR_EATJ_THUNK_SIZE :: 32; | |
| MAX_CLASS_NAME :: 1024; | |
| MAX_PACKAGE_NAME :: 1024; | |
| /* } */ | |
| ; | |
| IMAGE_COR20_HEADER :: struct { | |
| cb : DWORD, | |
| MajorRuntimeVersion : WORD, | |
| MinorRuntimeVersion : WORD, | |
| MetaData : IMAGE_DATA_DIRECTORY, | |
| Flags : DWORD, | |
| u : struct #raw_union { | |
| EntryPointToken : DWORD, | |
| EntryPointRVA : DWORD, | |
| }, | |
| Resources : IMAGE_DATA_DIRECTORY, | |
| StrongNameSignature : IMAGE_DATA_DIRECTORY, | |
| CodeManagerTable : IMAGE_DATA_DIRECTORY, | |
| VTableFixups : IMAGE_DATA_DIRECTORY, | |
| ExportAddressTableJumps : IMAGE_DATA_DIRECTORY, | |
| ManagedNativeHeader : IMAGE_DATA_DIRECTORY, | |
| }; | |
| PIMAGE_COR20_HEADER :: ^IMAGE_COR20_HEADER; | |
| SLIST_ENTRY :: struct { | |
| Next : ^SLIST_ENTRY, | |
| }; | |
| PSLIST_ENTRY :: ^SLIST_ENTRY; | |
| SLIST_HEADER :: struct #raw_union { | |
| s : struct { | |
| Alignment : ULONGLONG, | |
| Region : ULONGLONG, | |
| }, | |
| HeaderX64 : bit_field { | |
| Depth : 16, | |
| Sequence : 48, | |
| Reserved : 4, | |
| NextEntry : 60, | |
| }, | |
| }; | |
| PSLIST_HEADER :: ^SLIST_HEADER; | |
| RTL_RUN_ONCE :: struct #raw_union { | |
| Ptr : PVOID, | |
| }; | |
| PRTL_RUN_ONCE :: ^RTL_RUN_ONCE; | |
| RTL_BARRIER :: struct { | |
| Reserved1 : DWORD, | |
| Reserved2 : DWORD, | |
| Reserved3 : [2]ULONG_PTR, | |
| Reserved4 : DWORD, | |
| Reserved5 : DWORD, | |
| }; | |
| PRTL_BARRIER :: ^RTL_BARRIER; | |
| MESSAGE_RESOURCE_ENTRY :: struct { | |
| Length : WORD, | |
| Flags : WORD, | |
| Text : [1]BYTE, | |
| }; | |
| PMESSAGE_RESOURCE_ENTRY :: ^MESSAGE_RESOURCE_ENTRY; | |
| MESSAGE_RESOURCE_BLOCK :: struct { | |
| LowId : DWORD, | |
| HighId : DWORD, | |
| OffsetToEntries : DWORD, | |
| }; | |
| PMESSAGE_RESOURCE_BLOCK :: ^MESSAGE_RESOURCE_BLOCK; | |
| MESSAGE_RESOURCE_DATA :: struct { | |
| NumberOfBlocks : DWORD, | |
| Blocks : [1]MESSAGE_RESOURCE_BLOCK, | |
| }; | |
| PMESSAGE_RESOURCE_DATA :: ^MESSAGE_RESOURCE_DATA; | |
| OSVERSIONINFOA :: struct { | |
| dwOSVersionInfoSize : DWORD, | |
| dwMajorVersion : DWORD, | |
| dwMinorVersion : DWORD, | |
| dwBuildNumber : DWORD, | |
| dwPlatformId : DWORD, | |
| szCSDVersion : [128]CHAR, | |
| }; | |
| POSVERSIONINFOA :: ^OSVERSIONINFOA; | |
| LPOSVERSIONINFOA :: ^OSVERSIONINFOA; | |
| OSVERSIONINFOW :: struct { | |
| dwOSVersionInfoSize : DWORD, | |
| dwMajorVersion : DWORD, | |
| dwMinorVersion : DWORD, | |
| dwBuildNumber : DWORD, | |
| dwPlatformId : DWORD, | |
| szCSDVersion : [128]WCHAR, | |
| }; | |
| POSVERSIONINFOW :: ^OSVERSIONINFOW; | |
| LPOSVERSIONINFOW :: ^OSVERSIONINFOW; | |
| RTL_OSVERSIONINFOW :: struct { | |
| dwOSVersionInfoSize : DWORD, | |
| dwMajorVersion : DWORD, | |
| dwMinorVersion : DWORD, | |
| dwBuildNumber : DWORD, | |
| dwPlatformId : DWORD, | |
| szCSDVersion : [128]WCHAR, | |
| }; | |
| PRTL_OSVERSIONINFOW :: ^RTL_OSVERSIONINFOW; | |
| OSVERSIONINFO :: OSVERSIONINFOA; | |
| POSVERSIONINFO :: POSVERSIONINFOA; | |
| LPOSVERSIONINFO :: LPOSVERSIONINFOA; | |
| OSVERSIONINFOEXA :: struct { | |
| dwOSVersionInfoSize : DWORD, | |
| dwMajorVersion : DWORD, | |
| dwMinorVersion : DWORD, | |
| dwBuildNumber : DWORD, | |
| dwPlatformId : DWORD, | |
| szCSDVersion : [128]CHAR, | |
| wServicePackMajor : WORD, | |
| wServicePackMinor : WORD, | |
| wSuiteMask : WORD, | |
| wProductType : BYTE, | |
| wReserved : BYTE, | |
| }; | |
| POSVERSIONINFOEXA :: ^OSVERSIONINFOEXA; | |
| LPOSVERSIONINFOEXA :: ^OSVERSIONINFOEXA; | |
| OSVERSIONINFOEXW :: struct { | |
| dwOSVersionInfoSize : DWORD, | |
| dwMajorVersion : DWORD, | |
| dwMinorVersion : DWORD, | |
| dwBuildNumber : DWORD, | |
| dwPlatformId : DWORD, | |
| szCSDVersion : [128]WCHAR, | |
| wServicePackMajor : WORD, | |
| wServicePackMinor : WORD, | |
| wSuiteMask : WORD, | |
| wProductType : BYTE, | |
| wReserved : BYTE, | |
| }; | |
| POSVERSIONINFOEXW :: ^OSVERSIONINFOEXW; | |
| LPOSVERSIONINFOEXW :: ^OSVERSIONINFOEXW; | |
| RTL_OSVERSIONINFOEXW :: struct { | |
| dwOSVersionInfoSize : DWORD, | |
| dwMajorVersion : DWORD, | |
| dwMinorVersion : DWORD, | |
| dwBuildNumber : DWORD, | |
| dwPlatformId : DWORD, | |
| szCSDVersion : [128]WCHAR, | |
| wServicePackMajor : WORD, | |
| wServicePackMinor : WORD, | |
| wSuiteMask : WORD, | |
| wProductType : BYTE, | |
| wReserved : BYTE, | |
| }; | |
| PRTL_OSVERSIONINFOEXW :: ^RTL_OSVERSIONINFOEXW; | |
| OSVERSIONINFOEX :: OSVERSIONINFOEXA; | |
| POSVERSIONINFOEX :: POSVERSIONINFOEXA; | |
| LPOSVERSIONINFOEX :: LPOSVERSIONINFOEXA; | |
| /* RTL_UMS_THREAD_INFO_CLASS :: enum { */ | |
| RTL_UMS_THREAD_INFO_CLASS :: _c.int; | |
| UmsThreadInvalidInfoClass :: 0; | |
| UmsThreadUserContext :: UmsThreadInvalidInfoClass + 1; | |
| UmsThreadPriority :: UmsThreadUserContext + 1; | |
| UmsThreadAffinity :: UmsThreadPriority + 1; | |
| UmsThreadTeb :: UmsThreadAffinity + 1; | |
| UmsThreadIsSuspended :: UmsThreadTeb + 1; | |
| UmsThreadIsTerminated :: UmsThreadIsSuspended + 1; | |
| UmsThreadMaxInfoClass :: UmsThreadIsTerminated + 1; | |
| /* } */ | |
| PRTL_UMS_THREAD_INFO_CLASS :: ^RTL_UMS_THREAD_INFO_CLASS; | |
| /* RTL_UMS_SCHEDULER_REASON :: enum { */ | |
| RTL_UMS_SCHEDULER_REASON :: _c.int; | |
| UmsSchedulerStartup :: 0; | |
| UmsSchedulerThreadBlocked :: UmsSchedulerStartup + 1; | |
| UmsSchedulerThreadYield :: UmsSchedulerThreadBlocked + 1; | |
| /* } */ | |
| PRTL_UMS_SCHEDULER_REASON :: ^RTL_UMS_SCHEDULER_REASON; | |
| RTL_UMS_SCHEDULER_ENTRY_POINT :: #type proc "stdcall" (Reason : RTL_UMS_SCHEDULER_REASON, ActivationPayload : ULONG_PTR, SchedulerParam : PVOID); | |
| PRTL_UMS_SCHEDULER_ENTRY_POINT :: ^RTL_UMS_SCHEDULER_ENTRY_POINT; | |
| /* OS_DEPLOYEMENT_STATE_VALUES :: enum { */ | |
| OS_DEPLOYEMENT_STATE_VALUES :: _c.int; | |
| OS_DEPLOYMENT_STANDARD :: 1; | |
| OS_DEPLOYMENT_COMPACT :: OS_DEPLOYMENT_STANDARD + 1; | |
| /* } */ | |
| ; | |
| NV_MEMORY_RANGE :: struct { | |
| BaseAddress : rawptr, | |
| Length : SIZE_T, | |
| }; | |
| PNV_MEMORY_RANGE :: ^NV_MEMORY_RANGE; | |
| CORRELATION_VECTOR :: struct { | |
| Version : CHAR, | |
| Vector : [129]CHAR, | |
| }; | |
| PCORRELATION_VECTOR :: ^CORRELATION_VECTOR; | |
| CUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG :: struct { | |
| Size : DWORD, | |
| TriggerId : PCWSTR, | |
| }; | |
| PCUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG :: ^CUSTOM_SYSTEM_EVENT_TRIGGER_CONFIG; | |
| /* IMAGE_POLICY_ENTRY_TYPE :: enum { */ | |
| IMAGE_POLICY_ENTRY_TYPE :: _c.int; | |
| ImagePolicyEntryTypeNone :: 0; | |
| ImagePolicyEntryTypeBool :: ImagePolicyEntryTypeNone + 1; | |
| ImagePolicyEntryTypeInt8 :: ImagePolicyEntryTypeBool + 1; | |
| ImagePolicyEntryTypeUInt8 :: ImagePolicyEntryTypeInt8 + 1; | |
| ImagePolicyEntryTypeInt16 :: ImagePolicyEntryTypeUInt8 + 1; | |
| ImagePolicyEntryTypeUInt16 :: ImagePolicyEntryTypeInt16 + 1; | |
| ImagePolicyEntryTypeInt32 :: ImagePolicyEntryTypeUInt16 + 1; | |
| ImagePolicyEntryTypeUInt32 :: ImagePolicyEntryTypeInt32 + 1; | |
| ImagePolicyEntryTypeInt64 :: ImagePolicyEntryTypeUInt32 + 1; | |
| ImagePolicyEntryTypeUInt64 :: ImagePolicyEntryTypeInt64 + 1; | |
| ImagePolicyEntryTypeAnsiString :: ImagePolicyEntryTypeUInt64 + 1; | |
| ImagePolicyEntryTypeUnicodeString :: ImagePolicyEntryTypeAnsiString + 1; | |
| ImagePolicyEntryTypeOverride :: ImagePolicyEntryTypeUnicodeString + 1; | |
| ImagePolicyEntryTypeMaximum :: ImagePolicyEntryTypeOverride + 1; | |
| /* } */ | |
| ; | |
| /* IMAGE_POLICY_ID :: enum { */ | |
| IMAGE_POLICY_ID :: _c.int; | |
| ImagePolicyIdNone :: 0; | |
| ImagePolicyIdEtw :: ImagePolicyIdNone + 1; | |
| ImagePolicyIdDebug :: ImagePolicyIdEtw + 1; | |
| ImagePolicyIdCrashDump :: ImagePolicyIdDebug + 1; | |
| ImagePolicyIdCrashDumpKey :: ImagePolicyIdCrashDump + 1; | |
| ImagePolicyIdCrashDumpKeyGuid :: ImagePolicyIdCrashDumpKey + 1; | |
| ImagePolicyIdParentSd :: ImagePolicyIdCrashDumpKeyGuid + 1; | |
| ImagePolicyIdParentSdRev :: ImagePolicyIdParentSd + 1; | |
| ImagePolicyIdSvn :: ImagePolicyIdParentSdRev + 1; | |
| ImagePolicyIdDeviceId :: ImagePolicyIdSvn + 1; | |
| ImagePolicyIdCapability :: ImagePolicyIdDeviceId + 1; | |
| ImagePolicyIdScenarioId :: ImagePolicyIdCapability + 1; | |
| ImagePolicyIdMaximum :: ImagePolicyIdScenarioId + 1; | |
| /* } */ | |
| ; | |
| IMAGE_POLICY_ENTRY :: struct { | |
| Type : IMAGE_POLICY_ENTRY_TYPE, | |
| PolicyId : IMAGE_POLICY_ID, | |
| u : struct #raw_union { | |
| None : rawptr, | |
| BoolValue : BOOLEAN, | |
| Int8Value : INT8, | |
| UInt8Value : UINT8, | |
| Int16Value : INT16, | |
| UInt16Value : UINT16, | |
| Int32Value : INT32, | |
| UInt32Value : UINT32, | |
| Int64Value : INT64, | |
| UInt64Value : UINT64, | |
| AnsiStringValue : PCSTR, | |
| UnicodeStringValue : PCWSTR, | |
| }, | |
| }; | |
| PCIMAGE_POLICY_ENTRY :: ^IMAGE_POLICY_ENTRY; | |
| IMAGE_POLICY_METADATA :: struct { | |
| Version : BYTE, | |
| Reserved0 : [7]BYTE, | |
| ApplicationId : ULONGLONG, | |
| Policies : []IMAGE_POLICY_ENTRY, | |
| }; | |
| PCIMAGE_POLICY_METADATA :: ^IMAGE_POLICY_METADATA; | |
| RTL_CRITICAL_SECTION_DEBUG :: struct { | |
| Type : WORD, | |
| CreatorBackTraceIndex : WORD, | |
| CriticalSection : ^RTL_CRITICAL_SECTION, | |
| ProcessLocksList : LIST_ENTRY, | |
| EntryCount : DWORD, | |
| ContentionCount : DWORD, | |
| Flags : DWORD, | |
| CreatorBackTraceIndexHigh : WORD, | |
| SpareWORD : WORD, | |
| }; | |
| PRTL_CRITICAL_SECTION_DEBUG :: ^RTL_CRITICAL_SECTION_DEBUG; | |
| RTL_RESOURCE_DEBUG :: struct { | |
| Type : WORD, | |
| CreatorBackTraceIndex : WORD, | |
| CriticalSection : ^RTL_CRITICAL_SECTION, | |
| ProcessLocksList : LIST_ENTRY, | |
| EntryCount : DWORD, | |
| ContentionCount : DWORD, | |
| Flags : DWORD, | |
| CreatorBackTraceIndexHigh : WORD, | |
| SpareWORD : WORD, | |
| }; | |
| PRTL_RESOURCE_DEBUG :: ^RTL_RESOURCE_DEBUG; | |
| RTL_CRITICAL_SECTION :: struct { | |
| DebugInfo : PRTL_CRITICAL_SECTION_DEBUG, | |
| LockCount : LONG, | |
| RecursionCount : LONG, | |
| OwningThread : HANDLE, | |
| LockSemaphore : HANDLE, | |
| SpinCount : ULONG_PTR, | |
| }; | |
| PRTL_CRITICAL_SECTION :: ^RTL_CRITICAL_SECTION; | |
| RTL_SRWLOCK :: struct { | |
| Ptr : PVOID, | |
| }; | |
| PRTL_SRWLOCK :: ^RTL_SRWLOCK; | |
| RTL_CONDITION_VARIABLE :: struct { | |
| Ptr : PVOID, | |
| }; | |
| PRTL_CONDITION_VARIABLE :: ^RTL_CONDITION_VARIABLE; | |
| PAPCFUNC :: proc "stdcall" (Parameter : ULONG_PTR); | |
| PVECTORED_EXCEPTION_HANDLER :: (proc "stdcall" (ExceptionInfo : ^EXCEPTION_POINTERS) -> LONG); | |
| /* HEAP_INFORMATION_CLASS :: enum { */ | |
| HEAP_INFORMATION_CLASS :: _c.int; | |
| HeapCompatibilityInformation :: 0; | |
| HeapEnableTerminationOnCorruption :: 1; | |
| HeapOptimizeResources :: 3; | |
| /* } */ | |
| ; | |
| HEAP_OPTIMIZE_RESOURCES_INFORMATION :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| }; | |
| PHEAP_OPTIMIZE_RESOURCES_INFORMATION :: ^HEAP_OPTIMIZE_RESOURCES_INFORMATION; | |
| WAITORTIMERCALLBACKFUNC :: proc "stdcall" (PVOID, BOOLEAN); | |
| WORKERCALLBACKFUNC :: proc "stdcall" (PVOID); | |
| APC_CALLBACK_FUNCTION :: proc "stdcall" (DWORD, PVOID, PVOID); | |
| WAITORTIMERCALLBACK :: WAITORTIMERCALLBACKFUNC; | |
| PFLS_CALLBACK_FUNCTION :: proc "stdcall" (lpFlsData : PVOID); | |
| PSECURE_MEMORY_CACHE_CALLBACK :: (proc "stdcall" (Addr : PVOID, Range : SIZE_T) -> BOOLEAN); | |
| /* ACTIVATION_CONTEXT_INFO_CLASS :: enum { */ | |
| ACTIVATION_CONTEXT_INFO_CLASS :: _c.int; | |
| ActivationContextBasicInformation :: 1; | |
| ActivationContextDetailedInformation :: 2; | |
| AssemblyDetailedInformationInActivationContext :: 3; | |
| FileInformationInAssemblyOfAssemblyInActivationContext :: 4; | |
| RunlevelInformationInActivationContext :: 5; | |
| CompatibilityInformationInActivationContext :: 6; | |
| ActivationContextManifestResourceName :: 7; | |
| MaxActivationContextInfoClass :: ActivationContextManifestResourceName + 1; | |
| AssemblyDetailedInformationInActivationContxt :: 3; | |
| FileInformationInAssemblyOfAssemblyInActivationContxt :: 4; | |
| /* } */ | |
| ; | |
| ACTIVATION_CONTEXT_QUERY_INDEX :: struct { | |
| ulAssemblyIndex : DWORD, | |
| ulFileIndexInAssembly : DWORD, | |
| }; | |
| PACTIVATION_CONTEXT_QUERY_INDEX :: ^ACTIVATION_CONTEXT_QUERY_INDEX; | |
| PCACTIVATION_CONTEXT_QUERY_INDEX :: ^ACTIVATION_CONTEXT_QUERY_INDEX; | |
| ASSEMBLY_FILE_DETAILED_INFORMATION :: struct { | |
| ulFlags : DWORD, | |
| ulFilenameLength : DWORD, | |
| ulPathLength : DWORD, | |
| lpFileName : PCWSTR, | |
| lpFilePath : PCWSTR, | |
| }; | |
| PASSEMBLY_FILE_DETAILED_INFORMATION :: ^ASSEMBLY_FILE_DETAILED_INFORMATION; | |
| PCASSEMBLY_FILE_DETAILED_INFORMATION :: ^ASSEMBLY_FILE_DETAILED_INFORMATION; | |
| ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION :: struct { | |
| ulFlags : DWORD, | |
| ulEncodedAssemblyIdentityLength : DWORD, | |
| ulManifestPathType : DWORD, | |
| ulManifestPathLength : DWORD, | |
| liManifestLastWriteTime : LARGE_INTEGER, | |
| ulPolicyPathType : DWORD, | |
| ulPolicyPathLength : DWORD, | |
| liPolicyLastWriteTime : LARGE_INTEGER, | |
| ulMetadataSatelliteRosterIndex : DWORD, | |
| ulManifestVersionMajor : DWORD, | |
| ulManifestVersionMinor : DWORD, | |
| ulPolicyVersionMajor : DWORD, | |
| ulPolicyVersionMinor : DWORD, | |
| ulAssemblyDirectoryNameLength : DWORD, | |
| lpAssemblyEncodedAssemblyIdentity : PCWSTR, | |
| lpAssemblyManifestPath : PCWSTR, | |
| lpAssemblyPolicyPath : PCWSTR, | |
| lpAssemblyDirectoryName : PCWSTR, | |
| ulFileCount : DWORD, | |
| }; | |
| PACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION :: ^ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION; | |
| PCACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION :: ^ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION; | |
| /* ACTCTX_REQUESTED_RUN_LEVEL :: enum { */ | |
| ACTCTX_REQUESTED_RUN_LEVEL :: _c.int; | |
| ACTCTX_RUN_LEVEL_UNSPECIFIED :: 0; | |
| ACTCTX_RUN_LEVEL_AS_INVOKER :: ACTCTX_RUN_LEVEL_UNSPECIFIED + 1; | |
| ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE :: ACTCTX_RUN_LEVEL_AS_INVOKER + 1; | |
| ACTCTX_RUN_LEVEL_REQUIRE_ADMIN :: ACTCTX_RUN_LEVEL_HIGHEST_AVAILABLE + 1; | |
| ACTCTX_RUN_LEVEL_NUMBERS :: ACTCTX_RUN_LEVEL_REQUIRE_ADMIN + 1; | |
| /* } */ | |
| ; | |
| ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION :: struct { | |
| ulFlags : DWORD, | |
| RunLevel : ACTCTX_REQUESTED_RUN_LEVEL, | |
| UiAccess : DWORD, | |
| }; | |
| PACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION :: ^ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION; | |
| PCACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION :: ^ACTIVATION_CONTEXT_RUN_LEVEL_INFORMATION; | |
| /* ACTCTX_COMPATIBILITY_ELEMENT_TYPE :: enum { */ | |
| ACTCTX_COMPATIBILITY_ELEMENT_TYPE :: _c.int; | |
| ACTCTX_COMPATIBILITY_ELEMENT_TYPE_UNKNOWN :: 0; | |
| ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS :: ACTCTX_COMPATIBILITY_ELEMENT_TYPE_UNKNOWN + 1; | |
| ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MITIGATION :: ACTCTX_COMPATIBILITY_ELEMENT_TYPE_OS + 1; | |
| ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MAXVERSIONTESTED :: ACTCTX_COMPATIBILITY_ELEMENT_TYPE_MITIGATION + 1; | |
| /* } */ | |
| ; | |
| COMPATIBILITY_CONTEXT_ELEMENT :: struct { | |
| Id : GUID, | |
| Type : ACTCTX_COMPATIBILITY_ELEMENT_TYPE, | |
| MaxVersionTested : ULONGLONG, | |
| }; | |
| PCOMPATIBILITY_CONTEXT_ELEMENT :: ^COMPATIBILITY_CONTEXT_ELEMENT; | |
| PCCOMPATIBILITY_CONTEXT_ELEMENT :: ^COMPATIBILITY_CONTEXT_ELEMENT; | |
| SUPPORTED_OS_INFO :: struct { | |
| MajorVersion : WORD, | |
| MinorVersion : WORD, | |
| }; | |
| PSUPPORTED_OS_INFO :: ^SUPPORTED_OS_INFO; | |
| MAXVERSIONTESTED_INFO :: struct { | |
| MaxVersionTested : ULONGLONG, | |
| }; | |
| PMAXVERSIONTESTED_INFO :: ^MAXVERSIONTESTED_INFO; | |
| ACTIVATION_CONTEXT_DETAILED_INFORMATION :: struct { | |
| dwFlags : DWORD, | |
| ulFormatVersion : DWORD, | |
| ulAssemblyCount : DWORD, | |
| ulRootManifestPathType : DWORD, | |
| ulRootManifestPathChars : DWORD, | |
| ulRootConfigurationPathType : DWORD, | |
| ulRootConfigurationPathChars : DWORD, | |
| ulAppDirPathType : DWORD, | |
| ulAppDirPathChars : DWORD, | |
| lpRootManifestPath : PCWSTR, | |
| lpRootConfigurationPath : PCWSTR, | |
| lpAppDirPath : PCWSTR, | |
| }; | |
| PACTIVATION_CONTEXT_DETAILED_INFORMATION :: ^ACTIVATION_CONTEXT_DETAILED_INFORMATION; | |
| PCACTIVATION_CONTEXT_DETAILED_INFORMATION :: ^ACTIVATION_CONTEXT_DETAILED_INFORMATION; | |
| HARDWARE_COUNTER_DATA :: struct { | |
| Type : HARDWARE_COUNTER_TYPE, | |
| Reserved : DWORD, | |
| Value : DWORD64, | |
| }; | |
| PHARDWARE_COUNTER_DATA :: ^HARDWARE_COUNTER_DATA; | |
| PERFORMANCE_DATA :: struct { | |
| Size : WORD, | |
| Version : BYTE, | |
| HwCountersCount : BYTE, | |
| ContextSwitchCount : DWORD, | |
| WaitReasonBitMap : DWORD64, | |
| CycleTime : DWORD64, | |
| RetryCount : DWORD, | |
| Reserved : DWORD, | |
| HwCounters : [16]HARDWARE_COUNTER_DATA, | |
| }; | |
| PPERFORMANCE_DATA :: ^PERFORMANCE_DATA; | |
| EVENTLOGRECORD :: struct { | |
| 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 :: ^EVENTLOGRECORD; | |
| EVENTSFORLOGFILE :: struct {}; | |
| PEVENTSFORLOGFILE :: ^EVENTSFORLOGFILE; | |
| PACKEDEVENTINFO :: struct {}; | |
| PPACKEDEVENTINFO :: ^PACKEDEVENTINFO; | |
| /* SERVICE_NODE_TYPE :: enum { */ | |
| SERVICE_NODE_TYPE :: _c.int; | |
| DriverType :: 0x00000001; | |
| FileSystemType :: 0x00000002; | |
| Win32ServiceOwnProcess :: 0x00000010; | |
| Win32ServiceShareProcess :: 0x00000020; | |
| AdapterType :: 0x00000004; | |
| RecognizerType :: 0x00000008; | |
| /* } */ | |
| ; | |
| /* SERVICE_LOAD_TYPE :: enum { */ | |
| SERVICE_LOAD_TYPE :: _c.int; | |
| BootLoad :: 0x00000000; | |
| SystemLoad :: 0x00000001; | |
| AutoLoad :: 0x00000002; | |
| DemandLoad :: 0x00000003; | |
| DisableLoad :: 0x00000004; | |
| /* } */ | |
| ; | |
| /* SERVICE_ERROR_TYPE :: enum { */ | |
| SERVICE_ERROR_TYPE :: _c.int; | |
| IgnoreError :: 0x00000000; | |
| NormalError :: 0x00000001; | |
| SevereError :: 0x00000002; | |
| CriticalError :: 0x00000003; | |
| /* } */ | |
| ; | |
| TAPE_ERASE :: struct { | |
| Type : DWORD, | |
| Immediate : BOOLEAN, | |
| }; | |
| PTAPE_ERASE :: ^TAPE_ERASE; | |
| TAPE_PREPARE :: struct { | |
| Operation : DWORD, | |
| Immediate : BOOLEAN, | |
| }; | |
| PTAPE_PREPARE :: ^TAPE_PREPARE; | |
| TAPE_WRITE_MARKS :: struct { | |
| Type : DWORD, | |
| Count : DWORD, | |
| Immediate : BOOLEAN, | |
| }; | |
| PTAPE_WRITE_MARKS :: ^TAPE_WRITE_MARKS; | |
| TAPE_GET_POSITION :: struct { | |
| Type : DWORD, | |
| Partition : DWORD, | |
| Offset : LARGE_INTEGER, | |
| }; | |
| PTAPE_GET_POSITION :: ^TAPE_GET_POSITION; | |
| TAPE_SET_POSITION :: struct { | |
| Method : DWORD, | |
| Partition : DWORD, | |
| Offset : LARGE_INTEGER, | |
| Immediate : BOOLEAN, | |
| }; | |
| PTAPE_SET_POSITION :: ^TAPE_SET_POSITION; | |
| TAPE_GET_DRIVE_PARAMETERS :: struct { | |
| ECC : BOOLEAN, | |
| Compression : BOOLEAN, | |
| DataPadding : BOOLEAN, | |
| ReportSetmarks : BOOLEAN, | |
| DefaultBlockSize : DWORD, | |
| MaximumBlockSize : DWORD, | |
| MinimumBlockSize : DWORD, | |
| MaximumPartitionCount : DWORD, | |
| FeaturesLow : DWORD, | |
| FeaturesHigh : DWORD, | |
| EOTWarningZoneSize : DWORD, | |
| }; | |
| PTAPE_GET_DRIVE_PARAMETERS :: ^TAPE_GET_DRIVE_PARAMETERS; | |
| TAPE_SET_DRIVE_PARAMETERS :: struct { | |
| ECC : BOOLEAN, | |
| Compression : BOOLEAN, | |
| DataPadding : BOOLEAN, | |
| ReportSetmarks : BOOLEAN, | |
| EOTWarningZoneSize : DWORD, | |
| }; | |
| PTAPE_SET_DRIVE_PARAMETERS :: ^TAPE_SET_DRIVE_PARAMETERS; | |
| TAPE_GET_MEDIA_PARAMETERS :: struct { | |
| Capacity : LARGE_INTEGER, | |
| Remaining : LARGE_INTEGER, | |
| BlockSize : DWORD, | |
| PartitionCount : DWORD, | |
| WriteProtected : BOOLEAN, | |
| }; | |
| PTAPE_GET_MEDIA_PARAMETERS :: ^TAPE_GET_MEDIA_PARAMETERS; | |
| TAPE_SET_MEDIA_PARAMETERS :: struct { | |
| BlockSize : DWORD, | |
| }; | |
| PTAPE_SET_MEDIA_PARAMETERS :: ^TAPE_SET_MEDIA_PARAMETERS; | |
| TAPE_CREATE_PARTITION :: struct { | |
| Method : DWORD, | |
| Count : DWORD, | |
| Size : DWORD, | |
| }; | |
| PTAPE_CREATE_PARTITION :: ^TAPE_CREATE_PARTITION; | |
| TAPE_WMI_OPERATIONS :: struct { | |
| Method : DWORD, | |
| DataBufferSize : DWORD, | |
| DataBuffer : PVOID, | |
| }; | |
| PTAPE_WMI_OPERATIONS :: ^TAPE_WMI_OPERATIONS; | |
| /* TAPE_DRIVE_PROBLEM_TYPE :: enum { */ | |
| TAPE_DRIVE_PROBLEM_TYPE :: _c.int; | |
| TapeDriveProblemNone :: 0; | |
| TapeDriveReadWriteWarning :: TapeDriveProblemNone + 1; | |
| TapeDriveReadWriteError :: TapeDriveReadWriteWarning + 1; | |
| TapeDriveReadWarning :: TapeDriveReadWriteError + 1; | |
| TapeDriveWriteWarning :: TapeDriveReadWarning + 1; | |
| TapeDriveReadError :: TapeDriveWriteWarning + 1; | |
| TapeDriveWriteError :: TapeDriveReadError + 1; | |
| TapeDriveHardwareError :: TapeDriveWriteError + 1; | |
| TapeDriveUnsupportedMedia :: TapeDriveHardwareError + 1; | |
| TapeDriveScsiConnectionError :: TapeDriveUnsupportedMedia + 1; | |
| TapeDriveTimetoClean :: TapeDriveScsiConnectionError + 1; | |
| TapeDriveCleanDriveNow :: TapeDriveTimetoClean + 1; | |
| TapeDriveMediaLifeExpired :: TapeDriveCleanDriveNow + 1; | |
| TapeDriveSnappedTape :: TapeDriveMediaLifeExpired + 1; | |
| /* } */ | |
| ; | |
| UOW :: GUID; | |
| PUOW :: ^GUID; | |
| CRM_PROTOCOL_ID :: GUID; | |
| PCRM_PROTOCOL_ID :: ^GUID; | |
| NOTIFICATION_MASK :: ULONG; | |
| TRANSACTION_NOTIFICATION :: struct { | |
| TransactionKey : PVOID, | |
| TransactionNotification : ULONG, | |
| TmVirtualClock : LARGE_INTEGER, | |
| ArgumentLength : ULONG, | |
| }; | |
| PTRANSACTION_NOTIFICATION :: ^TRANSACTION_NOTIFICATION; | |
| TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT :: struct { | |
| EnlistmentId : GUID, | |
| UOW : UOW, | |
| }; | |
| PTRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT :: ^TRANSACTION_NOTIFICATION_RECOVERY_ARGUMENT; | |
| TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT :: struct { | |
| TmIdentity : GUID, | |
| Flags : ULONG, | |
| }; | |
| PTRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT :: ^TRANSACTION_NOTIFICATION_TM_ONLINE_ARGUMENT; | |
| SAVEPOINT_ID :: ULONG; | |
| PSAVEPOINT_ID :: ^ULONG; | |
| TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT :: struct { | |
| SavepointId : SAVEPOINT_ID, | |
| }; | |
| PTRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT :: ^TRANSACTION_NOTIFICATION_SAVEPOINT_ARGUMENT; | |
| TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT :: struct { | |
| PropagationCookie : ULONG, | |
| UOW : GUID, | |
| TmIdentity : GUID, | |
| BufferLength : ULONG, | |
| }; | |
| PTRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT :: ^TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT; | |
| TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT :: struct { | |
| MarshalCookie : ULONG, | |
| UOW : GUID, | |
| }; | |
| PTRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT :: ^TRANSACTION_NOTIFICATION_MARSHAL_ARGUMENT; | |
| TRANSACTION_NOTIFICATION_PROMOTE_ARGUMENT :: TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT; | |
| PTRANSACTION_NOTIFICATION_PROMOTE_ARGUMENT :: ^TRANSACTION_NOTIFICATION_PROPAGATE_ARGUMENT; | |
| KCRM_MARSHAL_HEADER :: struct { | |
| VersionMajor : ULONG, | |
| VersionMinor : ULONG, | |
| NumProtocols : ULONG, | |
| Unused : ULONG, | |
| }; | |
| PKCRM_MARSHAL_HEADER :: ^KCRM_MARSHAL_HEADER; | |
| PRKCRM_MARSHAL_HEADER :: ^KCRM_MARSHAL_HEADER; | |
| KCRM_TRANSACTION_BLOB :: struct { | |
| UOW : UOW, | |
| TmIdentity : GUID, | |
| IsolationLevel : ULONG, | |
| IsolationFlags : ULONG, | |
| Timeout : ULONG, | |
| Description : [64]WCHAR, | |
| }; | |
| PKCRM_TRANSACTION_BLOB :: ^KCRM_TRANSACTION_BLOB; | |
| PRKCRM_TRANSACTION_BLOB :: ^KCRM_TRANSACTION_BLOB; | |
| KCRM_PROTOCOL_BLOB :: struct { | |
| ProtocolId : CRM_PROTOCOL_ID, | |
| StaticInfoLength : ULONG, | |
| TransactionIdInfoLength : ULONG, | |
| Unused1 : ULONG, | |
| Unused2 : ULONG, | |
| }; | |
| PKCRM_PROTOCOL_BLOB :: ^KCRM_PROTOCOL_BLOB; | |
| PRKCRM_PROTOCOL_BLOB :: ^KCRM_PROTOCOL_BLOB; | |
| /* TRANSACTION_OUTCOME :: enum { */ | |
| TRANSACTION_OUTCOME :: _c.int; | |
| TransactionOutcomeUndetermined :: 1; | |
| TransactionOutcomeCommitted :: TransactionOutcomeUndetermined + 1; | |
| TransactionOutcomeAborted :: TransactionOutcomeCommitted + 1; | |
| /* } */ | |
| ; | |
| /* TRANSACTION_STATE :: enum { */ | |
| TRANSACTION_STATE :: _c.int; | |
| TransactionStateNormal :: 1; | |
| TransactionStateIndoubt :: TransactionStateNormal + 1; | |
| TransactionStateCommittedNotify :: TransactionStateIndoubt + 1; | |
| /* } */ | |
| ; | |
| TRANSACTION_BASIC_INFORMATION :: struct { | |
| TransactionId : GUID, | |
| State : DWORD, | |
| Outcome : DWORD, | |
| }; | |
| PTRANSACTION_BASIC_INFORMATION :: ^TRANSACTION_BASIC_INFORMATION; | |
| TRANSACTIONMANAGER_BASIC_INFORMATION :: struct { | |
| TmIdentity : GUID, | |
| VirtualClock : LARGE_INTEGER, | |
| }; | |
| PTRANSACTIONMANAGER_BASIC_INFORMATION :: ^TRANSACTIONMANAGER_BASIC_INFORMATION; | |
| TRANSACTIONMANAGER_LOG_INFORMATION :: struct { | |
| LogIdentity : GUID, | |
| }; | |
| PTRANSACTIONMANAGER_LOG_INFORMATION :: ^TRANSACTIONMANAGER_LOG_INFORMATION; | |
| TRANSACTIONMANAGER_LOGPATH_INFORMATION :: struct { | |
| LogPathLength : DWORD, | |
| LogPath : [1]WCHAR, | |
| }; | |
| PTRANSACTIONMANAGER_LOGPATH_INFORMATION :: ^TRANSACTIONMANAGER_LOGPATH_INFORMATION; | |
| TRANSACTIONMANAGER_RECOVERY_INFORMATION :: struct { | |
| LastRecoveredLsn : ULONGLONG, | |
| }; | |
| PTRANSACTIONMANAGER_RECOVERY_INFORMATION :: ^TRANSACTIONMANAGER_RECOVERY_INFORMATION; | |
| TRANSACTIONMANAGER_OLDEST_INFORMATION :: struct { | |
| OldestTransactionGuid : GUID, | |
| }; | |
| PTRANSACTIONMANAGER_OLDEST_INFORMATION :: ^TRANSACTIONMANAGER_OLDEST_INFORMATION; | |
| TRANSACTION_PROPERTIES_INFORMATION :: struct { | |
| IsolationLevel : DWORD, | |
| IsolationFlags : DWORD, | |
| Timeout : LARGE_INTEGER, | |
| Outcome : DWORD, | |
| DescriptionLength : DWORD, | |
| Description : [1]WCHAR, | |
| }; | |
| PTRANSACTION_PROPERTIES_INFORMATION :: ^TRANSACTION_PROPERTIES_INFORMATION; | |
| TRANSACTION_BIND_INFORMATION :: struct { | |
| TmHandle : HANDLE, | |
| }; | |
| PTRANSACTION_BIND_INFORMATION :: ^TRANSACTION_BIND_INFORMATION; | |
| TRANSACTION_ENLISTMENT_PAIR :: struct { | |
| EnlistmentId : GUID, | |
| ResourceManagerId : GUID, | |
| }; | |
| PTRANSACTION_ENLISTMENT_PAIR :: ^TRANSACTION_ENLISTMENT_PAIR; | |
| TRANSACTION_ENLISTMENTS_INFORMATION :: struct { | |
| NumberOfEnlistments : DWORD, | |
| EnlistmentPair : [1]TRANSACTION_ENLISTMENT_PAIR, | |
| }; | |
| PTRANSACTION_ENLISTMENTS_INFORMATION :: ^TRANSACTION_ENLISTMENTS_INFORMATION; | |
| TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION :: struct { | |
| SuperiorEnlistmentPair : TRANSACTION_ENLISTMENT_PAIR, | |
| }; | |
| PTRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION :: ^TRANSACTION_SUPERIOR_ENLISTMENT_INFORMATION; | |
| RESOURCEMANAGER_BASIC_INFORMATION :: struct { | |
| ResourceManagerId : GUID, | |
| DescriptionLength : DWORD, | |
| Description : [1]WCHAR, | |
| }; | |
| PRESOURCEMANAGER_BASIC_INFORMATION :: ^RESOURCEMANAGER_BASIC_INFORMATION; | |
| RESOURCEMANAGER_COMPLETION_INFORMATION :: struct { | |
| IoCompletionPortHandle : HANDLE, | |
| CompletionKey : ULONG_PTR, | |
| }; | |
| PRESOURCEMANAGER_COMPLETION_INFORMATION :: ^RESOURCEMANAGER_COMPLETION_INFORMATION; | |
| /* TRANSACTION_INFORMATION_CLASS :: enum { */ | |
| TRANSACTION_INFORMATION_CLASS :: _c.int; | |
| TransactionBasicInformation :: 0; | |
| TransactionPropertiesInformation :: TransactionBasicInformation + 1; | |
| TransactionEnlistmentInformation :: TransactionPropertiesInformation + 1; | |
| TransactionSuperiorEnlistmentInformation :: TransactionEnlistmentInformation + 1; | |
| TransactionBindInformation :: TransactionSuperiorEnlistmentInformation + 1; | |
| TransactionDTCPrivateInformation :: TransactionBindInformation + 1; | |
| /* } */ | |
| ; | |
| /* TRANSACTIONMANAGER_INFORMATION_CLASS :: enum { */ | |
| TRANSACTIONMANAGER_INFORMATION_CLASS :: _c.int; | |
| TransactionManagerBasicInformation :: 0; | |
| TransactionManagerLogInformation :: TransactionManagerBasicInformation + 1; | |
| TransactionManagerLogPathInformation :: TransactionManagerLogInformation + 1; | |
| TransactionManagerRecoveryInformation :: 4; | |
| TransactionManagerOnlineProbeInformation :: 3; | |
| TransactionManagerOldestTransactionInformation :: 5; | |
| /* } */ | |
| ; | |
| /* RESOURCEMANAGER_INFORMATION_CLASS :: enum { */ | |
| RESOURCEMANAGER_INFORMATION_CLASS :: _c.int; | |
| ResourceManagerBasicInformation :: 0; | |
| ResourceManagerCompletionInformation :: ResourceManagerBasicInformation + 1; | |
| /* } */ | |
| ; | |
| ENLISTMENT_BASIC_INFORMATION :: struct { | |
| EnlistmentId : GUID, | |
| TransactionId : GUID, | |
| ResourceManagerId : GUID, | |
| }; | |
| PENLISTMENT_BASIC_INFORMATION :: ^ENLISTMENT_BASIC_INFORMATION; | |
| ENLISTMENT_CRM_INFORMATION :: struct { | |
| CrmTransactionManagerId : GUID, | |
| CrmResourceManagerId : GUID, | |
| CrmEnlistmentId : GUID, | |
| }; | |
| PENLISTMENT_CRM_INFORMATION :: ^ENLISTMENT_CRM_INFORMATION; | |
| /* ENLISTMENT_INFORMATION_CLASS :: enum { */ | |
| ENLISTMENT_INFORMATION_CLASS :: _c.int; | |
| EnlistmentBasicInformation :: 0; | |
| EnlistmentRecoveryInformation :: EnlistmentBasicInformation + 1; | |
| EnlistmentCrmInformation :: EnlistmentRecoveryInformation + 1; | |
| /* } */ | |
| ; | |
| TRANSACTION_LIST_ENTRY :: struct { | |
| UOW : UOW, | |
| }; | |
| PTRANSACTION_LIST_ENTRY :: ^TRANSACTION_LIST_ENTRY; | |
| TRANSACTION_LIST_INFORMATION :: struct { | |
| NumberOfTransactions : DWORD, | |
| TransactionInformation : [1]TRANSACTION_LIST_ENTRY, | |
| }; | |
| PTRANSACTION_LIST_INFORMATION :: ^TRANSACTION_LIST_INFORMATION; | |
| /* KTMOBJECT_TYPE :: enum { */ | |
| KTMOBJECT_TYPE :: _c.int; | |
| KTMOBJECT_TRANSACTION :: 0; | |
| KTMOBJECT_TRANSACTION_MANAGER :: KTMOBJECT_TRANSACTION + 1; | |
| KTMOBJECT_RESOURCE_MANAGER :: KTMOBJECT_TRANSACTION_MANAGER + 1; | |
| KTMOBJECT_ENLISTMENT :: KTMOBJECT_RESOURCE_MANAGER + 1; | |
| KTMOBJECT_INVALID :: KTMOBJECT_ENLISTMENT + 1; | |
| /* } */ | |
| PKTMOBJECT_TYPE :: ^KTMOBJECT_TYPE; | |
| KTMOBJECT_CURSOR :: struct { | |
| LastQuery : GUID, | |
| ObjectIdCount : DWORD, | |
| ObjectIds : [1]GUID, | |
| }; | |
| PKTMOBJECT_CURSOR :: ^KTMOBJECT_CURSOR; | |
| TP_VERSION :: DWORD; | |
| PTP_VERSION :: ^DWORD; | |
| TP_CALLBACK_INSTANCE :: struct {}; | |
| PTP_CALLBACK_INSTANCE :: ^TP_CALLBACK_INSTANCE; | |
| PTP_SIMPLE_CALLBACK :: proc "stdcall" (Instance : PTP_CALLBACK_INSTANCE, Context : PVOID); | |
| TP_POOL :: struct {}; | |
| PTP_POOL :: ^TP_POOL; | |
| /* TP_CALLBACK_PRIORITY :: enum { */ | |
| TP_CALLBACK_PRIORITY :: _c.int; | |
| TP_CALLBACK_PRIORITY_HIGH :: 0; | |
| TP_CALLBACK_PRIORITY_NORMAL :: TP_CALLBACK_PRIORITY_HIGH + 1; | |
| TP_CALLBACK_PRIORITY_LOW :: TP_CALLBACK_PRIORITY_NORMAL + 1; | |
| TP_CALLBACK_PRIORITY_INVALID :: TP_CALLBACK_PRIORITY_LOW + 1; | |
| TP_CALLBACK_PRIORITY_COUNT :: TP_CALLBACK_PRIORITY_INVALID; | |
| /* } */ | |
| ; | |
| TP_POOL_STACK_INFORMATION :: struct { | |
| StackReserve : SIZE_T, | |
| StackCommit : SIZE_T, | |
| }; | |
| PTP_POOL_STACK_INFORMATION :: ^TP_POOL_STACK_INFORMATION; | |
| TP_CLEANUP_GROUP :: struct {}; | |
| PTP_CLEANUP_GROUP :: ^TP_CLEANUP_GROUP; | |
| PTP_CLEANUP_GROUP_CANCEL_CALLBACK :: proc "stdcall" (ObjectContext : PVOID, CleanupContext : PVOID); | |
| TP_CALLBACK_ENVIRON_V3 :: struct { | |
| Version : TP_VERSION, | |
| Pool : PTP_POOL, | |
| CleanupGroup : PTP_CLEANUP_GROUP, | |
| CleanupGroupCancelCallback : PTP_CLEANUP_GROUP_CANCEL_CALLBACK, | |
| RaceDll : PVOID, | |
| ActivationContext : ^_ACTIVATION_CONTEXT, | |
| FinalizationCallback : PTP_SIMPLE_CALLBACK, | |
| u : struct #raw_union { | |
| Flags : DWORD, | |
| s : bit_field { | |
| LongFunction : 1, | |
| Persistent : 1, | |
| Private : 30, | |
| }, | |
| }, | |
| CallbackPriority : TP_CALLBACK_PRIORITY, | |
| Size : DWORD, | |
| }; | |
| TP_CALLBACK_ENVIRON :: TP_CALLBACK_ENVIRON_V3; | |
| PTP_CALLBACK_ENVIRON :: ^TP_CALLBACK_ENVIRON_V3; | |
| TP_WORK :: struct {}; | |
| PTP_WORK :: ^TP_WORK; | |
| PTP_WORK_CALLBACK :: proc "stdcall" (Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Work : PTP_WORK); | |
| TP_TIMER :: struct {}; | |
| PTP_TIMER :: ^TP_TIMER; | |
| PTP_TIMER_CALLBACK :: proc "stdcall" (Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Timer : PTP_TIMER); | |
| TP_WAIT_RESULT :: DWORD; | |
| TP_WAIT :: struct {}; | |
| PTP_WAIT :: ^TP_WAIT; | |
| PTP_WAIT_CALLBACK :: proc "stdcall" (Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Wait : PTP_WAIT, WaitResult : TP_WAIT_RESULT); | |
| TP_IO :: struct {}; | |
| PTP_IO :: ^TP_IO; | |
| WPARAM :: UINT_PTR; | |
| LPARAM :: LONG_PTR; | |
| LRESULT :: LONG_PTR; | |
| SPHANDLE :: ^HANDLE; | |
| LPHANDLE :: ^HANDLE; | |
| HGLOBAL :: HANDLE; | |
| HLOCAL :: HANDLE; | |
| GLOBALHANDLE :: HANDLE; | |
| LOCALHANDLE :: HANDLE; | |
| FARPROC :: (proc "stdcall" () -> INT_PTR); | |
| NEARPROC :: (proc "stdcall" () -> INT_PTR); | |
| PROC :: (proc "stdcall" () -> INT_PTR); | |
| ATOM :: WORD; | |
| HKEY__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HKEY :: ^HKEY__; | |
| PHKEY :: ^HKEY; | |
| HMETAFILE__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HMETAFILE :: ^HMETAFILE__; | |
| HINSTANCE__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HINSTANCE :: ^HINSTANCE__; | |
| HMODULE :: HINSTANCE; | |
| HRGN__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HRGN :: ^HRGN__; | |
| HRSRC__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HRSRC :: ^HRSRC__; | |
| HSPRITE__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HSPRITE :: ^HSPRITE__; | |
| HLSURF__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HLSURF :: ^HLSURF__; | |
| HSTR__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HSTR :: ^HSTR__; | |
| HTASK__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HTASK :: ^HTASK__; | |
| HWINSTA__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HWINSTA :: ^HWINSTA__; | |
| HKL__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HKL :: ^HKL__; | |
| HFILE :: _c.int; | |
| FILETIME :: struct { | |
| dwLowDateTime : DWORD, | |
| dwHighDateTime : DWORD, | |
| }; | |
| PFILETIME :: ^FILETIME; | |
| LPFILETIME :: ^FILETIME; | |
| HWND__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HWND :: ^HWND__; | |
| HHOOK__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HHOOK :: ^HHOOK__; | |
| HGDIOBJ :: rawptr; | |
| HACCEL__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HACCEL :: ^HACCEL__; | |
| HBITMAP__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HBITMAP :: ^HBITMAP__; | |
| HBRUSH__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HBRUSH :: ^HBRUSH__; | |
| HCOLORSPACE__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HCOLORSPACE :: ^HCOLORSPACE__; | |
| HDC__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HDC :: ^HDC__; | |
| HGLRC__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HGLRC :: ^HGLRC__; | |
| HDESK__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HDESK :: ^HDESK__; | |
| HENHMETAFILE__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HENHMETAFILE :: ^HENHMETAFILE__; | |
| HFONT__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HFONT :: ^HFONT__; | |
| HICON__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HICON :: ^HICON__; | |
| HMENU__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HMENU :: ^HMENU__; | |
| HPALETTE__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HPALETTE :: ^HPALETTE__; | |
| HPEN__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HPEN :: ^HPEN__; | |
| HWINEVENTHOOK__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HWINEVENTHOOK :: ^HWINEVENTHOOK__; | |
| HMONITOR__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HMONITOR :: ^HMONITOR__; | |
| HUMPD__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HUMPD :: ^HUMPD__; | |
| HCURSOR :: HICON; | |
| COLORREF :: DWORD; | |
| LPCOLORREF :: ^DWORD; | |
| RECT :: struct { | |
| left : LONG, | |
| top : LONG, | |
| right : LONG, | |
| bottom : LONG, | |
| }; | |
| PRECT :: ^RECT; | |
| NPRECT :: ^RECT; | |
| LPRECT :: ^RECT; | |
| LPCRECT :: ^RECT; | |
| RECTL :: struct { | |
| left : LONG, | |
| top : LONG, | |
| right : LONG, | |
| bottom : LONG, | |
| }; | |
| PRECTL :: ^RECTL; | |
| LPRECTL :: ^RECTL; | |
| LPCRECTL :: ^RECTL; | |
| POINT :: struct { | |
| x : LONG, | |
| y : LONG, | |
| }; | |
| PPOINT :: ^POINT; | |
| NPPOINT :: ^POINT; | |
| LPPOINT :: ^POINT; | |
| POINTL :: struct { | |
| x : LONG, | |
| y : LONG, | |
| }; | |
| PPOINTL :: ^POINTL; | |
| SIZE :: struct { | |
| cx : LONG, | |
| cy : LONG, | |
| }; | |
| PSIZE :: ^SIZE; | |
| LPSIZE :: ^SIZE; | |
| SIZEL :: SIZE; | |
| PSIZEL :: ^SIZE; | |
| LPSIZEL :: ^SIZE; | |
| POINTS :: struct { | |
| x : SHORT, | |
| y : SHORT, | |
| }; | |
| PPOINTS :: ^POINTS; | |
| LPPOINTS :: ^POINTS; | |
| DPI_AWARENESS_CONTEXT__ :: struct { | |
| unused : _c.int, | |
| }; | |
| DPI_AWARENESS_CONTEXT :: ^DPI_AWARENESS_CONTEXT__; | |
| /* DPI_AWARENESS :: enum { */ | |
| DPI_AWARENESS :: _c.int; | |
| DPI_AWARENESS_INVALID :: -1; | |
| DPI_AWARENESS_UNAWARE :: 0; | |
| DPI_AWARENESS_SYSTEM_AWARE :: 1; | |
| DPI_AWARENESS_PER_MONITOR_AWARE :: 2; | |
| /* } */ | |
| ; | |
| /* DPI_HOSTING_BEHAVIOR :: enum { */ | |
| DPI_HOSTING_BEHAVIOR :: _c.int; | |
| DPI_HOSTING_BEHAVIOR_INVALID :: -1; | |
| DPI_HOSTING_BEHAVIOR_DEFAULT :: 0; | |
| DPI_HOSTING_BEHAVIOR_MIXED :: 1; | |
| /* } */ | |
| ; | |
| SECURITY_ATTRIBUTES :: struct { | |
| nLength : DWORD, | |
| lpSecurityDescriptor : LPVOID, | |
| bInheritHandle : BOOL, | |
| }; | |
| PSECURITY_ATTRIBUTES :: ^SECURITY_ATTRIBUTES; | |
| LPSECURITY_ATTRIBUTES :: ^SECURITY_ATTRIBUTES; | |
| OVERLAPPED :: struct { | |
| Internal : ULONG_PTR, | |
| InternalHigh : ULONG_PTR, | |
| u : struct #raw_union { | |
| s : struct { | |
| Offset : DWORD, | |
| OffsetHigh : DWORD, | |
| }, | |
| Pointer : PVOID, | |
| }, | |
| hEvent : HANDLE, | |
| }; | |
| LPOVERLAPPED :: ^OVERLAPPED; | |
| OVERLAPPED_ENTRY :: struct { | |
| lpCompletionKey : ULONG_PTR, | |
| lpOverlapped : LPOVERLAPPED, | |
| Internal : ULONG_PTR, | |
| dwNumberOfBytesTransferred : DWORD, | |
| }; | |
| LPOVERLAPPED_ENTRY :: ^OVERLAPPED_ENTRY; | |
| SYSTEMTIME :: struct { | |
| wYear : WORD, | |
| wMonth : WORD, | |
| wDayOfWeek : WORD, | |
| wDay : WORD, | |
| wHour : WORD, | |
| wMinute : WORD, | |
| wSecond : WORD, | |
| wMilliseconds : WORD, | |
| }; | |
| PSYSTEMTIME :: ^SYSTEMTIME; | |
| LPSYSTEMTIME :: ^SYSTEMTIME; | |
| WIN32_FIND_DATAA :: struct { | |
| dwFileAttributes : DWORD, | |
| ftCreationTime : FILETIME, | |
| ftLastAccessTime : FILETIME, | |
| ftLastWriteTime : FILETIME, | |
| nFileSizeHigh : DWORD, | |
| nFileSizeLow : DWORD, | |
| dwReserved0 : DWORD, | |
| dwReserved1 : DWORD, | |
| cFileName : [260]CHAR, | |
| cAlternateFileName : [14]CHAR, | |
| }; | |
| PWIN32_FIND_DATAA :: ^WIN32_FIND_DATAA; | |
| LPWIN32_FIND_DATAA :: ^WIN32_FIND_DATAA; | |
| WIN32_FIND_DATAW :: struct { | |
| dwFileAttributes : DWORD, | |
| ftCreationTime : FILETIME, | |
| ftLastAccessTime : FILETIME, | |
| ftLastWriteTime : FILETIME, | |
| nFileSizeHigh : DWORD, | |
| nFileSizeLow : DWORD, | |
| dwReserved0 : DWORD, | |
| dwReserved1 : DWORD, | |
| cFileName : [260]WCHAR, | |
| cAlternateFileName : [14]WCHAR, | |
| }; | |
| PWIN32_FIND_DATAW :: ^WIN32_FIND_DATAW; | |
| LPWIN32_FIND_DATAW :: ^WIN32_FIND_DATAW; | |
| WIN32_FIND_DATA :: WIN32_FIND_DATAA; | |
| PWIN32_FIND_DATA :: PWIN32_FIND_DATAA; | |
| LPWIN32_FIND_DATA :: LPWIN32_FIND_DATAA; | |
| /* FINDEX_INFO_LEVELS :: enum { */ | |
| FINDEX_INFO_LEVELS :: _c.int; | |
| FindExInfoStandard :: 0; | |
| FindExInfoBasic :: FindExInfoStandard + 1; | |
| FindExInfoMaxInfoLevel :: FindExInfoBasic + 1; | |
| /* } */ | |
| ; | |
| /* FINDEX_SEARCH_OPS :: enum { */ | |
| FINDEX_SEARCH_OPS :: _c.int; | |
| FindExSearchNameMatch :: 0; | |
| FindExSearchLimitToDirectories :: FindExSearchNameMatch + 1; | |
| FindExSearchLimitToDevices :: FindExSearchLimitToDirectories + 1; | |
| FindExSearchMaxSearchOp :: FindExSearchLimitToDevices + 1; | |
| /* } */ | |
| ; | |
| /* READ_DIRECTORY_NOTIFY_INFORMATION_CLASS :: enum { */ | |
| READ_DIRECTORY_NOTIFY_INFORMATION_CLASS :: _c.int; | |
| ReadDirectoryNotifyInformation :: 1; | |
| ReadDirectoryNotifyExtendedInformation :: ReadDirectoryNotifyInformation + 1; | |
| /* } */ | |
| PREAD_DIRECTORY_NOTIFY_INFORMATION_CLASS :: ^READ_DIRECTORY_NOTIFY_INFORMATION_CLASS; | |
| /* GET_FILEEX_INFO_LEVELS :: enum { */ | |
| GET_FILEEX_INFO_LEVELS :: _c.int; | |
| GetFileExInfoStandard :: 0; | |
| GetFileExMaxInfoLevel :: GetFileExInfoStandard + 1; | |
| /* } */ | |
| ; | |
| /* FILE_INFO_BY_HANDLE_CLASS :: enum { */ | |
| FILE_INFO_BY_HANDLE_CLASS :: _c.int; | |
| FileBasicInfo :: 0; | |
| FileStandardInfo :: FileBasicInfo + 1; | |
| FileNameInfo :: FileStandardInfo + 1; | |
| FileRenameInfo :: FileNameInfo + 1; | |
| FileDispositionInfo :: FileRenameInfo + 1; | |
| FileAllocationInfo :: FileDispositionInfo + 1; | |
| FileEndOfFileInfo :: FileAllocationInfo + 1; | |
| FileStreamInfo :: FileEndOfFileInfo + 1; | |
| FileCompressionInfo :: FileStreamInfo + 1; | |
| FileAttributeTagInfo :: FileCompressionInfo + 1; | |
| FileIdBothDirectoryInfo :: FileAttributeTagInfo + 1; | |
| FileIdBothDirectoryRestartInfo :: FileIdBothDirectoryInfo + 1; | |
| FileIoPriorityHintInfo :: FileIdBothDirectoryRestartInfo + 1; | |
| FileRemoteProtocolInfo :: FileIoPriorityHintInfo + 1; | |
| FileFullDirectoryInfo :: FileRemoteProtocolInfo + 1; | |
| FileFullDirectoryRestartInfo :: FileFullDirectoryInfo + 1; | |
| FileStorageInfo :: FileFullDirectoryRestartInfo + 1; | |
| FileAlignmentInfo :: FileStorageInfo + 1; | |
| FileIdInfo :: FileAlignmentInfo + 1; | |
| FileIdExtdDirectoryInfo :: FileIdInfo + 1; | |
| FileIdExtdDirectoryRestartInfo :: FileIdExtdDirectoryInfo + 1; | |
| FileDispositionInfoEx :: FileIdExtdDirectoryRestartInfo + 1; | |
| FileRenameInfoEx :: FileDispositionInfoEx + 1; | |
| FileCaseSensitiveInfo :: FileRenameInfoEx + 1; | |
| FileNormalizedNameInfo :: FileCaseSensitiveInfo + 1; | |
| MaximumFileInfoByHandleClass :: FileNormalizedNameInfo + 1; | |
| /* } */ | |
| PFILE_INFO_BY_HANDLE_CLASS :: ^FILE_INFO_BY_HANDLE_CLASS; | |
| CRITICAL_SECTION :: RTL_CRITICAL_SECTION; | |
| PCRITICAL_SECTION :: PRTL_CRITICAL_SECTION; | |
| LPCRITICAL_SECTION :: PRTL_CRITICAL_SECTION; | |
| CRITICAL_SECTION_DEBUG :: RTL_CRITICAL_SECTION_DEBUG; | |
| PCRITICAL_SECTION_DEBUG :: PRTL_CRITICAL_SECTION_DEBUG; | |
| LPCRITICAL_SECTION_DEBUG :: PRTL_CRITICAL_SECTION_DEBUG; | |
| LPOVERLAPPED_COMPLETION_ROUTINE :: proc "stdcall" (dwErrorCode : DWORD, dwNumberOfBytesTransfered : DWORD, lpOverlapped : LPOVERLAPPED); | |
| PROCESS_HEAP_ENTRY :: struct { | |
| lpData : PVOID, | |
| cbData : DWORD, | |
| cbOverhead : BYTE, | |
| iRegionIndex : BYTE, | |
| wFlags : WORD, | |
| u : struct #raw_union { | |
| Block : struct { | |
| hMem : HANDLE, | |
| dwReserved : [3]DWORD, | |
| }, | |
| Region : struct { | |
| dwCommittedSize : DWORD, | |
| dwUnCommittedSize : DWORD, | |
| lpFirstBlock : LPVOID, | |
| lpLastBlock : LPVOID, | |
| }, | |
| }, | |
| }; | |
| LPPROCESS_HEAP_ENTRY :: ^PROCESS_HEAP_ENTRY; | |
| PPROCESS_HEAP_ENTRY :: ^PROCESS_HEAP_ENTRY; | |
| REASON_CONTEXT :: struct { | |
| Version : ULONG, | |
| Flags : DWORD, | |
| Reason : struct #raw_union { | |
| Detailed : struct { | |
| LocalizedReasonModule : HMODULE, | |
| LocalizedReasonId : ULONG, | |
| ReasonStringCount : ULONG, | |
| ReasonStrings : ^LPWSTR, | |
| }, | |
| SimpleReasonString : LPWSTR, | |
| }, | |
| }; | |
| PREASON_CONTEXT :: ^REASON_CONTEXT; | |
| PTHREAD_START_ROUTINE :: (proc "stdcall" (lpThreadParameter : LPVOID) -> DWORD); | |
| LPTHREAD_START_ROUTINE :: PTHREAD_START_ROUTINE; | |
| PENCLAVE_ROUTINE :: (proc "stdcall" (lpThreadParameter : LPVOID) -> LPVOID); | |
| LPENCLAVE_ROUTINE :: PENCLAVE_ROUTINE; | |
| EXCEPTION_DEBUG_INFO :: struct { | |
| ExceptionRecord : EXCEPTION_RECORD, | |
| dwFirstChance : DWORD, | |
| }; | |
| LPEXCEPTION_DEBUG_INFO :: ^EXCEPTION_DEBUG_INFO; | |
| CREATE_THREAD_DEBUG_INFO :: struct { | |
| hThread : HANDLE, | |
| lpThreadLocalBase : LPVOID, | |
| lpStartAddress : LPTHREAD_START_ROUTINE, | |
| }; | |
| LPCREATE_THREAD_DEBUG_INFO :: ^CREATE_THREAD_DEBUG_INFO; | |
| CREATE_PROCESS_DEBUG_INFO :: struct { | |
| hFile : HANDLE, | |
| hProcess : HANDLE, | |
| hThread : HANDLE, | |
| lpBaseOfImage : LPVOID, | |
| dwDebugInfoFileOffset : DWORD, | |
| nDebugInfoSize : DWORD, | |
| lpThreadLocalBase : LPVOID, | |
| lpStartAddress : LPTHREAD_START_ROUTINE, | |
| lpImageName : LPVOID, | |
| fUnicode : WORD, | |
| }; | |
| LPCREATE_PROCESS_DEBUG_INFO :: ^CREATE_PROCESS_DEBUG_INFO; | |
| EXIT_THREAD_DEBUG_INFO :: struct { | |
| dwExitCode : DWORD, | |
| }; | |
| LPEXIT_THREAD_DEBUG_INFO :: ^EXIT_THREAD_DEBUG_INFO; | |
| EXIT_PROCESS_DEBUG_INFO :: struct { | |
| dwExitCode : DWORD, | |
| }; | |
| LPEXIT_PROCESS_DEBUG_INFO :: ^EXIT_PROCESS_DEBUG_INFO; | |
| LOAD_DLL_DEBUG_INFO :: struct { | |
| hFile : HANDLE, | |
| lpBaseOfDll : LPVOID, | |
| dwDebugInfoFileOffset : DWORD, | |
| nDebugInfoSize : DWORD, | |
| lpImageName : LPVOID, | |
| fUnicode : WORD, | |
| }; | |
| LPLOAD_DLL_DEBUG_INFO :: ^LOAD_DLL_DEBUG_INFO; | |
| UNLOAD_DLL_DEBUG_INFO :: struct { | |
| lpBaseOfDll : LPVOID, | |
| }; | |
| LPUNLOAD_DLL_DEBUG_INFO :: ^UNLOAD_DLL_DEBUG_INFO; | |
| OUTPUT_DEBUG_STRING_INFO :: struct { | |
| lpDebugStringData : LPSTR, | |
| fUnicode : WORD, | |
| nDebugStringLength : WORD, | |
| }; | |
| LPOUTPUT_DEBUG_STRING_INFO :: ^OUTPUT_DEBUG_STRING_INFO; | |
| RIP_INFO :: struct { | |
| dwError : DWORD, | |
| dwType : DWORD, | |
| }; | |
| LPRIP_INFO :: ^RIP_INFO; | |
| DEBUG_EVENT :: struct { | |
| dwDebugEventCode : DWORD, | |
| dwProcessId : DWORD, | |
| dwThreadId : DWORD, | |
| u : struct #raw_union { | |
| Exception : EXCEPTION_DEBUG_INFO, | |
| CreateThread : CREATE_THREAD_DEBUG_INFO, | |
| CreateProcessInfo : CREATE_PROCESS_DEBUG_INFO, | |
| ExitThread : EXIT_THREAD_DEBUG_INFO, | |
| ExitProcess : EXIT_PROCESS_DEBUG_INFO, | |
| LoadDll : LOAD_DLL_DEBUG_INFO, | |
| UnloadDll : UNLOAD_DLL_DEBUG_INFO, | |
| DebugString : OUTPUT_DEBUG_STRING_INFO, | |
| RipInfo : RIP_INFO, | |
| }, | |
| }; | |
| LPDEBUG_EVENT :: ^DEBUG_EVENT; | |
| LPCONTEXT :: PCONTEXT; | |
| DISK_SPACE_INFORMATION :: struct { | |
| ActualTotalAllocationUnits : ULONGLONG, | |
| ActualAvailableAllocationUnits : ULONGLONG, | |
| ActualPoolUnavailableAllocationUnits : ULONGLONG, | |
| CallerTotalAllocationUnits : ULONGLONG, | |
| CallerAvailableAllocationUnits : ULONGLONG, | |
| CallerPoolUnavailableAllocationUnits : ULONGLONG, | |
| UsedAllocationUnits : ULONGLONG, | |
| TotalReservedAllocationUnits : ULONGLONG, | |
| VolumeStorageReserveAllocationUnits : ULONGLONG, | |
| AvailableCommittedAllocationUnits : ULONGLONG, | |
| PoolAvailableAllocationUnits : ULONGLONG, | |
| SectorsPerAllocationUnit : DWORD, | |
| BytesPerSector : DWORD, | |
| }; | |
| WIN32_FILE_ATTRIBUTE_DATA :: struct { | |
| dwFileAttributes : DWORD, | |
| ftCreationTime : FILETIME, | |
| ftLastAccessTime : FILETIME, | |
| ftLastWriteTime : FILETIME, | |
| nFileSizeHigh : DWORD, | |
| nFileSizeLow : DWORD, | |
| }; | |
| LPWIN32_FILE_ATTRIBUTE_DATA :: ^WIN32_FILE_ATTRIBUTE_DATA; | |
| BY_HANDLE_FILE_INFORMATION :: struct { | |
| dwFileAttributes : DWORD, | |
| ftCreationTime : FILETIME, | |
| ftLastAccessTime : FILETIME, | |
| ftLastWriteTime : FILETIME, | |
| dwVolumeSerialNumber : DWORD, | |
| nFileSizeHigh : DWORD, | |
| nFileSizeLow : DWORD, | |
| nNumberOfLinks : DWORD, | |
| nFileIndexHigh : DWORD, | |
| nFileIndexLow : DWORD, | |
| }; | |
| PBY_HANDLE_FILE_INFORMATION :: ^BY_HANDLE_FILE_INFORMATION; | |
| LPBY_HANDLE_FILE_INFORMATION :: ^BY_HANDLE_FILE_INFORMATION; | |
| CREATEFILE2_EXTENDED_PARAMETERS :: struct { | |
| dwSize : DWORD, | |
| dwFileAttributes : DWORD, | |
| dwFileFlags : DWORD, | |
| dwSecurityQosFlags : DWORD, | |
| lpSecurityAttributes : LPSECURITY_ATTRIBUTES, | |
| hTemplateFile : HANDLE, | |
| }; | |
| PCREATEFILE2_EXTENDED_PARAMETERS :: ^CREATEFILE2_EXTENDED_PARAMETERS; | |
| LPCREATEFILE2_EXTENDED_PARAMETERS :: ^CREATEFILE2_EXTENDED_PARAMETERS; | |
| /* STREAM_INFO_LEVELS :: enum { */ | |
| STREAM_INFO_LEVELS :: _c.int; | |
| FindStreamInfoStandard :: 0; | |
| FindStreamInfoMaxInfoLevel :: FindStreamInfoStandard + 1; | |
| /* } */ | |
| ; | |
| WIN32_FIND_STREAM_DATA :: struct { | |
| StreamSize : LARGE_INTEGER, | |
| cStreamName : [260 + 36]WCHAR, | |
| }; | |
| PWIN32_FIND_STREAM_DATA :: ^WIN32_FIND_STREAM_DATA; | |
| PTOP_LEVEL_EXCEPTION_FILTER :: (proc "stdcall" (ExceptionInfo : ^EXCEPTION_POINTERS) -> LONG); | |
| LPTOP_LEVEL_EXCEPTION_FILTER :: PTOP_LEVEL_EXCEPTION_FILTER; | |
| HEAP_SUMMARY :: struct { | |
| cb : DWORD, | |
| cbAllocated : SIZE_T, | |
| cbCommitted : SIZE_T, | |
| cbReserved : SIZE_T, | |
| cbMaxReserve : SIZE_T, | |
| }; | |
| PHEAP_SUMMARY :: ^HEAP_SUMMARY; | |
| LPHEAP_SUMMARY :: PHEAP_SUMMARY; | |
| SRWLOCK :: RTL_SRWLOCK; | |
| PSRWLOCK :: ^RTL_SRWLOCK; | |
| INIT_ONCE :: RTL_RUN_ONCE; | |
| PINIT_ONCE :: PRTL_RUN_ONCE; | |
| LPINIT_ONCE :: PRTL_RUN_ONCE; | |
| PINIT_ONCE_FN :: (proc "stdcall" (InitOnce : PINIT_ONCE, Parameter : PVOID, Context : ^PVOID) -> BOOL); | |
| CONDITION_VARIABLE :: RTL_CONDITION_VARIABLE; | |
| PCONDITION_VARIABLE :: ^RTL_CONDITION_VARIABLE; | |
| PTIMERAPCROUTINE :: proc "stdcall" (lpArgToCompletionRoutine : LPVOID, dwTimerLowValue : DWORD, dwTimerHighValue : DWORD); | |
| SYNCHRONIZATION_BARRIER :: RTL_BARRIER; | |
| PSYNCHRONIZATION_BARRIER :: PRTL_BARRIER; | |
| LPSYNCHRONIZATION_BARRIER :: PRTL_BARRIER; | |
| PROCESS_INFORMATION :: struct { | |
| hProcess : HANDLE, | |
| hThread : HANDLE, | |
| dwProcessId : DWORD, | |
| dwThreadId : DWORD, | |
| }; | |
| PPROCESS_INFORMATION :: ^PROCESS_INFORMATION; | |
| LPPROCESS_INFORMATION :: ^PROCESS_INFORMATION; | |
| STARTUPINFOA :: struct { | |
| cb : DWORD, | |
| lpReserved : LPSTR, | |
| lpDesktop : LPSTR, | |
| lpTitle : LPSTR, | |
| dwX : DWORD, | |
| dwY : DWORD, | |
| dwXSize : DWORD, | |
| dwYSize : DWORD, | |
| dwXCountChars : DWORD, | |
| dwYCountChars : DWORD, | |
| dwFillAttribute : DWORD, | |
| dwFlags : DWORD, | |
| wShowWindow : WORD, | |
| cbReserved2 : WORD, | |
| lpReserved2 : LPBYTE, | |
| hStdInput : HANDLE, | |
| hStdOutput : HANDLE, | |
| hStdError : HANDLE, | |
| }; | |
| LPSTARTUPINFOA :: ^STARTUPINFOA; | |
| STARTUPINFOW :: struct { | |
| cb : DWORD, | |
| lpReserved : LPWSTR, | |
| lpDesktop : LPWSTR, | |
| lpTitle : LPWSTR, | |
| dwX : DWORD, | |
| dwY : DWORD, | |
| dwXSize : DWORD, | |
| dwYSize : DWORD, | |
| dwXCountChars : DWORD, | |
| dwYCountChars : DWORD, | |
| dwFillAttribute : DWORD, | |
| dwFlags : DWORD, | |
| wShowWindow : WORD, | |
| cbReserved2 : WORD, | |
| lpReserved2 : LPBYTE, | |
| hStdInput : HANDLE, | |
| hStdOutput : HANDLE, | |
| hStdError : HANDLE, | |
| }; | |
| LPSTARTUPINFOW :: ^STARTUPINFOW; | |
| STARTUPINFO :: STARTUPINFOA; | |
| LPSTARTUPINFO :: LPSTARTUPINFOA; | |
| PPROC_THREAD_ATTRIBUTE_LIST :: ^_PROC_THREAD_ATTRIBUTE_LIST; | |
| LPPROC_THREAD_ATTRIBUTE_LIST :: ^_PROC_THREAD_ATTRIBUTE_LIST; | |
| /* THREAD_INFORMATION_CLASS :: enum { */ | |
| THREAD_INFORMATION_CLASS :: _c.int; | |
| ThreadMemoryPriority :: 0; | |
| ThreadAbsoluteCpuPriority :: ThreadMemoryPriority + 1; | |
| ThreadDynamicCodePolicy :: ThreadAbsoluteCpuPriority + 1; | |
| ThreadPowerThrottling :: ThreadDynamicCodePolicy + 1; | |
| ThreadInformationClassMax :: ThreadPowerThrottling + 1; | |
| /* } */ | |
| ; | |
| MEMORY_PRIORITY_INFORMATION :: struct { | |
| MemoryPriority : ULONG, | |
| }; | |
| PMEMORY_PRIORITY_INFORMATION :: ^MEMORY_PRIORITY_INFORMATION; | |
| THREAD_POWER_THROTTLING_STATE :: struct { | |
| Version : ULONG, | |
| ControlMask : ULONG, | |
| StateMask : ULONG, | |
| }; | |
| /* PROCESS_INFORMATION_CLASS :: enum { */ | |
| PROCESS_INFORMATION_CLASS :: _c.int; | |
| ProcessMemoryPriority :: 0; | |
| ProcessMemoryExhaustionInfo :: ProcessMemoryPriority + 1; | |
| ProcessAppMemoryInfo :: ProcessMemoryExhaustionInfo + 1; | |
| ProcessInPrivateInfo :: ProcessAppMemoryInfo + 1; | |
| ProcessPowerThrottling :: ProcessInPrivateInfo + 1; | |
| ProcessReservedValue1 :: ProcessPowerThrottling + 1; | |
| ProcessTelemetryCoverageInfo :: ProcessReservedValue1 + 1; | |
| ProcessProtectionLevelInfo :: ProcessTelemetryCoverageInfo + 1; | |
| ProcessLeapSecondInfo :: ProcessProtectionLevelInfo + 1; | |
| ProcessInformationClassMax :: ProcessLeapSecondInfo + 1; | |
| /* } */ | |
| ; | |
| APP_MEMORY_INFORMATION :: struct { | |
| AvailableCommit : ULONG64, | |
| PrivateCommitUsage : ULONG64, | |
| PeakPrivateCommitUsage : ULONG64, | |
| TotalCommitUsage : ULONG64, | |
| }; | |
| PAPP_MEMORY_INFORMATION :: ^APP_MEMORY_INFORMATION; | |
| /* PROCESS_MEMORY_EXHAUSTION_TYPE :: enum { */ | |
| PROCESS_MEMORY_EXHAUSTION_TYPE :: _c.int; | |
| PMETypeFailFastOnCommitFailure :: 0; | |
| PMETypeMax :: PMETypeFailFastOnCommitFailure + 1; | |
| /* } */ | |
| PPROCESS_MEMORY_EXHAUSTION_TYPE :: ^PROCESS_MEMORY_EXHAUSTION_TYPE; | |
| PROCESS_MEMORY_EXHAUSTION_INFO :: struct { | |
| Version : USHORT, | |
| Reserved : USHORT, | |
| Type : PROCESS_MEMORY_EXHAUSTION_TYPE, | |
| Value : ULONG_PTR, | |
| }; | |
| PPROCESS_MEMORY_EXHAUSTION_INFO :: ^PROCESS_MEMORY_EXHAUSTION_INFO; | |
| PROCESS_POWER_THROTTLING_STATE :: struct { | |
| Version : ULONG, | |
| ControlMask : ULONG, | |
| StateMask : ULONG, | |
| }; | |
| PPROCESS_POWER_THROTTLING_STATE :: ^PROCESS_POWER_THROTTLING_STATE; | |
| PROCESS_PROTECTION_LEVEL_INFORMATION :: struct { | |
| ProtectionLevel : DWORD, | |
| }; | |
| PROCESS_LEAP_SECOND_INFO :: struct { | |
| Flags : ULONG, | |
| Reserved : ULONG, | |
| }; | |
| PPROCESS_LEAP_SECOND_INFO :: ^PROCESS_LEAP_SECOND_INFO; | |
| SYSTEM_INFO :: struct { | |
| u : struct #raw_union { | |
| dwOemId : DWORD, | |
| s : struct { | |
| wProcessorArchitecture : WORD, | |
| wReserved : WORD, | |
| }, | |
| }, | |
| dwPageSize : DWORD, | |
| lpMinimumApplicationAddress : LPVOID, | |
| lpMaximumApplicationAddress : LPVOID, | |
| dwActiveProcessorMask : DWORD_PTR, | |
| dwNumberOfProcessors : DWORD, | |
| dwProcessorType : DWORD, | |
| dwAllocationGranularity : DWORD, | |
| wProcessorLevel : WORD, | |
| wProcessorRevision : WORD, | |
| }; | |
| LPSYSTEM_INFO :: ^SYSTEM_INFO; | |
| MEMORYSTATUSEX :: struct { | |
| dwLength : DWORD, | |
| dwMemoryLoad : DWORD, | |
| ullTotalPhys : DWORDLONG, | |
| ullAvailPhys : DWORDLONG, | |
| ullTotalPageFile : DWORDLONG, | |
| ullAvailPageFile : DWORDLONG, | |
| ullTotalVirtual : DWORDLONG, | |
| ullAvailVirtual : DWORDLONG, | |
| ullAvailExtendedVirtual : DWORDLONG, | |
| }; | |
| LPMEMORYSTATUSEX :: ^MEMORYSTATUSEX; | |
| /* COMPUTER_NAME_FORMAT :: enum { */ | |
| COMPUTER_NAME_FORMAT :: _c.int; | |
| ComputerNameNetBIOS :: 0; | |
| ComputerNameDnsHostname :: ComputerNameNetBIOS + 1; | |
| ComputerNameDnsDomain :: ComputerNameDnsHostname + 1; | |
| ComputerNameDnsFullyQualified :: ComputerNameDnsDomain + 1; | |
| ComputerNamePhysicalNetBIOS :: ComputerNameDnsFullyQualified + 1; | |
| ComputerNamePhysicalDnsHostname :: ComputerNamePhysicalNetBIOS + 1; | |
| ComputerNamePhysicalDnsDomain :: ComputerNamePhysicalDnsHostname + 1; | |
| ComputerNamePhysicalDnsFullyQualified :: ComputerNamePhysicalDnsDomain + 1; | |
| ComputerNameMax :: ComputerNamePhysicalDnsFullyQualified + 1; | |
| /* } */ | |
| ; | |
| /* MEMORY_RESOURCE_NOTIFICATION_TYPE :: enum { */ | |
| MEMORY_RESOURCE_NOTIFICATION_TYPE :: _c.int; | |
| LowMemoryResourceNotification :: 0; | |
| HighMemoryResourceNotification :: LowMemoryResourceNotification + 1; | |
| /* } */ | |
| ; | |
| WIN32_MEMORY_RANGE_ENTRY :: struct { | |
| VirtualAddress : PVOID, | |
| NumberOfBytes : SIZE_T, | |
| }; | |
| PWIN32_MEMORY_RANGE_ENTRY :: ^WIN32_MEMORY_RANGE_ENTRY; | |
| BAD_MEMORY_CALLBACK_ROUTINE :: #type proc "stdcall" (); | |
| PBAD_MEMORY_CALLBACK_ROUTINE :: ^BAD_MEMORY_CALLBACK_ROUTINE; | |
| /* OFFER_PRIORITY :: enum { */ | |
| OFFER_PRIORITY :: _c.int; | |
| VmOfferPriorityVeryLow :: 1; | |
| VmOfferPriorityLow :: VmOfferPriorityVeryLow + 1; | |
| VmOfferPriorityBelowNormal :: VmOfferPriorityLow + 1; | |
| VmOfferPriorityNormal :: VmOfferPriorityBelowNormal + 1; | |
| /* } */ | |
| ; | |
| /* WIN32_MEMORY_INFORMATION_CLASS :: enum { */ | |
| WIN32_MEMORY_INFORMATION_CLASS :: _c.int; | |
| MemoryRegionInfo :: 0; | |
| /* } */ | |
| ; | |
| WIN32_MEMORY_REGION_INFORMATION :: struct { | |
| AllocationBase : PVOID, | |
| AllocationProtect : ULONG, | |
| u : struct #raw_union { | |
| Flags : ULONG, | |
| s : bit_field { | |
| Private : 1, | |
| MappedDataFile : 1, | |
| MappedImage : 1, | |
| MappedPageFile : 1, | |
| MappedPhysical : 1, | |
| DirectMapped : 1, | |
| Reserved : 26, | |
| }, | |
| }, | |
| RegionSize : SIZE_T, | |
| CommitSize : SIZE_T, | |
| }; | |
| PTP_WIN32_IO_CALLBACK :: proc "stdcall" (Instance : PTP_CALLBACK_INSTANCE, Context : PVOID, Overlapped : PVOID, IoResult : ULONG, NumberOfBytesTransferred : ULONG_PTR, Io : PTP_IO); | |
| JOBOBJECT_IO_RATE_CONTROL_INFORMATION :: struct { | |
| MaxIops : LONG64, | |
| MaxBandwidth : LONG64, | |
| ReservationIops : LONG64, | |
| VolumeName : PCWSTR, | |
| BaseIoSize : ULONG, | |
| ControlFlags : ULONG, | |
| }; | |
| ENUMUILANG :: struct { | |
| NumOfEnumUILang : ULONG, | |
| SizeOfEnumUIBuffer : ULONG, | |
| pEnumUIBuffer : ^LANGID, | |
| }; | |
| PENUMUILANG :: ^ENUMUILANG; | |
| ENUMRESLANGPROCA :: (proc "stdcall" (hModule : HMODULE, lpType : LPCSTR, lpName : LPCSTR, wLanguage : WORD, lParam : LONG_PTR) -> BOOL); | |
| ENUMRESLANGPROCW :: (proc "stdcall" (hModule : HMODULE, lpType : LPCWSTR, lpName : LPCWSTR, wLanguage : WORD, lParam : LONG_PTR) -> BOOL); | |
| ENUMRESNAMEPROCA :: (proc "stdcall" (hModule : HMODULE, lpType : LPCSTR, lpName : LPSTR, lParam : LONG_PTR) -> BOOL); | |
| ENUMRESNAMEPROCW :: (proc "stdcall" (hModule : HMODULE, lpType : LPCWSTR, lpName : LPWSTR, lParam : LONG_PTR) -> BOOL); | |
| ENUMRESTYPEPROCA :: (proc "stdcall" (hModule : HMODULE, lpType : LPSTR, lParam : LONG_PTR) -> BOOL); | |
| ENUMRESTYPEPROCW :: (proc "stdcall" (hModule : HMODULE, lpType : LPWSTR, lParam : LONG_PTR) -> BOOL); | |
| PGET_MODULE_HANDLE_EXA :: (proc "stdcall" (dwFlags : DWORD, lpModuleName : LPCSTR, phModule : ^HMODULE) -> BOOL); | |
| PGET_MODULE_HANDLE_EXW :: (proc "stdcall" (dwFlags : DWORD, lpModuleName : LPCWSTR, phModule : ^HMODULE) -> BOOL); | |
| REDIRECTION_FUNCTION_DESCRIPTOR :: struct { | |
| DllName : PCSTR, | |
| FunctionName : PCSTR, | |
| RedirectionTarget : PVOID, | |
| }; | |
| PREDIRECTION_FUNCTION_DESCRIPTOR :: ^REDIRECTION_FUNCTION_DESCRIPTOR; | |
| PCREDIRECTION_FUNCTION_DESCRIPTOR :: ^REDIRECTION_FUNCTION_DESCRIPTOR; | |
| REDIRECTION_DESCRIPTOR :: struct { | |
| Version : ULONG, | |
| FunctionCount : ULONG, | |
| Redirections : PCREDIRECTION_FUNCTION_DESCRIPTOR, | |
| }; | |
| PREDIRECTION_DESCRIPTOR :: ^REDIRECTION_DESCRIPTOR; | |
| PCREDIRECTION_DESCRIPTOR :: ^REDIRECTION_DESCRIPTOR; | |
| DLL_DIRECTORY_COOKIE :: PVOID; | |
| PDLL_DIRECTORY_COOKIE :: ^PVOID; | |
| PFIBER_START_ROUTINE :: proc "stdcall" (lpFiberParameter : LPVOID); | |
| LPFIBER_START_ROUTINE :: PFIBER_START_ROUTINE; | |
| PFIBER_CALLOUT_ROUTINE :: (proc "stdcall" (lpParameter : LPVOID) -> LPVOID); | |
| LPLDT_ENTRY :: LPVOID; | |
| COMMPROP :: struct { | |
| wPacketLength : WORD, | |
| wPacketVersion : WORD, | |
| dwServiceMask : DWORD, | |
| dwReserved1 : DWORD, | |
| dwMaxTxQueue : DWORD, | |
| dwMaxRxQueue : DWORD, | |
| dwMaxBaud : DWORD, | |
| dwProvSubType : DWORD, | |
| dwProvCapabilities : DWORD, | |
| dwSettableParams : DWORD, | |
| dwSettableBaud : DWORD, | |
| wSettableData : WORD, | |
| wSettableStopParity : WORD, | |
| dwCurrentTxQueue : DWORD, | |
| dwCurrentRxQueue : DWORD, | |
| dwProvSpec1 : DWORD, | |
| dwProvSpec2 : DWORD, | |
| wcProvChar : [1]WCHAR, | |
| }; | |
| LPCOMMPROP :: ^COMMPROP; | |
| COMSTAT :: struct { | |
| using _ : bit_field { | |
| fCtsHold : 1, | |
| fDsrHold : 1, | |
| fRlsdHold : 1, | |
| fXoffHold : 1, | |
| fXoffSent : 1, | |
| fEof : 1, | |
| fTxim : 1, | |
| fReserved : 25, | |
| }, | |
| cbInQue : DWORD, | |
| cbOutQue : DWORD, | |
| }; | |
| LPCOMSTAT :: ^COMSTAT; | |
| DCB :: struct { | |
| DCBlength : DWORD, | |
| BaudRate : DWORD, | |
| using _ : bit_field { | |
| fBinary : 1, | |
| fParity : 1, | |
| fOutxCtsFlow : 1, | |
| fOutxDsrFlow : 1, | |
| fDtrControl : 2, | |
| fDsrSensitivity : 1, | |
| fTXContinueOnXoff : 1, | |
| fOutX : 1, | |
| fInX : 1, | |
| fErrorChar : 1, | |
| fNull : 1, | |
| fRtsControl : 2, | |
| fAbortOnError : 1, | |
| fDummy2 : 17, | |
| }, | |
| wReserved : WORD, | |
| XonLim : WORD, | |
| XoffLim : WORD, | |
| ByteSize : BYTE, | |
| Parity : BYTE, | |
| StopBits : BYTE, | |
| XonChar : _c.uchar, | |
| XoffChar : _c.uchar, | |
| ErrorChar : _c.uchar, | |
| EofChar : _c.uchar, | |
| EvtChar : _c.uchar, | |
| wReserved1 : WORD, | |
| }; | |
| LPDCB :: ^DCB; | |
| COMMTIMEOUTS :: struct { | |
| ReadIntervalTimeout : DWORD, | |
| ReadTotalTimeoutMultiplier : DWORD, | |
| ReadTotalTimeoutConstant : DWORD, | |
| WriteTotalTimeoutMultiplier : DWORD, | |
| WriteTotalTimeoutConstant : DWORD, | |
| }; | |
| LPCOMMTIMEOUTS :: ^COMMTIMEOUTS; | |
| COMMCONFIG :: struct { | |
| dwSize : DWORD, | |
| wVersion : WORD, | |
| wReserved : WORD, | |
| dcb : DCB, | |
| dwProviderSubType : DWORD, | |
| dwProviderOffset : DWORD, | |
| dwProviderSize : DWORD, | |
| wcProviderData : [1]WCHAR, | |
| }; | |
| LPCOMMCONFIG :: ^COMMCONFIG; | |
| MEMORYSTATUS :: struct { | |
| dwLength : DWORD, | |
| dwMemoryLoad : DWORD, | |
| dwTotalPhys : SIZE_T, | |
| dwAvailPhys : SIZE_T, | |
| dwTotalPageFile : SIZE_T, | |
| dwAvailPageFile : SIZE_T, | |
| dwTotalVirtual : SIZE_T, | |
| dwAvailVirtual : SIZE_T, | |
| }; | |
| LPMEMORYSTATUS :: ^MEMORYSTATUS; | |
| JIT_DEBUG_INFO :: struct { | |
| dwSize : DWORD, | |
| dwProcessorArchitecture : DWORD, | |
| dwThreadID : DWORD, | |
| dwReserved0 : DWORD, | |
| lpExceptionAddress : ULONG64, | |
| lpExceptionRecord : ULONG64, | |
| lpContextRecord : ULONG64, | |
| }; | |
| LPJIT_DEBUG_INFO :: ^JIT_DEBUG_INFO; | |
| JIT_DEBUG_INFO32 :: JIT_DEBUG_INFO; | |
| LPJIT_DEBUG_INFO32 :: ^JIT_DEBUG_INFO; | |
| JIT_DEBUG_INFO64 :: JIT_DEBUG_INFO; | |
| LPJIT_DEBUG_INFO64 :: ^JIT_DEBUG_INFO; | |
| LPEXCEPTION_RECORD :: PEXCEPTION_RECORD; | |
| LPEXCEPTION_POINTERS :: PEXCEPTION_POINTERS; | |
| OFSTRUCT :: struct { | |
| cBytes : BYTE, | |
| fFixedDisk : BYTE, | |
| nErrCode : WORD, | |
| Reserved1 : WORD, | |
| Reserved2 : WORD, | |
| szPathName : [128]CHAR, | |
| }; | |
| LPOFSTRUCT :: ^OFSTRUCT; | |
| POFSTRUCT :: ^OFSTRUCT; | |
| PUMS_CONTEXT :: rawptr; | |
| PUMS_COMPLETION_LIST :: rawptr; | |
| UMS_THREAD_INFO_CLASS :: RTL_UMS_THREAD_INFO_CLASS; | |
| PUMS_THREAD_INFO_CLASS :: ^RTL_UMS_THREAD_INFO_CLASS; | |
| UMS_SCHEDULER_REASON :: RTL_UMS_SCHEDULER_REASON; | |
| PUMS_SCHEDULER_ENTRY_POINT :: PRTL_UMS_SCHEDULER_ENTRY_POINT; | |
| UMS_SCHEDULER_STARTUP_INFO :: struct { | |
| UmsVersion : ULONG, | |
| CompletionList : PUMS_COMPLETION_LIST, | |
| SchedulerProc : PUMS_SCHEDULER_ENTRY_POINT, | |
| SchedulerParam : PVOID, | |
| }; | |
| PUMS_SCHEDULER_STARTUP_INFO :: ^UMS_SCHEDULER_STARTUP_INFO; | |
| UMS_SYSTEM_THREAD_INFORMATION :: struct { | |
| UmsVersion : ULONG, | |
| u : struct #raw_union { | |
| s : bit_field { | |
| IsUmsSchedulerThread : 1, | |
| IsUmsWorkerThread : 1, | |
| }, | |
| ThreadUmsFlags : ULONG, | |
| }, | |
| }; | |
| PUMS_SYSTEM_THREAD_INFORMATION :: ^UMS_SYSTEM_THREAD_INFORMATION; | |
| POWER_REQUEST_CONTEXT :: REASON_CONTEXT; | |
| PPOWER_REQUEST_CONTEXT :: ^REASON_CONTEXT; | |
| LPPOWER_REQUEST_CONTEXT :: ^REASON_CONTEXT; | |
| /* DEP_SYSTEM_POLICY_TYPE :: enum { */ | |
| DEP_SYSTEM_POLICY_TYPE :: _c.int; | |
| DEPPolicyAlwaysOff :: 0; | |
| DEPPolicyAlwaysOn :: DEPPolicyAlwaysOff + 1; | |
| DEPPolicyOptIn :: DEPPolicyAlwaysOn + 1; | |
| DEPPolicyOptOut :: DEPPolicyOptIn + 1; | |
| DEPTotalPolicyCount :: DEPPolicyOptOut + 1; | |
| /* } */ | |
| ; | |
| PFE_EXPORT_FUNC :: (proc "stdcall" (pbData : PBYTE, pvCallbackContext : PVOID, ulLength : ULONG) -> DWORD); | |
| PFE_IMPORT_FUNC :: (proc "stdcall" (pbData : PBYTE, pvCallbackContext : PVOID, ulLength : PULONG) -> DWORD); | |
| WIN32_STREAM_ID :: struct { | |
| dwStreamId : DWORD, | |
| dwStreamAttributes : DWORD, | |
| Size : LARGE_INTEGER, | |
| dwStreamNameSize : DWORD, | |
| cStreamName : [1]WCHAR, | |
| }; | |
| LPWIN32_STREAM_ID :: ^WIN32_STREAM_ID; | |
| STARTUPINFOEXA :: struct { | |
| StartupInfo : STARTUPINFOA, | |
| lpAttributeList : LPPROC_THREAD_ATTRIBUTE_LIST, | |
| }; | |
| LPSTARTUPINFOEXA :: ^STARTUPINFOEXA; | |
| STARTUPINFOEXW :: struct { | |
| StartupInfo : STARTUPINFOW, | |
| lpAttributeList : LPPROC_THREAD_ATTRIBUTE_LIST, | |
| }; | |
| LPSTARTUPINFOEXW :: ^STARTUPINFOEXW; | |
| STARTUPINFOEX :: STARTUPINFOEXA; | |
| LPSTARTUPINFOEX :: LPSTARTUPINFOEXA; | |
| /* PROC_THREAD_ATTRIBUTE_NUM :: enum { */ | |
| PROC_THREAD_ATTRIBUTE_NUM :: _c.int; | |
| ProcThreadAttributeParentProcess :: 0; | |
| ProcThreadAttributeHandleList :: 2; | |
| ProcThreadAttributeGroupAffinity :: 3; | |
| ProcThreadAttributePreferredNode :: 4; | |
| ProcThreadAttributeIdealProcessor :: 5; | |
| ProcThreadAttributeUmsThread :: 6; | |
| ProcThreadAttributeMitigationPolicy :: 7; | |
| ProcThreadAttributeSecurityCapabilities :: 9; | |
| ProcThreadAttributeProtectionLevel :: 11; | |
| ProcThreadAttributeJobList :: 13; | |
| ProcThreadAttributeChildProcessPolicy :: 14; | |
| ProcThreadAttributeAllApplicationPackagesPolicy :: 15; | |
| ProcThreadAttributeWin32kFilter :: 16; | |
| ProcThreadAttributeSafeOpenPromptOriginClaim :: 17; | |
| ProcThreadAttributeDesktopAppPolicy :: 18; | |
| ProcThreadAttributePseudoConsole :: 22; | |
| /* } */ | |
| ; | |
| PGET_SYSTEM_WOW64_DIRECTORY_A :: (proc "stdcall" (lpBuffer : LPSTR, uSize : UINT) -> UINT); | |
| PGET_SYSTEM_WOW64_DIRECTORY_W :: (proc "stdcall" (lpBuffer : LPWSTR, uSize : UINT) -> UINT); | |
| LPPROGRESS_ROUTINE :: (proc "stdcall" (TotalFileSize : LARGE_INTEGER, TotalBytesTransferred : LARGE_INTEGER, StreamSize : LARGE_INTEGER, StreamBytesTransferred : LARGE_INTEGER, dwStreamNumber : DWORD, dwCallbackReason : DWORD, hSourceFile : HANDLE, hDestinationFile : HANDLE, lpData : LPVOID) -> DWORD); | |
| /* COPYFILE2_MESSAGE_TYPE :: enum { */ | |
| COPYFILE2_MESSAGE_TYPE :: _c.int; | |
| COPYFILE2_CALLBACK_NONE :: 0; | |
| COPYFILE2_CALLBACK_CHUNK_STARTED :: COPYFILE2_CALLBACK_NONE + 1; | |
| COPYFILE2_CALLBACK_CHUNK_FINISHED :: COPYFILE2_CALLBACK_CHUNK_STARTED + 1; | |
| COPYFILE2_CALLBACK_STREAM_STARTED :: COPYFILE2_CALLBACK_CHUNK_FINISHED + 1; | |
| COPYFILE2_CALLBACK_STREAM_FINISHED :: COPYFILE2_CALLBACK_STREAM_STARTED + 1; | |
| COPYFILE2_CALLBACK_POLL_CONTINUE :: COPYFILE2_CALLBACK_STREAM_FINISHED + 1; | |
| COPYFILE2_CALLBACK_ERROR :: COPYFILE2_CALLBACK_POLL_CONTINUE + 1; | |
| COPYFILE2_CALLBACK_MAX :: COPYFILE2_CALLBACK_ERROR + 1; | |
| /* } */ | |
| ; | |
| /* COPYFILE2_MESSAGE_ACTION :: enum { */ | |
| COPYFILE2_MESSAGE_ACTION :: _c.int; | |
| COPYFILE2_PROGRESS_CONTINUE :: 0; | |
| COPYFILE2_PROGRESS_CANCEL :: COPYFILE2_PROGRESS_CONTINUE + 1; | |
| COPYFILE2_PROGRESS_STOP :: COPYFILE2_PROGRESS_CANCEL + 1; | |
| COPYFILE2_PROGRESS_QUIET :: COPYFILE2_PROGRESS_STOP + 1; | |
| COPYFILE2_PROGRESS_PAUSE :: COPYFILE2_PROGRESS_QUIET + 1; | |
| /* } */ | |
| ; | |
| /* COPYFILE2_COPY_PHASE :: enum { */ | |
| COPYFILE2_COPY_PHASE :: _c.int; | |
| COPYFILE2_PHASE_NONE :: 0; | |
| COPYFILE2_PHASE_PREPARE_SOURCE :: COPYFILE2_PHASE_NONE + 1; | |
| COPYFILE2_PHASE_PREPARE_DEST :: COPYFILE2_PHASE_PREPARE_SOURCE + 1; | |
| COPYFILE2_PHASE_READ_SOURCE :: COPYFILE2_PHASE_PREPARE_DEST + 1; | |
| COPYFILE2_PHASE_WRITE_DESTINATION :: COPYFILE2_PHASE_READ_SOURCE + 1; | |
| COPYFILE2_PHASE_SERVER_COPY :: COPYFILE2_PHASE_WRITE_DESTINATION + 1; | |
| COPYFILE2_PHASE_NAMEGRAFT_COPY :: COPYFILE2_PHASE_SERVER_COPY + 1; | |
| COPYFILE2_PHASE_MAX :: COPYFILE2_PHASE_NAMEGRAFT_COPY + 1; | |
| /* } */ | |
| ; | |
| COPYFILE2_MESSAGE :: struct { | |
| Type : COPYFILE2_MESSAGE_TYPE, | |
| dwPadding : DWORD, | |
| Info : struct #raw_union { | |
| ChunkStarted : struct { | |
| dwStreamNumber : DWORD, | |
| dwReserved : DWORD, | |
| hSourceFile : HANDLE, | |
| hDestinationFile : HANDLE, | |
| uliChunkNumber : ULARGE_INTEGER, | |
| uliChunkSize : ULARGE_INTEGER, | |
| uliStreamSize : ULARGE_INTEGER, | |
| uliTotalFileSize : ULARGE_INTEGER, | |
| }, | |
| ChunkFinished : struct { | |
| dwStreamNumber : DWORD, | |
| dwFlags : DWORD, | |
| hSourceFile : HANDLE, | |
| hDestinationFile : HANDLE, | |
| uliChunkNumber : ULARGE_INTEGER, | |
| uliChunkSize : ULARGE_INTEGER, | |
| uliStreamSize : ULARGE_INTEGER, | |
| uliStreamBytesTransferred : ULARGE_INTEGER, | |
| uliTotalFileSize : ULARGE_INTEGER, | |
| uliTotalBytesTransferred : ULARGE_INTEGER, | |
| }, | |
| StreamStarted : struct { | |
| dwStreamNumber : DWORD, | |
| dwReserved : DWORD, | |
| hSourceFile : HANDLE, | |
| hDestinationFile : HANDLE, | |
| uliStreamSize : ULARGE_INTEGER, | |
| uliTotalFileSize : ULARGE_INTEGER, | |
| }, | |
| StreamFinished : struct { | |
| dwStreamNumber : DWORD, | |
| dwReserved : DWORD, | |
| hSourceFile : HANDLE, | |
| hDestinationFile : HANDLE, | |
| uliStreamSize : ULARGE_INTEGER, | |
| uliStreamBytesTransferred : ULARGE_INTEGER, | |
| uliTotalFileSize : ULARGE_INTEGER, | |
| uliTotalBytesTransferred : ULARGE_INTEGER, | |
| }, | |
| PollContinue : struct { | |
| dwReserved : DWORD, | |
| }, | |
| Error : struct { | |
| CopyPhase : COPYFILE2_COPY_PHASE, | |
| dwStreamNumber : DWORD, | |
| hrFailure : HRESULT, | |
| dwReserved : DWORD, | |
| uliChunkNumber : ULARGE_INTEGER, | |
| uliStreamSize : ULARGE_INTEGER, | |
| uliStreamBytesTransferred : ULARGE_INTEGER, | |
| uliTotalFileSize : ULARGE_INTEGER, | |
| uliTotalBytesTransferred : ULARGE_INTEGER, | |
| }, | |
| }, | |
| }; | |
| PCOPYFILE2_PROGRESS_ROUTINE :: (proc "stdcall" (pMessage : ^COPYFILE2_MESSAGE, pvCallbackContext : PVOID) -> COPYFILE2_MESSAGE_ACTION); | |
| COPYFILE2_EXTENDED_PARAMETERS :: struct { | |
| dwSize : DWORD, | |
| dwCopyFlags : DWORD, | |
| pfCancel : ^BOOL, | |
| pProgressRoutine : PCOPYFILE2_PROGRESS_ROUTINE, | |
| pvCallbackContext : PVOID, | |
| }; | |
| EVENTLOG_FULL_INFORMATION :: struct { | |
| dwFull : DWORD, | |
| }; | |
| LPEVENTLOG_FULL_INFORMATION :: ^EVENTLOG_FULL_INFORMATION; | |
| OPERATION_ID :: ULONG; | |
| OPERATION_START_PARAMETERS :: struct { | |
| Version : ULONG, | |
| OperationId : OPERATION_ID, | |
| Flags : ULONG, | |
| }; | |
| POPERATION_START_PARAMETERS :: ^OPERATION_START_PARAMETERS; | |
| OPERATION_END_PARAMETERS :: struct { | |
| Version : ULONG, | |
| OperationId : OPERATION_ID, | |
| Flags : ULONG, | |
| }; | |
| POPERATION_END_PARAMETERS :: ^OPERATION_END_PARAMETERS; | |
| HW_PROFILE_INFOA :: struct { | |
| dwDockInfo : DWORD, | |
| szHwProfileGuid : [39]CHAR, | |
| szHwProfileName : [80]CHAR, | |
| }; | |
| LPHW_PROFILE_INFOA :: ^HW_PROFILE_INFOA; | |
| HW_PROFILE_INFOW :: struct { | |
| dwDockInfo : DWORD, | |
| szHwProfileGuid : [39]WCHAR, | |
| szHwProfileName : [80]WCHAR, | |
| }; | |
| LPHW_PROFILE_INFOW :: ^HW_PROFILE_INFOW; | |
| HW_PROFILE_INFO :: HW_PROFILE_INFOA; | |
| LPHW_PROFILE_INFO :: LPHW_PROFILE_INFOA; | |
| TIME_ZONE_INFORMATION :: struct { | |
| Bias : LONG, | |
| StandardName : [32]WCHAR, | |
| StandardDate : SYSTEMTIME, | |
| StandardBias : LONG, | |
| DaylightName : [32]WCHAR, | |
| DaylightDate : SYSTEMTIME, | |
| DaylightBias : LONG, | |
| }; | |
| PTIME_ZONE_INFORMATION :: ^TIME_ZONE_INFORMATION; | |
| LPTIME_ZONE_INFORMATION :: ^TIME_ZONE_INFORMATION; | |
| DYNAMIC_TIME_ZONE_INFORMATION :: struct { | |
| Bias : LONG, | |
| StandardName : [32]WCHAR, | |
| StandardDate : SYSTEMTIME, | |
| StandardBias : LONG, | |
| DaylightName : [32]WCHAR, | |
| DaylightDate : SYSTEMTIME, | |
| DaylightBias : LONG, | |
| TimeZoneKeyName : [128]WCHAR, | |
| DynamicDaylightTimeDisabled : BOOLEAN, | |
| }; | |
| PDYNAMIC_TIME_ZONE_INFORMATION :: ^DYNAMIC_TIME_ZONE_INFORMATION; | |
| SYSTEM_POWER_STATUS :: struct { | |
| ACLineStatus : BYTE, | |
| BatteryFlag : BYTE, | |
| BatteryLifePercent : BYTE, | |
| SystemStatusFlag : BYTE, | |
| BatteryLifeTime : DWORD, | |
| BatteryFullLifeTime : DWORD, | |
| }; | |
| LPSYSTEM_POWER_STATUS :: ^SYSTEM_POWER_STATUS; | |
| ACTCTXA :: struct { | |
| cbSize : ULONG, | |
| dwFlags : DWORD, | |
| lpSource : LPCSTR, | |
| wProcessorArchitecture : USHORT, | |
| wLangId : LANGID, | |
| lpAssemblyDirectory : LPCSTR, | |
| lpResourceName : LPCSTR, | |
| lpApplicationName : LPCSTR, | |
| hModule : HMODULE, | |
| }; | |
| PACTCTXA :: ^ACTCTXA; | |
| ACTCTXW :: struct { | |
| cbSize : ULONG, | |
| dwFlags : DWORD, | |
| lpSource : LPCWSTR, | |
| wProcessorArchitecture : USHORT, | |
| wLangId : LANGID, | |
| lpAssemblyDirectory : LPCWSTR, | |
| lpResourceName : LPCWSTR, | |
| lpApplicationName : LPCWSTR, | |
| hModule : HMODULE, | |
| }; | |
| PACTCTXW :: ^ACTCTXW; | |
| ACTCTX :: ACTCTXA; | |
| PACTCTX :: PACTCTXA; | |
| PCACTCTXA :: ^ACTCTXA; | |
| PCACTCTXW :: ^ACTCTXW; | |
| PCACTCTX :: PCACTCTXA; | |
| ACTCTX_SECTION_KEYED_DATA_2600 :: struct { | |
| cbSize : ULONG, | |
| ulDataFormatVersion : ULONG, | |
| lpData : PVOID, | |
| ulLength : ULONG, | |
| lpSectionGlobalData : PVOID, | |
| ulSectionGlobalDataLength : ULONG, | |
| lpSectionBase : PVOID, | |
| ulSectionTotalLength : ULONG, | |
| hActCtx : HANDLE, | |
| ulAssemblyRosterIndex : ULONG, | |
| }; | |
| PACTCTX_SECTION_KEYED_DATA_2600 :: ^ACTCTX_SECTION_KEYED_DATA_2600; | |
| PCACTCTX_SECTION_KEYED_DATA_2600 :: ^ACTCTX_SECTION_KEYED_DATA_2600; | |
| ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA :: struct { | |
| lpInformation : PVOID, | |
| lpSectionBase : PVOID, | |
| ulSectionLength : ULONG, | |
| lpSectionGlobalDataBase : PVOID, | |
| ulSectionGlobalDataLength : ULONG, | |
| }; | |
| PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA :: ^ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA; | |
| PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA :: ^ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA; | |
| ACTCTX_SECTION_KEYED_DATA :: struct { | |
| cbSize : ULONG, | |
| ulDataFormatVersion : ULONG, | |
| lpData : PVOID, | |
| ulLength : ULONG, | |
| lpSectionGlobalData : PVOID, | |
| ulSectionGlobalDataLength : ULONG, | |
| lpSectionBase : PVOID, | |
| ulSectionTotalLength : ULONG, | |
| hActCtx : HANDLE, | |
| ulAssemblyRosterIndex : ULONG, | |
| ulFlags : ULONG, | |
| AssemblyMetadata : ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, | |
| }; | |
| PACTCTX_SECTION_KEYED_DATA :: ^ACTCTX_SECTION_KEYED_DATA; | |
| PCACTCTX_SECTION_KEYED_DATA :: ^ACTCTX_SECTION_KEYED_DATA; | |
| ACTIVATION_CONTEXT_BASIC_INFORMATION :: struct { | |
| hActCtx : HANDLE, | |
| dwFlags : DWORD, | |
| }; | |
| PACTIVATION_CONTEXT_BASIC_INFORMATION :: ^ACTIVATION_CONTEXT_BASIC_INFORMATION; | |
| PCACTIVATION_CONTEXT_BASIC_INFORMATION :: ^ACTIVATION_CONTEXT_BASIC_INFORMATION; | |
| PQUERYACTCTXW_FUNC :: (proc "stdcall" (dwFlags : DWORD, hActCtx : HANDLE, pvSubInstance : PVOID, ulInfoClass : ULONG, pvBuffer : PVOID, cbBuffer : SIZE_T, pcbWrittenOrRequired : ^SIZE_T) -> BOOL); | |
| APPLICATION_RECOVERY_CALLBACK :: (proc "stdcall" (pvParameter : PVOID) -> DWORD); | |
| FILE_BASIC_INFO :: struct { | |
| CreationTime : LARGE_INTEGER, | |
| LastAccessTime : LARGE_INTEGER, | |
| LastWriteTime : LARGE_INTEGER, | |
| ChangeTime : LARGE_INTEGER, | |
| FileAttributes : DWORD, | |
| }; | |
| PFILE_BASIC_INFO :: ^FILE_BASIC_INFO; | |
| FILE_STANDARD_INFO :: struct { | |
| AllocationSize : LARGE_INTEGER, | |
| EndOfFile : LARGE_INTEGER, | |
| NumberOfLinks : DWORD, | |
| DeletePending : BOOLEAN, | |
| Directory : BOOLEAN, | |
| }; | |
| PFILE_STANDARD_INFO :: ^FILE_STANDARD_INFO; | |
| FILE_NAME_INFO :: struct { | |
| FileNameLength : DWORD, | |
| FileName : [1]WCHAR, | |
| }; | |
| PFILE_NAME_INFO :: ^FILE_NAME_INFO; | |
| FILE_CASE_SENSITIVE_INFO :: struct { | |
| Flags : ULONG, | |
| }; | |
| PFILE_CASE_SENSITIVE_INFO :: ^FILE_CASE_SENSITIVE_INFO; | |
| FILE_RENAME_INFO :: struct { | |
| u : struct #raw_union { | |
| ReplaceIfExists : BOOLEAN, | |
| Flags : DWORD, | |
| }, | |
| RootDirectory : HANDLE, | |
| FileNameLength : DWORD, | |
| FileName : [1]WCHAR, | |
| }; | |
| PFILE_RENAME_INFO :: ^FILE_RENAME_INFO; | |
| FILE_ALLOCATION_INFO :: struct { | |
| AllocationSize : LARGE_INTEGER, | |
| }; | |
| PFILE_ALLOCATION_INFO :: ^FILE_ALLOCATION_INFO; | |
| FILE_END_OF_FILE_INFO :: struct { | |
| EndOfFile : LARGE_INTEGER, | |
| }; | |
| PFILE_END_OF_FILE_INFO :: ^FILE_END_OF_FILE_INFO; | |
| FILE_STREAM_INFO :: struct { | |
| NextEntryOffset : DWORD, | |
| StreamNameLength : DWORD, | |
| StreamSize : LARGE_INTEGER, | |
| StreamAllocationSize : LARGE_INTEGER, | |
| StreamName : [1]WCHAR, | |
| }; | |
| PFILE_STREAM_INFO :: ^FILE_STREAM_INFO; | |
| FILE_COMPRESSION_INFO :: struct { | |
| CompressedFileSize : LARGE_INTEGER, | |
| CompressionFormat : WORD, | |
| CompressionUnitShift : UCHAR, | |
| ChunkShift : UCHAR, | |
| ClusterShift : UCHAR, | |
| Reserved : [3]UCHAR, | |
| }; | |
| PFILE_COMPRESSION_INFO :: ^FILE_COMPRESSION_INFO; | |
| FILE_ATTRIBUTE_TAG_INFO :: struct { | |
| FileAttributes : DWORD, | |
| ReparseTag : DWORD, | |
| }; | |
| PFILE_ATTRIBUTE_TAG_INFO :: ^FILE_ATTRIBUTE_TAG_INFO; | |
| FILE_DISPOSITION_INFO :: struct { | |
| DeleteFileA : BOOLEAN, | |
| }; | |
| PFILE_DISPOSITION_INFO :: ^FILE_DISPOSITION_INFO; | |
| FILE_DISPOSITION_INFO_EX :: struct { | |
| Flags : DWORD, | |
| }; | |
| PFILE_DISPOSITION_INFO_EX :: ^FILE_DISPOSITION_INFO_EX; | |
| FILE_ID_BOTH_DIR_INFO :: struct { | |
| NextEntryOffset : DWORD, | |
| FileIndex : DWORD, | |
| CreationTime : LARGE_INTEGER, | |
| LastAccessTime : LARGE_INTEGER, | |
| LastWriteTime : LARGE_INTEGER, | |
| ChangeTime : LARGE_INTEGER, | |
| EndOfFile : LARGE_INTEGER, | |
| AllocationSize : LARGE_INTEGER, | |
| FileAttributes : DWORD, | |
| FileNameLength : DWORD, | |
| EaSize : DWORD, | |
| ShortNameLength : CCHAR, | |
| ShortName : [12]WCHAR, | |
| FileId : LARGE_INTEGER, | |
| FileName : [1]WCHAR, | |
| }; | |
| PFILE_ID_BOTH_DIR_INFO :: ^FILE_ID_BOTH_DIR_INFO; | |
| FILE_FULL_DIR_INFO :: struct { | |
| NextEntryOffset : ULONG, | |
| FileIndex : ULONG, | |
| CreationTime : LARGE_INTEGER, | |
| LastAccessTime : LARGE_INTEGER, | |
| LastWriteTime : LARGE_INTEGER, | |
| ChangeTime : LARGE_INTEGER, | |
| EndOfFile : LARGE_INTEGER, | |
| AllocationSize : LARGE_INTEGER, | |
| FileAttributes : ULONG, | |
| FileNameLength : ULONG, | |
| EaSize : ULONG, | |
| FileName : [1]WCHAR, | |
| }; | |
| PFILE_FULL_DIR_INFO :: ^FILE_FULL_DIR_INFO; | |
| /* PRIORITY_HINT :: enum { */ | |
| PRIORITY_HINT :: _c.int; | |
| IoPriorityHintVeryLow :: 0; | |
| IoPriorityHintLow :: IoPriorityHintVeryLow + 1; | |
| IoPriorityHintNormal :: IoPriorityHintLow + 1; | |
| MaximumIoPriorityHintType :: IoPriorityHintNormal + 1; | |
| /* } */ | |
| ; | |
| FILE_IO_PRIORITY_HINT_INFO :: struct { | |
| PriorityHint : PRIORITY_HINT, | |
| }; | |
| PFILE_IO_PRIORITY_HINT_INFO :: ^FILE_IO_PRIORITY_HINT_INFO; | |
| FILE_ALIGNMENT_INFO :: struct { | |
| AlignmentRequirement : ULONG, | |
| }; | |
| PFILE_ALIGNMENT_INFO :: ^FILE_ALIGNMENT_INFO; | |
| FILE_STORAGE_INFO :: struct { | |
| LogicalBytesPerSector : ULONG, | |
| PhysicalBytesPerSectorForAtomicity : ULONG, | |
| PhysicalBytesPerSectorForPerformance : ULONG, | |
| FileSystemEffectivePhysicalBytesPerSectorForAtomicity : ULONG, | |
| Flags : ULONG, | |
| ByteOffsetForSectorAlignment : ULONG, | |
| ByteOffsetForPartitionAlignment : ULONG, | |
| }; | |
| PFILE_STORAGE_INFO :: ^FILE_STORAGE_INFO; | |
| FILE_ID_INFO :: struct { | |
| VolumeSerialNumber : ULONGLONG, | |
| FileId : FILE_ID_128, | |
| }; | |
| PFILE_ID_INFO :: ^FILE_ID_INFO; | |
| FILE_ID_EXTD_DIR_INFO :: struct { | |
| NextEntryOffset : ULONG, | |
| FileIndex : ULONG, | |
| CreationTime : LARGE_INTEGER, | |
| LastAccessTime : LARGE_INTEGER, | |
| LastWriteTime : LARGE_INTEGER, | |
| ChangeTime : LARGE_INTEGER, | |
| EndOfFile : LARGE_INTEGER, | |
| AllocationSize : LARGE_INTEGER, | |
| FileAttributes : ULONG, | |
| FileNameLength : ULONG, | |
| EaSize : ULONG, | |
| ReparsePointTag : ULONG, | |
| FileId : FILE_ID_128, | |
| FileName : [1]WCHAR, | |
| }; | |
| PFILE_ID_EXTD_DIR_INFO :: ^FILE_ID_EXTD_DIR_INFO; | |
| FILE_REMOTE_PROTOCOL_INFO :: struct { | |
| StructureVersion : USHORT, | |
| StructureSize : USHORT, | |
| Protocol : ULONG, | |
| ProtocolMajorVersion : USHORT, | |
| ProtocolMinorVersion : USHORT, | |
| ProtocolRevision : USHORT, | |
| Reserved : USHORT, | |
| Flags : ULONG, | |
| GenericReserved : struct { | |
| Reserved : [8]ULONG, | |
| }, | |
| ProtocolSpecific : struct #raw_union { | |
| Smb2 : struct { | |
| Server : struct { | |
| Capabilities : ULONG, | |
| }, | |
| Share : struct { | |
| Capabilities : ULONG, | |
| CachingFlags : ULONG, | |
| }, | |
| }, | |
| Reserved : [16]ULONG, | |
| }, | |
| }; | |
| PFILE_REMOTE_PROTOCOL_INFO :: ^FILE_REMOTE_PROTOCOL_INFO; | |
| /* FILE_ID_TYPE :: enum { */ | |
| FILE_ID_TYPE :: _c.int; | |
| FileIdType :: 0; | |
| ObjectIdType :: FileIdType + 1; | |
| ExtendedFileIdType :: ObjectIdType + 1; | |
| MaximumFileIdType :: ExtendedFileIdType + 1; | |
| /* } */ | |
| PFILE_ID_TYPE :: ^FILE_ID_TYPE; | |
| FILE_ID_DESCRIPTOR :: struct { | |
| dwSize : DWORD, | |
| Type : FILE_ID_TYPE, | |
| u : struct #raw_union { | |
| FileId : LARGE_INTEGER, | |
| ObjectId : GUID, | |
| ExtendedFileId : FILE_ID_128, | |
| }, | |
| }; | |
| LPFILE_ID_DESCRIPTOR :: ^FILE_ID_DESCRIPTOR; | |
| DRAWPATRECT :: struct { | |
| ptPosition : POINT, | |
| ptSize : POINT, | |
| wStyle : WORD, | |
| wPattern : WORD, | |
| }; | |
| PDRAWPATRECT :: ^DRAWPATRECT; | |
| PSINJECTDATA :: struct { | |
| DataBytes : DWORD, | |
| InjectionPoint : WORD, | |
| PageNumber : WORD, | |
| }; | |
| PPSINJECTDATA :: ^PSINJECTDATA; | |
| PSFEATURE_OUTPUT :: struct { | |
| bPageIndependent : BOOL, | |
| bSetPageDevice : BOOL, | |
| }; | |
| PPSFEATURE_OUTPUT :: ^PSFEATURE_OUTPUT; | |
| PSFEATURE_CUSTPAPER :: struct { | |
| lOrientation : LONG, | |
| lWidth : LONG, | |
| lHeight : LONG, | |
| lWidthOffset : LONG, | |
| lHeightOffset : LONG, | |
| }; | |
| PPSFEATURE_CUSTPAPER :: ^PSFEATURE_CUSTPAPER; | |
| XFORM :: struct { | |
| eM11 : FLOAT, | |
| eM12 : FLOAT, | |
| eM21 : FLOAT, | |
| eM22 : FLOAT, | |
| eDx : FLOAT, | |
| eDy : FLOAT, | |
| }; | |
| PXFORM :: ^XFORM; | |
| LPXFORM :: ^XFORM; | |
| BITMAP :: struct { | |
| bmType : LONG, | |
| bmWidth : LONG, | |
| bmHeight : LONG, | |
| bmWidthBytes : LONG, | |
| bmPlanes : WORD, | |
| bmBitsPixel : WORD, | |
| bmBits : LPVOID, | |
| }; | |
| PBITMAP :: ^BITMAP; | |
| NPBITMAP :: ^BITMAP; | |
| LPBITMAP :: ^BITMAP; | |
| RGBTRIPLE :: struct { | |
| rgbtBlue : BYTE, | |
| rgbtGreen : BYTE, | |
| rgbtRed : BYTE, | |
| }; | |
| PRGBTRIPLE :: ^RGBTRIPLE; | |
| NPRGBTRIPLE :: ^RGBTRIPLE; | |
| LPRGBTRIPLE :: ^RGBTRIPLE; | |
| RGBQUAD :: struct { | |
| rgbBlue : BYTE, | |
| rgbGreen : BYTE, | |
| rgbRed : BYTE, | |
| rgbReserved : BYTE, | |
| }; | |
| LPRGBQUAD :: ^RGBQUAD; | |
| LCSCSTYPE :: LONG; | |
| LCSGAMUTMATCH :: LONG; | |
| FXPT16DOT16 :: _c.long; | |
| LPFXPT16DOT16 :: ^_c.long; | |
| FXPT2DOT30 :: _c.long; | |
| LPFXPT2DOT30 :: ^_c.long; | |
| CIEXYZ :: struct { | |
| ciexyzX : FXPT2DOT30, | |
| ciexyzY : FXPT2DOT30, | |
| ciexyzZ : FXPT2DOT30, | |
| }; | |
| LPCIEXYZ :: ^CIEXYZ; | |
| CIEXYZTRIPLE :: struct { | |
| ciexyzRed : CIEXYZ, | |
| ciexyzGreen : CIEXYZ, | |
| ciexyzBlue : CIEXYZ, | |
| }; | |
| LPCIEXYZTRIPLE :: ^CIEXYZTRIPLE; | |
| LOGCOLORSPACEA :: struct { | |
| lcsSignature : DWORD, | |
| lcsVersion : DWORD, | |
| lcsSize : DWORD, | |
| lcsCSType : LCSCSTYPE, | |
| lcsIntent : LCSGAMUTMATCH, | |
| lcsEndpoints : CIEXYZTRIPLE, | |
| lcsGammaRed : DWORD, | |
| lcsGammaGreen : DWORD, | |
| lcsGammaBlue : DWORD, | |
| lcsFilename : [260]CHAR, | |
| }; | |
| LPLOGCOLORSPACEA :: ^LOGCOLORSPACEA; | |
| LOGCOLORSPACEW :: struct { | |
| lcsSignature : DWORD, | |
| lcsVersion : DWORD, | |
| lcsSize : DWORD, | |
| lcsCSType : LCSCSTYPE, | |
| lcsIntent : LCSGAMUTMATCH, | |
| lcsEndpoints : CIEXYZTRIPLE, | |
| lcsGammaRed : DWORD, | |
| lcsGammaGreen : DWORD, | |
| lcsGammaBlue : DWORD, | |
| lcsFilename : [260]WCHAR, | |
| }; | |
| LPLOGCOLORSPACEW :: ^LOGCOLORSPACEW; | |
| LOGCOLORSPACE :: LOGCOLORSPACEA; | |
| LPLOGCOLORSPACE :: LPLOGCOLORSPACEA; | |
| BITMAPCOREHEADER :: struct { | |
| bcSize : DWORD, | |
| bcWidth : WORD, | |
| bcHeight : WORD, | |
| bcPlanes : WORD, | |
| bcBitCount : WORD, | |
| }; | |
| LPBITMAPCOREHEADER :: ^BITMAPCOREHEADER; | |
| PBITMAPCOREHEADER :: ^BITMAPCOREHEADER; | |
| BITMAPINFOHEADER :: struct { | |
| biSize : DWORD, | |
| biWidth : LONG, | |
| biHeight : LONG, | |
| biPlanes : WORD, | |
| biBitCount : WORD, | |
| biCompression : DWORD, | |
| biSizeImage : DWORD, | |
| biXPelsPerMeter : LONG, | |
| biYPelsPerMeter : LONG, | |
| biClrUsed : DWORD, | |
| biClrImportant : DWORD, | |
| }; | |
| LPBITMAPINFOHEADER :: ^BITMAPINFOHEADER; | |
| PBITMAPINFOHEADER :: ^BITMAPINFOHEADER; | |
| BITMAPV4HEADER :: struct { | |
| bV4Size : DWORD, | |
| bV4Width : LONG, | |
| bV4Height : LONG, | |
| bV4Planes : WORD, | |
| bV4BitCount : WORD, | |
| bV4V4Compression : DWORD, | |
| bV4SizeImage : DWORD, | |
| bV4XPelsPerMeter : LONG, | |
| bV4YPelsPerMeter : LONG, | |
| bV4ClrUsed : DWORD, | |
| bV4ClrImportant : DWORD, | |
| bV4RedMask : DWORD, | |
| bV4GreenMask : DWORD, | |
| bV4BlueMask : DWORD, | |
| bV4AlphaMask : DWORD, | |
| bV4CSType : DWORD, | |
| bV4Endpoints : CIEXYZTRIPLE, | |
| bV4GammaRed : DWORD, | |
| bV4GammaGreen : DWORD, | |
| bV4GammaBlue : DWORD, | |
| }; | |
| LPBITMAPV4HEADER :: ^BITMAPV4HEADER; | |
| PBITMAPV4HEADER :: ^BITMAPV4HEADER; | |
| BITMAPV5HEADER :: struct { | |
| bV5Size : DWORD, | |
| bV5Width : LONG, | |
| bV5Height : LONG, | |
| bV5Planes : WORD, | |
| bV5BitCount : WORD, | |
| bV5Compression : DWORD, | |
| bV5SizeImage : DWORD, | |
| bV5XPelsPerMeter : LONG, | |
| bV5YPelsPerMeter : LONG, | |
| bV5ClrUsed : DWORD, | |
| bV5ClrImportant : DWORD, | |
| bV5RedMask : DWORD, | |
| bV5GreenMask : DWORD, | |
| bV5BlueMask : DWORD, | |
| bV5AlphaMask : DWORD, | |
| bV5CSType : DWORD, | |
| bV5Endpoints : CIEXYZTRIPLE, | |
| bV5GammaRed : DWORD, | |
| bV5GammaGreen : DWORD, | |
| bV5GammaBlue : DWORD, | |
| bV5Intent : DWORD, | |
| bV5ProfileData : DWORD, | |
| bV5ProfileSize : DWORD, | |
| bV5Reserved : DWORD, | |
| }; | |
| LPBITMAPV5HEADER :: ^BITMAPV5HEADER; | |
| PBITMAPV5HEADER :: ^BITMAPV5HEADER; | |
| BITMAPINFO :: struct { | |
| bmiHeader : BITMAPINFOHEADER, | |
| bmiColors : [1]RGBQUAD, | |
| }; | |
| LPBITMAPINFO :: ^BITMAPINFO; | |
| PBITMAPINFO :: ^BITMAPINFO; | |
| BITMAPCOREINFO :: struct { | |
| bmciHeader : BITMAPCOREHEADER, | |
| bmciColors : [1]RGBTRIPLE, | |
| }; | |
| LPBITMAPCOREINFO :: ^BITMAPCOREINFO; | |
| PBITMAPCOREINFO :: ^BITMAPCOREINFO; | |
| BITMAPFILEHEADER :: struct { | |
| bfType : WORD, | |
| bfSize : DWORD, | |
| bfReserved1 : WORD, | |
| bfReserved2 : WORD, | |
| bfOffBits : DWORD, | |
| }; | |
| LPBITMAPFILEHEADER :: ^BITMAPFILEHEADER; | |
| PBITMAPFILEHEADER :: ^BITMAPFILEHEADER; | |
| FONTSIGNATURE :: struct { | |
| fsUsb : [4]DWORD, | |
| fsCsb : [2]DWORD, | |
| }; | |
| PFONTSIGNATURE :: ^FONTSIGNATURE; | |
| LPFONTSIGNATURE :: ^FONTSIGNATURE; | |
| CHARSETINFO :: struct { | |
| ciCharset : UINT, | |
| ciACP : UINT, | |
| fs : FONTSIGNATURE, | |
| }; | |
| PCHARSETINFO :: ^CHARSETINFO; | |
| NPCHARSETINFO :: ^CHARSETINFO; | |
| LPCHARSETINFO :: ^CHARSETINFO; | |
| LOCALESIGNATURE :: struct { | |
| lsUsb : [4]DWORD, | |
| lsCsbDefault : [2]DWORD, | |
| lsCsbSupported : [2]DWORD, | |
| }; | |
| PLOCALESIGNATURE :: ^LOCALESIGNATURE; | |
| LPLOCALESIGNATURE :: ^LOCALESIGNATURE; | |
| HANDLETABLE :: struct { | |
| objectHandle : [1]HGDIOBJ, | |
| }; | |
| PHANDLETABLE :: ^HANDLETABLE; | |
| LPHANDLETABLE :: ^HANDLETABLE; | |
| METARECORD :: struct { | |
| rdSize : DWORD, | |
| rdFunction : WORD, | |
| rdParm : [1]WORD, | |
| }; | |
| PMETARECORD :: ^METARECORD; | |
| LPMETARECORD :: ^METARECORD; | |
| METAFILEPICT :: struct { | |
| mm : LONG, | |
| xExt : LONG, | |
| yExt : LONG, | |
| hMF : HMETAFILE, | |
| }; | |
| LPMETAFILEPICT :: ^METAFILEPICT; | |
| METAHEADER :: struct { | |
| mtType : WORD, | |
| mtHeaderSize : WORD, | |
| mtVersion : WORD, | |
| mtSize : DWORD, | |
| mtNoObjects : WORD, | |
| mtMaxRecord : DWORD, | |
| mtNoParameters : WORD, | |
| }; | |
| PMETAHEADER :: ^METAHEADER; | |
| LPMETAHEADER :: ^METAHEADER; | |
| ENHMETARECORD :: struct { | |
| iType : DWORD, | |
| nSize : DWORD, | |
| dParm : [1]DWORD, | |
| }; | |
| PENHMETARECORD :: ^ENHMETARECORD; | |
| LPENHMETARECORD :: ^ENHMETARECORD; | |
| ENHMETAHEADER :: struct { | |
| iType : DWORD, | |
| nSize : DWORD, | |
| rclBounds : RECTL, | |
| rclFrame : RECTL, | |
| dSignature : DWORD, | |
| nVersion : DWORD, | |
| nBytes : DWORD, | |
| nRecords : DWORD, | |
| nHandles : WORD, | |
| sReserved : WORD, | |
| nDescription : DWORD, | |
| offDescription : DWORD, | |
| nPalEntries : DWORD, | |
| szlDevice : SIZEL, | |
| szlMillimeters : SIZEL, | |
| cbPixelFormat : DWORD, | |
| offPixelFormat : DWORD, | |
| bOpenGL : DWORD, | |
| szlMicrometers : SIZEL, | |
| }; | |
| PENHMETAHEADER :: ^ENHMETAHEADER; | |
| LPENHMETAHEADER :: ^ENHMETAHEADER; | |
| BCHAR :: BYTE; | |
| TEXTMETRICA :: struct { | |
| tmHeight : LONG, | |
| tmAscent : LONG, | |
| tmDescent : LONG, | |
| tmInternalLeading : LONG, | |
| tmExternalLeading : LONG, | |
| tmAveCharWidth : LONG, | |
| tmMaxCharWidth : LONG, | |
| tmWeight : LONG, | |
| tmOverhang : LONG, | |
| tmDigitizedAspectX : LONG, | |
| tmDigitizedAspectY : LONG, | |
| tmFirstChar : BYTE, | |
| tmLastChar : BYTE, | |
| tmDefaultChar : BYTE, | |
| tmBreakChar : BYTE, | |
| tmItalic : BYTE, | |
| tmUnderlined : BYTE, | |
| tmStruckOut : BYTE, | |
| tmPitchAndFamily : BYTE, | |
| tmCharSet : BYTE, | |
| }; | |
| PTEXTMETRICA :: ^TEXTMETRICA; | |
| NPTEXTMETRICA :: ^TEXTMETRICA; | |
| LPTEXTMETRICA :: ^TEXTMETRICA; | |
| TEXTMETRICW :: struct { | |
| tmHeight : LONG, | |
| tmAscent : LONG, | |
| tmDescent : LONG, | |
| tmInternalLeading : LONG, | |
| tmExternalLeading : LONG, | |
| tmAveCharWidth : LONG, | |
| tmMaxCharWidth : LONG, | |
| tmWeight : LONG, | |
| tmOverhang : LONG, | |
| tmDigitizedAspectX : LONG, | |
| tmDigitizedAspectY : LONG, | |
| tmFirstChar : WCHAR, | |
| tmLastChar : WCHAR, | |
| tmDefaultChar : WCHAR, | |
| tmBreakChar : WCHAR, | |
| tmItalic : BYTE, | |
| tmUnderlined : BYTE, | |
| tmStruckOut : BYTE, | |
| tmPitchAndFamily : BYTE, | |
| tmCharSet : BYTE, | |
| }; | |
| PTEXTMETRICW :: ^TEXTMETRICW; | |
| NPTEXTMETRICW :: ^TEXTMETRICW; | |
| LPTEXTMETRICW :: ^TEXTMETRICW; | |
| TEXTMETRIC :: TEXTMETRICA; | |
| PTEXTMETRIC :: PTEXTMETRICA; | |
| NPTEXTMETRIC :: NPTEXTMETRICA; | |
| LPTEXTMETRIC :: LPTEXTMETRICA; | |
| NEWTEXTMETRICA :: struct { | |
| tmHeight : LONG, | |
| tmAscent : LONG, | |
| tmDescent : LONG, | |
| tmInternalLeading : LONG, | |
| tmExternalLeading : LONG, | |
| tmAveCharWidth : LONG, | |
| tmMaxCharWidth : LONG, | |
| tmWeight : LONG, | |
| tmOverhang : LONG, | |
| tmDigitizedAspectX : LONG, | |
| tmDigitizedAspectY : LONG, | |
| tmFirstChar : BYTE, | |
| tmLastChar : BYTE, | |
| tmDefaultChar : BYTE, | |
| tmBreakChar : BYTE, | |
| tmItalic : BYTE, | |
| tmUnderlined : BYTE, | |
| tmStruckOut : BYTE, | |
| tmPitchAndFamily : BYTE, | |
| tmCharSet : BYTE, | |
| ntmFlags : DWORD, | |
| ntmSizeEM : UINT, | |
| ntmCellHeight : UINT, | |
| ntmAvgWidth : UINT, | |
| }; | |
| PNEWTEXTMETRICA :: ^NEWTEXTMETRICA; | |
| NPNEWTEXTMETRICA :: ^NEWTEXTMETRICA; | |
| LPNEWTEXTMETRICA :: ^NEWTEXTMETRICA; | |
| NEWTEXTMETRICW :: struct { | |
| tmHeight : LONG, | |
| tmAscent : LONG, | |
| tmDescent : LONG, | |
| tmInternalLeading : LONG, | |
| tmExternalLeading : LONG, | |
| tmAveCharWidth : LONG, | |
| tmMaxCharWidth : LONG, | |
| tmWeight : LONG, | |
| tmOverhang : LONG, | |
| tmDigitizedAspectX : LONG, | |
| tmDigitizedAspectY : LONG, | |
| tmFirstChar : WCHAR, | |
| tmLastChar : WCHAR, | |
| tmDefaultChar : WCHAR, | |
| tmBreakChar : WCHAR, | |
| tmItalic : BYTE, | |
| tmUnderlined : BYTE, | |
| tmStruckOut : BYTE, | |
| tmPitchAndFamily : BYTE, | |
| tmCharSet : BYTE, | |
| ntmFlags : DWORD, | |
| ntmSizeEM : UINT, | |
| ntmCellHeight : UINT, | |
| ntmAvgWidth : UINT, | |
| }; | |
| PNEWTEXTMETRICW :: ^NEWTEXTMETRICW; | |
| NPNEWTEXTMETRICW :: ^NEWTEXTMETRICW; | |
| LPNEWTEXTMETRICW :: ^NEWTEXTMETRICW; | |
| NEWTEXTMETRIC :: NEWTEXTMETRICA; | |
| PNEWTEXTMETRIC :: PNEWTEXTMETRICA; | |
| NPNEWTEXTMETRIC :: NPNEWTEXTMETRICA; | |
| LPNEWTEXTMETRIC :: LPNEWTEXTMETRICA; | |
| NEWTEXTMETRICEXA :: struct { | |
| ntmTm : NEWTEXTMETRICA, | |
| ntmFontSig : FONTSIGNATURE, | |
| }; | |
| NEWTEXTMETRICEXW :: struct { | |
| ntmTm : NEWTEXTMETRICW, | |
| ntmFontSig : FONTSIGNATURE, | |
| }; | |
| NEWTEXTMETRICEX :: NEWTEXTMETRICEXA; | |
| PELARRAY :: struct { | |
| paXCount : LONG, | |
| paYCount : LONG, | |
| paXExt : LONG, | |
| paYExt : LONG, | |
| paRGBs : BYTE, | |
| }; | |
| PPELARRAY :: ^PELARRAY; | |
| NPPELARRAY :: ^PELARRAY; | |
| LPPELARRAY :: ^PELARRAY; | |
| LOGBRUSH :: struct { | |
| lbStyle : UINT, | |
| lbColor : COLORREF, | |
| lbHatch : ULONG_PTR, | |
| }; | |
| PLOGBRUSH :: ^LOGBRUSH; | |
| NPLOGBRUSH :: ^LOGBRUSH; | |
| LPLOGBRUSH :: ^LOGBRUSH; | |
| LOGBRUSH32 :: struct { | |
| lbStyle : UINT, | |
| lbColor : COLORREF, | |
| lbHatch : ULONG, | |
| }; | |
| PLOGBRUSH32 :: ^LOGBRUSH32; | |
| NPLOGBRUSH32 :: ^LOGBRUSH32; | |
| LPLOGBRUSH32 :: ^LOGBRUSH32; | |
| PATTERN :: LOGBRUSH; | |
| PPATTERN :: ^PATTERN; | |
| NPPATTERN :: ^PATTERN; | |
| LPPATTERN :: ^PATTERN; | |
| LOGPEN :: struct { | |
| lopnStyle : UINT, | |
| lopnWidth : POINT, | |
| lopnColor : COLORREF, | |
| }; | |
| PLOGPEN :: ^LOGPEN; | |
| NPLOGPEN :: ^LOGPEN; | |
| LPLOGPEN :: ^LOGPEN; | |
| EXTLOGPEN :: struct { | |
| elpPenStyle : DWORD, | |
| elpWidth : DWORD, | |
| elpBrushStyle : UINT, | |
| elpColor : COLORREF, | |
| elpHatch : ULONG_PTR, | |
| elpNumEntries : DWORD, | |
| elpStyleEntry : [1]DWORD, | |
| }; | |
| PEXTLOGPEN :: ^EXTLOGPEN; | |
| NPEXTLOGPEN :: ^EXTLOGPEN; | |
| LPEXTLOGPEN :: ^EXTLOGPEN; | |
| EXTLOGPEN32 :: struct { | |
| elpPenStyle : DWORD, | |
| elpWidth : DWORD, | |
| elpBrushStyle : UINT, | |
| elpColor : COLORREF, | |
| elpHatch : ULONG, | |
| elpNumEntries : DWORD, | |
| elpStyleEntry : [1]DWORD, | |
| }; | |
| PEXTLOGPEN32 :: ^EXTLOGPEN32; | |
| NPEXTLOGPEN32 :: ^EXTLOGPEN32; | |
| LPEXTLOGPEN32 :: ^EXTLOGPEN32; | |
| PALETTEENTRY :: struct { | |
| peRed : BYTE, | |
| peGreen : BYTE, | |
| peBlue : BYTE, | |
| peFlags : BYTE, | |
| }; | |
| PPALETTEENTRY :: ^PALETTEENTRY; | |
| LPPALETTEENTRY :: ^PALETTEENTRY; | |
| LOGPALETTE :: struct { | |
| palVersion : WORD, | |
| palNumEntries : WORD, | |
| palPalEntry : [1]PALETTEENTRY, | |
| }; | |
| PLOGPALETTE :: ^LOGPALETTE; | |
| NPLOGPALETTE :: ^LOGPALETTE; | |
| LPLOGPALETTE :: ^LOGPALETTE; | |
| LOGFONTA :: struct { | |
| lfHeight : LONG, | |
| lfWidth : LONG, | |
| lfEscapement : LONG, | |
| lfOrientation : LONG, | |
| lfWeight : LONG, | |
| lfItalic : BYTE, | |
| lfUnderline : BYTE, | |
| lfStrikeOut : BYTE, | |
| lfCharSet : BYTE, | |
| lfOutPrecision : BYTE, | |
| lfClipPrecision : BYTE, | |
| lfQuality : BYTE, | |
| lfPitchAndFamily : BYTE, | |
| lfFaceName : [32]CHAR, | |
| }; | |
| PLOGFONTA :: ^LOGFONTA; | |
| NPLOGFONTA :: ^LOGFONTA; | |
| LPLOGFONTA :: ^LOGFONTA; | |
| LOGFONTW :: struct { | |
| lfHeight : LONG, | |
| lfWidth : LONG, | |
| lfEscapement : LONG, | |
| lfOrientation : LONG, | |
| lfWeight : LONG, | |
| lfItalic : BYTE, | |
| lfUnderline : BYTE, | |
| lfStrikeOut : BYTE, | |
| lfCharSet : BYTE, | |
| lfOutPrecision : BYTE, | |
| lfClipPrecision : BYTE, | |
| lfQuality : BYTE, | |
| lfPitchAndFamily : BYTE, | |
| lfFaceName : [32]WCHAR, | |
| }; | |
| PLOGFONTW :: ^LOGFONTW; | |
| NPLOGFONTW :: ^LOGFONTW; | |
| LPLOGFONTW :: ^LOGFONTW; | |
| LOGFONT :: LOGFONTA; | |
| PLOGFONT :: PLOGFONTA; | |
| NPLOGFONT :: NPLOGFONTA; | |
| LPLOGFONT :: LPLOGFONTA; | |
| ENUMLOGFONTA :: struct { | |
| elfLogFont : LOGFONTA, | |
| elfFullName : [64]BYTE, | |
| elfStyle : [32]BYTE, | |
| }; | |
| LPENUMLOGFONTA :: ^ENUMLOGFONTA; | |
| ENUMLOGFONTW :: struct { | |
| elfLogFont : LOGFONTW, | |
| elfFullName : [64]WCHAR, | |
| elfStyle : [32]WCHAR, | |
| }; | |
| LPENUMLOGFONTW :: ^ENUMLOGFONTW; | |
| ENUMLOGFONT :: ENUMLOGFONTA; | |
| LPENUMLOGFONT :: LPENUMLOGFONTA; | |
| ENUMLOGFONTEXA :: struct { | |
| elfLogFont : LOGFONTA, | |
| elfFullName : [64]BYTE, | |
| elfStyle : [32]BYTE, | |
| elfScript : [32]BYTE, | |
| }; | |
| LPENUMLOGFONTEXA :: ^ENUMLOGFONTEXA; | |
| ENUMLOGFONTEXW :: struct { | |
| elfLogFont : LOGFONTW, | |
| elfFullName : [64]WCHAR, | |
| elfStyle : [32]WCHAR, | |
| elfScript : [32]WCHAR, | |
| }; | |
| LPENUMLOGFONTEXW :: ^ENUMLOGFONTEXW; | |
| ENUMLOGFONTEX :: ENUMLOGFONTEXA; | |
| LPENUMLOGFONTEX :: LPENUMLOGFONTEXA; | |
| PANOSE :: struct { | |
| bFamilyType : BYTE, | |
| bSerifStyle : BYTE, | |
| bWeight : BYTE, | |
| bProportion : BYTE, | |
| bContrast : BYTE, | |
| bStrokeVariation : BYTE, | |
| bArmStyle : BYTE, | |
| bLetterform : BYTE, | |
| bMidline : BYTE, | |
| bXHeight : BYTE, | |
| }; | |
| LPPANOSE :: ^PANOSE; | |
| EXTLOGFONTA :: struct { | |
| elfLogFont : LOGFONTA, | |
| elfFullName : [64]BYTE, | |
| elfStyle : [32]BYTE, | |
| elfVersion : DWORD, | |
| elfStyleSize : DWORD, | |
| elfMatch : DWORD, | |
| elfReserved : DWORD, | |
| elfVendorId : [4]BYTE, | |
| elfCulture : DWORD, | |
| elfPanose : PANOSE, | |
| }; | |
| PEXTLOGFONTA :: ^EXTLOGFONTA; | |
| NPEXTLOGFONTA :: ^EXTLOGFONTA; | |
| LPEXTLOGFONTA :: ^EXTLOGFONTA; | |
| EXTLOGFONTW :: struct { | |
| elfLogFont : LOGFONTW, | |
| elfFullName : [64]WCHAR, | |
| elfStyle : [32]WCHAR, | |
| elfVersion : DWORD, | |
| elfStyleSize : DWORD, | |
| elfMatch : DWORD, | |
| elfReserved : DWORD, | |
| elfVendorId : [4]BYTE, | |
| elfCulture : DWORD, | |
| elfPanose : PANOSE, | |
| }; | |
| PEXTLOGFONTW :: ^EXTLOGFONTW; | |
| NPEXTLOGFONTW :: ^EXTLOGFONTW; | |
| LPEXTLOGFONTW :: ^EXTLOGFONTW; | |
| EXTLOGFONT :: EXTLOGFONTA; | |
| PEXTLOGFONT :: PEXTLOGFONTA; | |
| NPEXTLOGFONT :: NPEXTLOGFONTA; | |
| LPEXTLOGFONT :: LPEXTLOGFONTA; | |
| DEVMODEA :: struct { | |
| dmDeviceName : [32]BYTE, | |
| dmSpecVersion : WORD, | |
| dmDriverVersion : WORD, | |
| dmSize : WORD, | |
| dmDriverExtra : WORD, | |
| dmFields : DWORD, | |
| u : struct #raw_union { | |
| s : struct { | |
| dmOrientation : _c.short, | |
| dmPaperSize : _c.short, | |
| dmPaperLength : _c.short, | |
| dmPaperWidth : _c.short, | |
| dmScale : _c.short, | |
| dmCopies : _c.short, | |
| dmDefaultSource : _c.short, | |
| dmPrintQuality : _c.short, | |
| }, | |
| s2 : struct { | |
| dmPosition : POINTL, | |
| dmDisplayOrientation : DWORD, | |
| dmDisplayFixedOutput : DWORD, | |
| }, | |
| }, | |
| dmColor : _c.short, | |
| dmDuplex : _c.short, | |
| dmYResolution : _c.short, | |
| dmTTOption : _c.short, | |
| dmCollate : _c.short, | |
| dmFormName : [32]BYTE, | |
| dmLogPixels : WORD, | |
| dmBitsPerPel : DWORD, | |
| dmPelsWidth : DWORD, | |
| dmPelsHeight : DWORD, | |
| u2 : struct #raw_union { | |
| dmDisplayFlags : DWORD, | |
| dmNup : DWORD, | |
| }, | |
| dmDisplayFrequency : DWORD, | |
| dmICMMethod : DWORD, | |
| dmICMIntent : DWORD, | |
| dmMediaType : DWORD, | |
| dmDitherType : DWORD, | |
| dmReserved1 : DWORD, | |
| dmReserved2 : DWORD, | |
| dmPanningWidth : DWORD, | |
| dmPanningHeight : DWORD, | |
| }; | |
| PDEVMODEA :: ^DEVMODEA; | |
| NPDEVMODEA :: ^DEVMODEA; | |
| LPDEVMODEA :: ^DEVMODEA; | |
| DEVMODEW :: struct { | |
| dmDeviceName : [32]WCHAR, | |
| dmSpecVersion : WORD, | |
| dmDriverVersion : WORD, | |
| dmSize : WORD, | |
| dmDriverExtra : WORD, | |
| dmFields : DWORD, | |
| u : struct #raw_union { | |
| s : struct { | |
| dmOrientation : _c.short, | |
| dmPaperSize : _c.short, | |
| dmPaperLength : _c.short, | |
| dmPaperWidth : _c.short, | |
| dmScale : _c.short, | |
| dmCopies : _c.short, | |
| dmDefaultSource : _c.short, | |
| dmPrintQuality : _c.short, | |
| }, | |
| s2 : struct { | |
| dmPosition : POINTL, | |
| dmDisplayOrientation : DWORD, | |
| dmDisplayFixedOutput : DWORD, | |
| }, | |
| }, | |
| dmColor : _c.short, | |
| dmDuplex : _c.short, | |
| dmYResolution : _c.short, | |
| dmTTOption : _c.short, | |
| dmCollate : _c.short, | |
| dmFormName : [32]WCHAR, | |
| dmLogPixels : WORD, | |
| dmBitsPerPel : DWORD, | |
| dmPelsWidth : DWORD, | |
| dmPelsHeight : DWORD, | |
| u2 : struct #raw_union { | |
| dmDisplayFlags : DWORD, | |
| dmNup : DWORD, | |
| }, | |
| dmDisplayFrequency : DWORD, | |
| dmICMMethod : DWORD, | |
| dmICMIntent : DWORD, | |
| dmMediaType : DWORD, | |
| dmDitherType : DWORD, | |
| dmReserved1 : DWORD, | |
| dmReserved2 : DWORD, | |
| dmPanningWidth : DWORD, | |
| dmPanningHeight : DWORD, | |
| }; | |
| PDEVMODEW :: ^DEVMODEW; | |
| NPDEVMODEW :: ^DEVMODEW; | |
| LPDEVMODEW :: ^DEVMODEW; | |
| DEVMODE :: DEVMODEA; | |
| PDEVMODE :: PDEVMODEA; | |
| NPDEVMODE :: NPDEVMODEA; | |
| LPDEVMODE :: LPDEVMODEA; | |
| DISPLAY_DEVICEA :: struct { | |
| cb : DWORD, | |
| DeviceName : [32]CHAR, | |
| DeviceString : [128]CHAR, | |
| StateFlags : DWORD, | |
| DeviceID : [128]CHAR, | |
| DeviceKey : [128]CHAR, | |
| }; | |
| PDISPLAY_DEVICEA :: ^DISPLAY_DEVICEA; | |
| LPDISPLAY_DEVICEA :: ^DISPLAY_DEVICEA; | |
| DISPLAY_DEVICEW :: struct { | |
| cb : DWORD, | |
| DeviceName : [32]WCHAR, | |
| DeviceString : [128]WCHAR, | |
| StateFlags : DWORD, | |
| DeviceID : [128]WCHAR, | |
| DeviceKey : [128]WCHAR, | |
| }; | |
| PDISPLAY_DEVICEW :: ^DISPLAY_DEVICEW; | |
| LPDISPLAY_DEVICEW :: ^DISPLAY_DEVICEW; | |
| DISPLAY_DEVICE :: DISPLAY_DEVICEA; | |
| PDISPLAY_DEVICE :: PDISPLAY_DEVICEA; | |
| LPDISPLAY_DEVICE :: LPDISPLAY_DEVICEA; | |
| DISPLAYCONFIG_RATIONAL :: struct { | |
| Numerator : UINT32, | |
| Denominator : UINT32, | |
| }; | |
| /* DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY :: enum { */ | |
| DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY :: _c.int; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER :: -1; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15 :: 0; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SVIDEO :: 1; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPOSITE_VIDEO :: 2; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPONENT_VIDEO :: 3; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DVI :: 4; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI :: 5; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_LVDS :: 6; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_D_JPN :: 8; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDI :: 9; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL :: 10; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED :: 11; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EXTERNAL :: 12; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EMBEDDED :: 13; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDTVDONGLE :: 14; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_MIRACAST :: 15; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INDIRECT_WIRED :: 16; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INDIRECT_VIRTUAL :: 17; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL :: 0x80000000; | |
| DISPLAYCONFIG_OUTPUT_TECHNOLOGY_FORCE_UINT32 :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| /* DISPLAYCONFIG_SCANLINE_ORDERING :: enum { */ | |
| DISPLAYCONFIG_SCANLINE_ORDERING :: _c.int; | |
| DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED :: 0; | |
| DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE :: 1; | |
| DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED :: 2; | |
| DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_UPPERFIELDFIRST :: DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED; | |
| DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_LOWERFIELDFIRST :: 3; | |
| DISPLAYCONFIG_SCANLINE_ORDERING_FORCE_UINT32 :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| DISPLAYCONFIG_2DREGION :: struct { | |
| cx : UINT32, | |
| cy : UINT32, | |
| }; | |
| DISPLAYCONFIG_VIDEO_SIGNAL_INFO :: struct { | |
| pixelRate : UINT64, | |
| hSyncFreq : DISPLAYCONFIG_RATIONAL, | |
| vSyncFreq : DISPLAYCONFIG_RATIONAL, | |
| activeSize : DISPLAYCONFIG_2DREGION, | |
| totalSize : DISPLAYCONFIG_2DREGION, | |
| u : struct #raw_union { | |
| AdditionalSignalInfo : bit_field { | |
| videoStandard : 16, | |
| vSyncFreqDivider : 6, | |
| reserved : 10, | |
| }, | |
| videoStandard : UINT32, | |
| }, | |
| scanLineOrdering : DISPLAYCONFIG_SCANLINE_ORDERING, | |
| }; | |
| /* DISPLAYCONFIG_SCALING :: enum { */ | |
| DISPLAYCONFIG_SCALING :: _c.int; | |
| DISPLAYCONFIG_SCALING_IDENTITY :: 1; | |
| DISPLAYCONFIG_SCALING_CENTERED :: 2; | |
| DISPLAYCONFIG_SCALING_STRETCHED :: 3; | |
| DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX :: 4; | |
| DISPLAYCONFIG_SCALING_CUSTOM :: 5; | |
| DISPLAYCONFIG_SCALING_PREFERRED :: 128; | |
| DISPLAYCONFIG_SCALING_FORCE_UINT32 :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| /* DISPLAYCONFIG_ROTATION :: enum { */ | |
| DISPLAYCONFIG_ROTATION :: _c.int; | |
| DISPLAYCONFIG_ROTATION_IDENTITY :: 1; | |
| DISPLAYCONFIG_ROTATION_ROTATE90 :: 2; | |
| DISPLAYCONFIG_ROTATION_ROTATE180 :: 3; | |
| DISPLAYCONFIG_ROTATION_ROTATE270 :: 4; | |
| DISPLAYCONFIG_ROTATION_FORCE_UINT32 :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| /* DISPLAYCONFIG_MODE_INFO_TYPE :: enum { */ | |
| DISPLAYCONFIG_MODE_INFO_TYPE :: _c.int; | |
| DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE :: 1; | |
| DISPLAYCONFIG_MODE_INFO_TYPE_TARGET :: 2; | |
| DISPLAYCONFIG_MODE_INFO_TYPE_DESKTOP_IMAGE :: 3; | |
| DISPLAYCONFIG_MODE_INFO_TYPE_FORCE_UINT32 :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| /* DISPLAYCONFIG_PIXELFORMAT :: enum { */ | |
| DISPLAYCONFIG_PIXELFORMAT :: _c.int; | |
| DISPLAYCONFIG_PIXELFORMAT_8BPP :: 1; | |
| DISPLAYCONFIG_PIXELFORMAT_16BPP :: 2; | |
| DISPLAYCONFIG_PIXELFORMAT_24BPP :: 3; | |
| DISPLAYCONFIG_PIXELFORMAT_32BPP :: 4; | |
| DISPLAYCONFIG_PIXELFORMAT_NONGDI :: 5; | |
| DISPLAYCONFIG_PIXELFORMAT_FORCE_UINT32 :: 0xffffffff; | |
| /* } */ | |
| ; | |
| DISPLAYCONFIG_SOURCE_MODE :: struct { | |
| width : UINT32, | |
| height : UINT32, | |
| pixelFormat : DISPLAYCONFIG_PIXELFORMAT, | |
| position : POINTL, | |
| }; | |
| DISPLAYCONFIG_TARGET_MODE :: struct { | |
| targetVideoSignalInfo : DISPLAYCONFIG_VIDEO_SIGNAL_INFO, | |
| }; | |
| DISPLAYCONFIG_DESKTOP_IMAGE_INFO :: struct { | |
| PathSourceSize : POINTL, | |
| DesktopImageRegion : RECTL, | |
| DesktopImageClip : RECTL, | |
| }; | |
| DISPLAYCONFIG_MODE_INFO :: struct { | |
| infoType : DISPLAYCONFIG_MODE_INFO_TYPE, | |
| id : UINT32, | |
| adapterId : LUID, | |
| u : struct #raw_union { | |
| targetMode : DISPLAYCONFIG_TARGET_MODE, | |
| sourceMode : DISPLAYCONFIG_SOURCE_MODE, | |
| desktopImageInfo : DISPLAYCONFIG_DESKTOP_IMAGE_INFO, | |
| }, | |
| }; | |
| DISPLAYCONFIG_PATH_SOURCE_INFO :: struct { | |
| adapterId : LUID, | |
| id : UINT32, | |
| u : struct #raw_union { | |
| modeInfoIdx : UINT32, | |
| s : bit_field { | |
| cloneGroupId : 16, | |
| sourceModeInfoIdx : 16, | |
| }, | |
| }, | |
| statusFlags : UINT32, | |
| }; | |
| DISPLAYCONFIG_PATH_TARGET_INFO :: struct { | |
| adapterId : LUID, | |
| id : UINT32, | |
| u : struct #raw_union { | |
| modeInfoIdx : UINT32, | |
| s : bit_field { | |
| desktopModeInfoIdx : 16, | |
| targetModeInfoIdx : 16, | |
| }, | |
| }, | |
| outputTechnology : DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY, | |
| rotation : DISPLAYCONFIG_ROTATION, | |
| scaling : DISPLAYCONFIG_SCALING, | |
| refreshRate : DISPLAYCONFIG_RATIONAL, | |
| scanLineOrdering : DISPLAYCONFIG_SCANLINE_ORDERING, | |
| targetAvailable : BOOL, | |
| statusFlags : UINT32, | |
| }; | |
| DISPLAYCONFIG_PATH_INFO :: struct { | |
| sourceInfo : DISPLAYCONFIG_PATH_SOURCE_INFO, | |
| targetInfo : DISPLAYCONFIG_PATH_TARGET_INFO, | |
| flags : UINT32, | |
| }; | |
| /* DISPLAYCONFIG_TOPOLOGY_ID :: enum { */ | |
| DISPLAYCONFIG_TOPOLOGY_ID :: _c.int; | |
| DISPLAYCONFIG_TOPOLOGY_INTERNAL :: 0x00000001; | |
| DISPLAYCONFIG_TOPOLOGY_CLONE :: 0x00000002; | |
| DISPLAYCONFIG_TOPOLOGY_EXTEND :: 0x00000004; | |
| DISPLAYCONFIG_TOPOLOGY_EXTERNAL :: 0x00000008; | |
| DISPLAYCONFIG_TOPOLOGY_FORCE_UINT32 :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| /* DISPLAYCONFIG_DEVICE_INFO_TYPE :: enum { */ | |
| DISPLAYCONFIG_DEVICE_INFO_TYPE :: _c.int; | |
| DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME :: 1; | |
| DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME :: 2; | |
| DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_PREFERRED_MODE :: 3; | |
| DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME :: 4; | |
| DISPLAYCONFIG_DEVICE_INFO_SET_TARGET_PERSISTENCE :: 5; | |
| DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_BASE_TYPE :: 6; | |
| DISPLAYCONFIG_DEVICE_INFO_GET_SUPPORT_VIRTUAL_RESOLUTION :: 7; | |
| DISPLAYCONFIG_DEVICE_INFO_SET_SUPPORT_VIRTUAL_RESOLUTION :: 8; | |
| DISPLAYCONFIG_DEVICE_INFO_GET_ADVANCED_COLOR_INFO :: 9; | |
| DISPLAYCONFIG_DEVICE_INFO_SET_ADVANCED_COLOR_STATE :: 10; | |
| DISPLAYCONFIG_DEVICE_INFO_GET_SDR_WHITE_LEVEL :: 11; | |
| DISPLAYCONFIG_DEVICE_INFO_FORCE_UINT32 :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| DISPLAYCONFIG_DEVICE_INFO_HEADER :: struct { | |
| type : DISPLAYCONFIG_DEVICE_INFO_TYPE, | |
| size : UINT32, | |
| adapterId : LUID, | |
| id : UINT32, | |
| }; | |
| DISPLAYCONFIG_SOURCE_DEVICE_NAME :: struct { | |
| header : DISPLAYCONFIG_DEVICE_INFO_HEADER, | |
| viewGdiDeviceName : [32]WCHAR, | |
| }; | |
| DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS :: struct { | |
| u : struct #raw_union { | |
| s : bit_field { | |
| friendlyNameFromEdid : 1, | |
| friendlyNameForced : 1, | |
| edidIdsValid : 1, | |
| reserved : 29, | |
| }, | |
| value : UINT32, | |
| }, | |
| }; | |
| DISPLAYCONFIG_TARGET_DEVICE_NAME :: struct { | |
| header : DISPLAYCONFIG_DEVICE_INFO_HEADER, | |
| flags : DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS, | |
| outputTechnology : DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY, | |
| edidManufactureId : UINT16, | |
| edidProductCodeId : UINT16, | |
| connectorInstance : UINT32, | |
| monitorFriendlyDeviceName : [64]WCHAR, | |
| monitorDevicePath : [128]WCHAR, | |
| }; | |
| DISPLAYCONFIG_TARGET_PREFERRED_MODE :: struct { | |
| header : DISPLAYCONFIG_DEVICE_INFO_HEADER, | |
| width : UINT32, | |
| height : UINT32, | |
| targetMode : DISPLAYCONFIG_TARGET_MODE, | |
| }; | |
| DISPLAYCONFIG_ADAPTER_NAME :: struct { | |
| header : DISPLAYCONFIG_DEVICE_INFO_HEADER, | |
| adapterDevicePath : [128]WCHAR, | |
| }; | |
| DISPLAYCONFIG_TARGET_BASE_TYPE :: struct { | |
| header : DISPLAYCONFIG_DEVICE_INFO_HEADER, | |
| baseOutputTechnology : DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY, | |
| }; | |
| DISPLAYCONFIG_SET_TARGET_PERSISTENCE :: struct { | |
| header : DISPLAYCONFIG_DEVICE_INFO_HEADER, | |
| u : struct #raw_union { | |
| s : bit_field { | |
| bootPersistenceOn : 1, | |
| reserved : 31, | |
| }, | |
| value : UINT32, | |
| }, | |
| }; | |
| DISPLAYCONFIG_SUPPORT_VIRTUAL_RESOLUTION :: struct { | |
| header : DISPLAYCONFIG_DEVICE_INFO_HEADER, | |
| s : struct #raw_union { | |
| s : bit_field { | |
| disableMonitorVirtualResolution : 1, | |
| reserved : 31, | |
| }, | |
| value : UINT32, | |
| }, | |
| }; | |
| /* DISPLAYCONFIG_COLOR_ENCODING :: enum { */ | |
| DISPLAYCONFIG_COLOR_ENCODING :: _c.int; | |
| DISPLAYCONFIG_COLOR_ENCODING_RGB :: 0; | |
| DISPLAYCONFIG_COLOR_ENCODING_YCBCR444 :: 1; | |
| DISPLAYCONFIG_COLOR_ENCODING_YCBCR422 :: 2; | |
| DISPLAYCONFIG_COLOR_ENCODING_YCBCR420 :: 3; | |
| DISPLAYCONFIG_COLOR_ENCODING_INTENSITY :: 4; | |
| DISPLAYCONFIG_COLOR_ENCODING_FORCE_UINT32 :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO :: struct { | |
| header : DISPLAYCONFIG_DEVICE_INFO_HEADER, | |
| u : struct #raw_union { | |
| s : bit_field { | |
| advancedColorSupported : 1, | |
| advancedColorEnabled : 1, | |
| wideColorEnforced : 1, | |
| advancedColorForceDisabled : 1, | |
| reserved : 28, | |
| }, | |
| value : UINT32, | |
| }, | |
| colorEncoding : DISPLAYCONFIG_COLOR_ENCODING, | |
| bitsPerColorChannel : UINT32, | |
| }; | |
| DISPLAYCONFIG_SET_ADVANCED_COLOR_STATE :: struct { | |
| header : DISPLAYCONFIG_DEVICE_INFO_HEADER, | |
| u : struct #raw_union { | |
| s : bit_field { | |
| enableAdvancedColor : 1, | |
| reserved : 31, | |
| }, | |
| value : UINT32, | |
| }, | |
| }; | |
| DISPLAYCONFIG_SDR_WHITE_LEVEL :: struct { | |
| header : DISPLAYCONFIG_DEVICE_INFO_HEADER, | |
| SDRWhiteLevel : ULONG, | |
| }; | |
| RGNDATAHEADER :: struct { | |
| dwSize : DWORD, | |
| iType : DWORD, | |
| nCount : DWORD, | |
| nRgnSize : DWORD, | |
| rcBound : RECT, | |
| }; | |
| PRGNDATAHEADER :: ^RGNDATAHEADER; | |
| RGNDATA :: struct { | |
| rdh : RGNDATAHEADER, | |
| Buffer : [1]_c.uchar, | |
| }; | |
| PRGNDATA :: ^RGNDATA; | |
| NPRGNDATA :: ^RGNDATA; | |
| LPRGNDATA :: ^RGNDATA; | |
| ABC :: struct { | |
| abcA : _c.int, | |
| abcB : UINT, | |
| abcC : _c.int, | |
| }; | |
| PABC :: ^ABC; | |
| NPABC :: ^ABC; | |
| LPABC :: ^ABC; | |
| ABCFLOAT :: struct { | |
| abcfA : FLOAT, | |
| abcfB : FLOAT, | |
| abcfC : FLOAT, | |
| }; | |
| PABCFLOAT :: ^ABCFLOAT; | |
| NPABCFLOAT :: ^ABCFLOAT; | |
| LPABCFLOAT :: ^ABCFLOAT; | |
| OUTLINETEXTMETRICA :: struct { | |
| otmSize : UINT, | |
| otmTextMetrics : TEXTMETRICA, | |
| otmFiller : BYTE, | |
| otmPanoseNumber : PANOSE, | |
| otmfsSelection : UINT, | |
| otmfsType : UINT, | |
| otmsCharSlopeRise : _c.int, | |
| otmsCharSlopeRun : _c.int, | |
| otmItalicAngle : _c.int, | |
| otmEMSquare : UINT, | |
| otmAscent : _c.int, | |
| otmDescent : _c.int, | |
| otmLineGap : UINT, | |
| otmsCapEmHeight : UINT, | |
| otmsXHeight : UINT, | |
| otmrcFontBox : RECT, | |
| otmMacAscent : _c.int, | |
| otmMacDescent : _c.int, | |
| otmMacLineGap : UINT, | |
| otmusMinimumPPEM : UINT, | |
| otmptSubscriptSize : POINT, | |
| otmptSubscriptOffset : POINT, | |
| otmptSuperscriptSize : POINT, | |
| otmptSuperscriptOffset : POINT, | |
| otmsStrikeoutSize : UINT, | |
| otmsStrikeoutPosition : _c.int, | |
| otmsUnderscoreSize : _c.int, | |
| otmsUnderscorePosition : _c.int, | |
| otmpFamilyName : PSTR, | |
| otmpFaceName : PSTR, | |
| otmpStyleName : PSTR, | |
| otmpFullName : PSTR, | |
| }; | |
| POUTLINETEXTMETRICA :: ^OUTLINETEXTMETRICA; | |
| NPOUTLINETEXTMETRICA :: ^OUTLINETEXTMETRICA; | |
| LPOUTLINETEXTMETRICA :: ^OUTLINETEXTMETRICA; | |
| OUTLINETEXTMETRICW :: struct { | |
| otmSize : UINT, | |
| otmTextMetrics : TEXTMETRICW, | |
| otmFiller : BYTE, | |
| otmPanoseNumber : PANOSE, | |
| otmfsSelection : UINT, | |
| otmfsType : UINT, | |
| otmsCharSlopeRise : _c.int, | |
| otmsCharSlopeRun : _c.int, | |
| otmItalicAngle : _c.int, | |
| otmEMSquare : UINT, | |
| otmAscent : _c.int, | |
| otmDescent : _c.int, | |
| otmLineGap : UINT, | |
| otmsCapEmHeight : UINT, | |
| otmsXHeight : UINT, | |
| otmrcFontBox : RECT, | |
| otmMacAscent : _c.int, | |
| otmMacDescent : _c.int, | |
| otmMacLineGap : UINT, | |
| otmusMinimumPPEM : UINT, | |
| otmptSubscriptSize : POINT, | |
| otmptSubscriptOffset : POINT, | |
| otmptSuperscriptSize : POINT, | |
| otmptSuperscriptOffset : POINT, | |
| otmsStrikeoutSize : UINT, | |
| otmsStrikeoutPosition : _c.int, | |
| otmsUnderscoreSize : _c.int, | |
| otmsUnderscorePosition : _c.int, | |
| otmpFamilyName : PSTR, | |
| otmpFaceName : PSTR, | |
| otmpStyleName : PSTR, | |
| otmpFullName : PSTR, | |
| }; | |
| POUTLINETEXTMETRICW :: ^OUTLINETEXTMETRICW; | |
| NPOUTLINETEXTMETRICW :: ^OUTLINETEXTMETRICW; | |
| LPOUTLINETEXTMETRICW :: ^OUTLINETEXTMETRICW; | |
| OUTLINETEXTMETRIC :: OUTLINETEXTMETRICA; | |
| POUTLINETEXTMETRIC :: POUTLINETEXTMETRICA; | |
| NPOUTLINETEXTMETRIC :: NPOUTLINETEXTMETRICA; | |
| LPOUTLINETEXTMETRIC :: LPOUTLINETEXTMETRICA; | |
| POLYTEXTA :: struct { | |
| x : _c.int, | |
| y : _c.int, | |
| n : UINT, | |
| lpstr : LPCSTR, | |
| uiFlags : UINT, | |
| rcl : RECT, | |
| pdx : ^_c.int, | |
| }; | |
| PPOLYTEXTA :: ^POLYTEXTA; | |
| NPPOLYTEXTA :: ^POLYTEXTA; | |
| LPPOLYTEXTA :: ^POLYTEXTA; | |
| POLYTEXTW :: struct { | |
| x : _c.int, | |
| y : _c.int, | |
| n : UINT, | |
| lpstr : LPCWSTR, | |
| uiFlags : UINT, | |
| rcl : RECT, | |
| pdx : ^_c.int, | |
| }; | |
| PPOLYTEXTW :: ^POLYTEXTW; | |
| NPPOLYTEXTW :: ^POLYTEXTW; | |
| LPPOLYTEXTW :: ^POLYTEXTW; | |
| POLYTEXT :: POLYTEXTA; | |
| PPOLYTEXT :: PPOLYTEXTA; | |
| NPPOLYTEXT :: NPPOLYTEXTA; | |
| LPPOLYTEXT :: LPPOLYTEXTA; | |
| FIXED :: struct { | |
| fract : WORD, | |
| value : _c.short, | |
| }; | |
| MAT2 :: struct { | |
| eM11 : FIXED, | |
| eM12 : FIXED, | |
| eM21 : FIXED, | |
| eM22 : FIXED, | |
| }; | |
| LPMAT2 :: ^MAT2; | |
| GLYPHMETRICS :: struct { | |
| gmBlackBoxX : UINT, | |
| gmBlackBoxY : UINT, | |
| gmptGlyphOrigin : POINT, | |
| gmCellIncX : _c.short, | |
| gmCellIncY : _c.short, | |
| }; | |
| LPGLYPHMETRICS :: ^GLYPHMETRICS; | |
| POINTFX :: struct { | |
| x : FIXED, | |
| y : FIXED, | |
| }; | |
| LPPOINTFX :: ^POINTFX; | |
| TTPOLYCURVE :: struct { | |
| wType : WORD, | |
| cpfx : WORD, | |
| apfx : [1]POINTFX, | |
| }; | |
| LPTTPOLYCURVE :: ^TTPOLYCURVE; | |
| TTPOLYGONHEADER :: struct { | |
| cb : DWORD, | |
| dwType : DWORD, | |
| pfxStart : POINTFX, | |
| }; | |
| LPTTPOLYGONHEADER :: ^TTPOLYGONHEADER; | |
| GCP_RESULTSA :: struct { | |
| lStructSize : DWORD, | |
| lpOutString : LPSTR, | |
| lpOrder : ^UINT, | |
| lpDx : ^_c.int, | |
| lpCaretPos : ^_c.int, | |
| lpClass : LPSTR, | |
| lpGlyphs : LPWSTR, | |
| nGlyphs : UINT, | |
| nMaxFit : _c.int, | |
| }; | |
| LPGCP_RESULTSA :: ^GCP_RESULTSA; | |
| GCP_RESULTSW :: struct { | |
| lStructSize : DWORD, | |
| lpOutString : LPWSTR, | |
| lpOrder : ^UINT, | |
| lpDx : ^_c.int, | |
| lpCaretPos : ^_c.int, | |
| lpClass : LPSTR, | |
| lpGlyphs : LPWSTR, | |
| nGlyphs : UINT, | |
| nMaxFit : _c.int, | |
| }; | |
| LPGCP_RESULTSW :: ^GCP_RESULTSW; | |
| GCP_RESULTS :: GCP_RESULTSA; | |
| LPGCP_RESULTS :: LPGCP_RESULTSA; | |
| RASTERIZER_STATUS :: struct { | |
| nSize : _c.short, | |
| wFlags : _c.short, | |
| nLanguageID : _c.short, | |
| }; | |
| LPRASTERIZER_STATUS :: ^RASTERIZER_STATUS; | |
| PIXELFORMATDESCRIPTOR :: struct { | |
| nSize : WORD, | |
| nVersion : WORD, | |
| dwFlags : DWORD, | |
| iPixelType : BYTE, | |
| cColorBits : BYTE, | |
| cRedBits : BYTE, | |
| cRedShift : BYTE, | |
| cGreenBits : BYTE, | |
| cGreenShift : BYTE, | |
| cBlueBits : BYTE, | |
| cBlueShift : BYTE, | |
| cAlphaBits : BYTE, | |
| cAlphaShift : BYTE, | |
| cAccumBits : BYTE, | |
| cAccumRedBits : BYTE, | |
| cAccumGreenBits : BYTE, | |
| cAccumBlueBits : BYTE, | |
| cAccumAlphaBits : BYTE, | |
| cDepthBits : BYTE, | |
| cStencilBits : BYTE, | |
| cAuxBuffers : BYTE, | |
| iLayerType : BYTE, | |
| bReserved : BYTE, | |
| dwLayerMask : DWORD, | |
| dwVisibleMask : DWORD, | |
| dwDamageMask : DWORD, | |
| }; | |
| PPIXELFORMATDESCRIPTOR :: ^PIXELFORMATDESCRIPTOR; | |
| LPPIXELFORMATDESCRIPTOR :: ^PIXELFORMATDESCRIPTOR; | |
| OLDFONTENUMPROCA :: (proc "stdcall" (^LOGFONTA, ^TEXTMETRICA, DWORD, LPARAM) -> _c.int); | |
| OLDFONTENUMPROCW :: (proc "stdcall" (^LOGFONTW, ^TEXTMETRICW, DWORD, LPARAM) -> _c.int); | |
| FONTENUMPROCA :: OLDFONTENUMPROCA; | |
| FONTENUMPROCW :: OLDFONTENUMPROCW; | |
| FONTENUMPROC :: FONTENUMPROCA; | |
| GOBJENUMPROC :: (proc "stdcall" (LPVOID, LPARAM) -> _c.int); | |
| LINEDDAPROC :: proc "stdcall" (_c.int, _c.int, LPARAM); | |
| LPFNDEVMODE :: (proc "stdcall" (HWND, HMODULE, LPDEVMODE, LPSTR, LPSTR, LPDEVMODE, LPSTR, UINT) -> UINT); | |
| LPFNDEVCAPS :: (proc "stdcall" (LPSTR, LPSTR, UINT, LPSTR, LPDEVMODE) -> DWORD); | |
| WCRANGE :: struct { | |
| wcLow : WCHAR, | |
| cGlyphs : USHORT, | |
| }; | |
| PWCRANGE :: ^WCRANGE; | |
| LPWCRANGE :: ^WCRANGE; | |
| GLYPHSET :: struct { | |
| cbThis : DWORD, | |
| flAccel : DWORD, | |
| cGlyphsSupported : DWORD, | |
| cRanges : DWORD, | |
| ranges : [1]WCRANGE, | |
| }; | |
| PGLYPHSET :: ^GLYPHSET; | |
| LPGLYPHSET :: ^GLYPHSET; | |
| DESIGNVECTOR :: struct { | |
| dvReserved : DWORD, | |
| dvNumAxes : DWORD, | |
| dvValues : [16]LONG, | |
| }; | |
| PDESIGNVECTOR :: ^DESIGNVECTOR; | |
| LPDESIGNVECTOR :: ^DESIGNVECTOR; | |
| AXISINFOA :: struct { | |
| axMinValue : LONG, | |
| axMaxValue : LONG, | |
| axAxisName : [16]BYTE, | |
| }; | |
| PAXISINFOA :: ^AXISINFOA; | |
| LPAXISINFOA :: ^AXISINFOA; | |
| AXISINFOW :: struct { | |
| axMinValue : LONG, | |
| axMaxValue : LONG, | |
| axAxisName : [16]WCHAR, | |
| }; | |
| PAXISINFOW :: ^AXISINFOW; | |
| LPAXISINFOW :: ^AXISINFOW; | |
| AXISINFO :: AXISINFOA; | |
| PAXISINFO :: PAXISINFOA; | |
| LPAXISINFO :: LPAXISINFOA; | |
| AXESLISTA :: struct { | |
| axlReserved : DWORD, | |
| axlNumAxes : DWORD, | |
| axlAxisInfo : [16]AXISINFOA, | |
| }; | |
| PAXESLISTA :: ^AXESLISTA; | |
| LPAXESLISTA :: ^AXESLISTA; | |
| AXESLISTW :: struct { | |
| axlReserved : DWORD, | |
| axlNumAxes : DWORD, | |
| axlAxisInfo : [16]AXISINFOW, | |
| }; | |
| PAXESLISTW :: ^AXESLISTW; | |
| LPAXESLISTW :: ^AXESLISTW; | |
| AXESLIST :: AXESLISTA; | |
| PAXESLIST :: PAXESLISTA; | |
| LPAXESLIST :: LPAXESLISTA; | |
| ENUMLOGFONTEXDVA :: struct { | |
| elfEnumLogfontEx : ENUMLOGFONTEXA, | |
| elfDesignVector : DESIGNVECTOR, | |
| }; | |
| PENUMLOGFONTEXDVA :: ^ENUMLOGFONTEXDVA; | |
| LPENUMLOGFONTEXDVA :: ^ENUMLOGFONTEXDVA; | |
| ENUMLOGFONTEXDVW :: struct { | |
| elfEnumLogfontEx : ENUMLOGFONTEXW, | |
| elfDesignVector : DESIGNVECTOR, | |
| }; | |
| PENUMLOGFONTEXDVW :: ^ENUMLOGFONTEXDVW; | |
| LPENUMLOGFONTEXDVW :: ^ENUMLOGFONTEXDVW; | |
| ENUMLOGFONTEXDV :: ENUMLOGFONTEXDVA; | |
| PENUMLOGFONTEXDV :: PENUMLOGFONTEXDVA; | |
| LPENUMLOGFONTEXDV :: LPENUMLOGFONTEXDVA; | |
| ENUMTEXTMETRICA :: struct { | |
| etmNewTextMetricEx : NEWTEXTMETRICEXA, | |
| etmAxesList : AXESLISTA, | |
| }; | |
| PENUMTEXTMETRICA :: ^ENUMTEXTMETRICA; | |
| LPENUMTEXTMETRICA :: ^ENUMTEXTMETRICA; | |
| ENUMTEXTMETRICW :: struct { | |
| etmNewTextMetricEx : NEWTEXTMETRICEXW, | |
| etmAxesList : AXESLISTW, | |
| }; | |
| PENUMTEXTMETRICW :: ^ENUMTEXTMETRICW; | |
| LPENUMTEXTMETRICW :: ^ENUMTEXTMETRICW; | |
| ENUMTEXTMETRIC :: ENUMTEXTMETRICA; | |
| PENUMTEXTMETRIC :: PENUMTEXTMETRICA; | |
| LPENUMTEXTMETRIC :: LPENUMTEXTMETRICA; | |
| COLOR16 :: USHORT; | |
| TRIVERTEX :: struct { | |
| x : LONG, | |
| y : LONG, | |
| Red : COLOR16, | |
| Green : COLOR16, | |
| Blue : COLOR16, | |
| Alpha : COLOR16, | |
| }; | |
| PTRIVERTEX :: ^TRIVERTEX; | |
| LPTRIVERTEX :: ^TRIVERTEX; | |
| GRADIENT_TRIANGLE :: struct { | |
| Vertex1 : ULONG, | |
| Vertex2 : ULONG, | |
| Vertex3 : ULONG, | |
| }; | |
| PGRADIENT_TRIANGLE :: ^GRADIENT_TRIANGLE; | |
| LPGRADIENT_TRIANGLE :: ^GRADIENT_TRIANGLE; | |
| GRADIENT_RECT :: struct { | |
| UpperLeft : ULONG, | |
| LowerRight : ULONG, | |
| }; | |
| PGRADIENT_RECT :: ^GRADIENT_RECT; | |
| LPGRADIENT_RECT :: ^GRADIENT_RECT; | |
| BLENDFUNCTION :: struct { | |
| BlendOp : BYTE, | |
| BlendFlags : BYTE, | |
| SourceConstantAlpha : BYTE, | |
| AlphaFormat : BYTE, | |
| }; | |
| PBLENDFUNCTION :: ^BLENDFUNCTION; | |
| MFENUMPROC :: (proc "stdcall" (hdc : HDC, lpht : ^HANDLETABLE, lpMR : ^METARECORD, nObj : _c.int, param : LPARAM) -> _c.int); | |
| ENHMFENUMPROC :: (proc "stdcall" (hdc : HDC, lpht : ^HANDLETABLE, lpmr : ^ENHMETARECORD, nHandles : _c.int, data : LPARAM) -> _c.int); | |
| DIBSECTION :: struct { | |
| dsBm : BITMAP, | |
| dsBmih : BITMAPINFOHEADER, | |
| dsBitfields : [3]DWORD, | |
| dshSection : HANDLE, | |
| dsOffset : DWORD, | |
| }; | |
| LPDIBSECTION :: ^DIBSECTION; | |
| PDIBSECTION :: ^DIBSECTION; | |
| COLORADJUSTMENT :: struct { | |
| caSize : WORD, | |
| caFlags : WORD, | |
| caIlluminantIndex : WORD, | |
| caRedGamma : WORD, | |
| caGreenGamma : WORD, | |
| caBlueGamma : WORD, | |
| caReferenceBlack : WORD, | |
| caReferenceWhite : WORD, | |
| caContrast : SHORT, | |
| caBrightness : SHORT, | |
| caColorfulness : SHORT, | |
| caRedGreenTint : SHORT, | |
| }; | |
| PCOLORADJUSTMENT :: ^COLORADJUSTMENT; | |
| LPCOLORADJUSTMENT :: ^COLORADJUSTMENT; | |
| ABORTPROC :: (proc "stdcall" (HDC, _c.int) -> BOOL); | |
| DOCINFOA :: struct { | |
| cbSize : _c.int, | |
| lpszDocName : LPCSTR, | |
| lpszOutput : LPCSTR, | |
| lpszDatatype : LPCSTR, | |
| fwType : DWORD, | |
| }; | |
| LPDOCINFOA :: ^DOCINFOA; | |
| DOCINFOW :: struct { | |
| cbSize : _c.int, | |
| lpszDocName : LPCWSTR, | |
| lpszOutput : LPCWSTR, | |
| lpszDatatype : LPCWSTR, | |
| fwType : DWORD, | |
| }; | |
| LPDOCINFOW :: ^DOCINFOW; | |
| DOCINFO :: DOCINFOA; | |
| LPDOCINFO :: LPDOCINFOA; | |
| KERNINGPAIR :: struct { | |
| wFirst : WORD, | |
| wSecond : WORD, | |
| iKernAmount : _c.int, | |
| }; | |
| LPKERNINGPAIR :: ^KERNINGPAIR; | |
| ICMENUMPROCA :: (proc "stdcall" (LPSTR, LPARAM) -> _c.int); | |
| ICMENUMPROCW :: (proc "stdcall" (LPWSTR, LPARAM) -> _c.int); | |
| EMR :: struct { | |
| iType : DWORD, | |
| nSize : DWORD, | |
| }; | |
| PEMR :: ^EMR; | |
| EMRTEXT :: struct { | |
| ptlReference : POINTL, | |
| nChars : DWORD, | |
| offString : DWORD, | |
| fOptions : DWORD, | |
| rcl : RECTL, | |
| offDx : DWORD, | |
| }; | |
| PEMRTEXT :: ^EMRTEXT; | |
| EMRABORTPATH :: struct { | |
| emr : EMR, | |
| }; | |
| PEMRABORTPATH :: ^EMRABORTPATH; | |
| EMRBEGINPATH :: struct { | |
| emr : EMR, | |
| }; | |
| PEMRBEGINPATH :: ^EMRBEGINPATH; | |
| EMRENDPATH :: struct { | |
| emr : EMR, | |
| }; | |
| PEMRENDPATH :: ^EMRENDPATH; | |
| EMRCLOSEFIGURE :: struct { | |
| emr : EMR, | |
| }; | |
| PEMRCLOSEFIGURE :: ^EMRCLOSEFIGURE; | |
| EMRFLATTENPATH :: struct { | |
| emr : EMR, | |
| }; | |
| PEMRFLATTENPATH :: ^EMRFLATTENPATH; | |
| EMRWIDENPATH :: struct { | |
| emr : EMR, | |
| }; | |
| PEMRWIDENPATH :: ^EMRWIDENPATH; | |
| EMRSETMETARGN :: struct { | |
| emr : EMR, | |
| }; | |
| PEMRSETMETARGN :: ^EMRSETMETARGN; | |
| EMRSAVEDC :: struct { | |
| emr : EMR, | |
| }; | |
| PEMRSAVEDC :: ^EMRSAVEDC; | |
| EMRREALIZEPALETTE :: struct { | |
| emr : EMR, | |
| }; | |
| PEMRREALIZEPALETTE :: ^EMRREALIZEPALETTE; | |
| EMRSELECTCLIPPATH :: struct { | |
| emr : EMR, | |
| iMode : DWORD, | |
| }; | |
| PEMRSELECTCLIPPATH :: ^EMRSELECTCLIPPATH; | |
| EMRSETBKMODE :: struct { | |
| emr : EMR, | |
| iMode : DWORD, | |
| }; | |
| PEMRSETBKMODE :: ^EMRSETBKMODE; | |
| EMRSETMAPMODE :: struct { | |
| emr : EMR, | |
| iMode : DWORD, | |
| }; | |
| PEMRSETMAPMODE :: ^EMRSETMAPMODE; | |
| EMRSETLAYOUT :: struct { | |
| emr : EMR, | |
| iMode : DWORD, | |
| }; | |
| PEMRSETLAYOUT :: ^EMRSETLAYOUT; | |
| EMRSETPOLYFILLMODE :: struct { | |
| emr : EMR, | |
| iMode : DWORD, | |
| }; | |
| PEMRSETPOLYFILLMODE :: ^EMRSETPOLYFILLMODE; | |
| EMRSETROP2 :: struct { | |
| emr : EMR, | |
| iMode : DWORD, | |
| }; | |
| PEMRSETROP2 :: ^EMRSETROP2; | |
| EMRSETSTRETCHBLTMODE :: struct { | |
| emr : EMR, | |
| iMode : DWORD, | |
| }; | |
| PEMRSETSTRETCHBLTMODE :: ^EMRSETSTRETCHBLTMODE; | |
| EMRSETICMMODE :: struct { | |
| emr : EMR, | |
| iMode : DWORD, | |
| }; | |
| PEMRSETICMMODE :: ^EMRSETICMMODE; | |
| EMRSETTEXTALIGN :: struct { | |
| emr : EMR, | |
| iMode : DWORD, | |
| }; | |
| PEMRSETTEXTALIGN :: ^EMRSETTEXTALIGN; | |
| EMRSETMITERLIMIT :: struct { | |
| emr : EMR, | |
| eMiterLimit : FLOAT, | |
| }; | |
| PEMRSETMITERLIMIT :: ^EMRSETMITERLIMIT; | |
| EMRRESTOREDC :: struct { | |
| emr : EMR, | |
| iRelative : LONG, | |
| }; | |
| PEMRRESTOREDC :: ^EMRRESTOREDC; | |
| EMRSETARCDIRECTION :: struct { | |
| emr : EMR, | |
| iArcDirection : DWORD, | |
| }; | |
| PEMRSETARCDIRECTION :: ^EMRSETARCDIRECTION; | |
| EMRSETMAPPERFLAGS :: struct { | |
| emr : EMR, | |
| dwFlags : DWORD, | |
| }; | |
| PEMRSETMAPPERFLAGS :: ^EMRSETMAPPERFLAGS; | |
| EMRSETBKCOLOR :: struct { | |
| emr : EMR, | |
| crColor : COLORREF, | |
| }; | |
| PEMRSETBKCOLOR :: ^EMRSETBKCOLOR; | |
| EMRSETTEXTCOLOR :: struct { | |
| emr : EMR, | |
| crColor : COLORREF, | |
| }; | |
| PEMRSETTEXTCOLOR :: ^EMRSETTEXTCOLOR; | |
| EMRSELECTOBJECT :: struct { | |
| emr : EMR, | |
| ihObject : DWORD, | |
| }; | |
| PEMRSELECTOBJECT :: ^EMRSELECTOBJECT; | |
| EMRDELETEOBJECT :: struct { | |
| emr : EMR, | |
| ihObject : DWORD, | |
| }; | |
| PEMRDELETEOBJECT :: ^EMRDELETEOBJECT; | |
| EMRSELECTPALETTE :: struct { | |
| emr : EMR, | |
| ihPal : DWORD, | |
| }; | |
| PEMRSELECTPALETTE :: ^EMRSELECTPALETTE; | |
| EMRRESIZEPALETTE :: struct { | |
| emr : EMR, | |
| ihPal : DWORD, | |
| cEntries : DWORD, | |
| }; | |
| PEMRRESIZEPALETTE :: ^EMRRESIZEPALETTE; | |
| EMRSETPALETTEENTRIES :: struct { | |
| emr : EMR, | |
| ihPal : DWORD, | |
| iStart : DWORD, | |
| cEntries : DWORD, | |
| aPalEntries : [1]PALETTEENTRY, | |
| }; | |
| PEMRSETPALETTEENTRIES :: ^EMRSETPALETTEENTRIES; | |
| EMRSETCOLORADJUSTMENT :: struct { | |
| emr : EMR, | |
| ColorAdjustment : COLORADJUSTMENT, | |
| }; | |
| PEMRSETCOLORADJUSTMENT :: ^EMRSETCOLORADJUSTMENT; | |
| EMRGDICOMMENT :: struct { | |
| emr : EMR, | |
| cbData : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PEMRGDICOMMENT :: ^EMRGDICOMMENT; | |
| EMREOF :: struct { | |
| emr : EMR, | |
| nPalEntries : DWORD, | |
| offPalEntries : DWORD, | |
| nSizeLast : DWORD, | |
| }; | |
| PEMREOF :: ^EMREOF; | |
| EMRLINETO :: struct { | |
| emr : EMR, | |
| ptl : POINTL, | |
| }; | |
| PEMRLINETO :: ^EMRLINETO; | |
| EMRMOVETOEX :: struct { | |
| emr : EMR, | |
| ptl : POINTL, | |
| }; | |
| PEMRMOVETOEX :: ^EMRMOVETOEX; | |
| EMROFFSETCLIPRGN :: struct { | |
| emr : EMR, | |
| ptlOffset : POINTL, | |
| }; | |
| PEMROFFSETCLIPRGN :: ^EMROFFSETCLIPRGN; | |
| EMRFILLPATH :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| }; | |
| PEMRFILLPATH :: ^EMRFILLPATH; | |
| EMRSTROKEANDFILLPATH :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| }; | |
| PEMRSTROKEANDFILLPATH :: ^EMRSTROKEANDFILLPATH; | |
| EMRSTROKEPATH :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| }; | |
| PEMRSTROKEPATH :: ^EMRSTROKEPATH; | |
| EMREXCLUDECLIPRECT :: struct { | |
| emr : EMR, | |
| rclClip : RECTL, | |
| }; | |
| PEMREXCLUDECLIPRECT :: ^EMREXCLUDECLIPRECT; | |
| EMRINTERSECTCLIPRECT :: struct { | |
| emr : EMR, | |
| rclClip : RECTL, | |
| }; | |
| PEMRINTERSECTCLIPRECT :: ^EMRINTERSECTCLIPRECT; | |
| EMRSETVIEWPORTORGEX :: struct { | |
| emr : EMR, | |
| ptlOrigin : POINTL, | |
| }; | |
| PEMRSETVIEWPORTORGEX :: ^EMRSETVIEWPORTORGEX; | |
| EMRSETWINDOWORGEX :: struct { | |
| emr : EMR, | |
| ptlOrigin : POINTL, | |
| }; | |
| PEMRSETWINDOWORGEX :: ^EMRSETWINDOWORGEX; | |
| EMRSETBRUSHORGEX :: struct { | |
| emr : EMR, | |
| ptlOrigin : POINTL, | |
| }; | |
| PEMRSETBRUSHORGEX :: ^EMRSETBRUSHORGEX; | |
| EMRSETVIEWPORTEXTEX :: struct { | |
| emr : EMR, | |
| szlExtent : SIZEL, | |
| }; | |
| PEMRSETVIEWPORTEXTEX :: ^EMRSETVIEWPORTEXTEX; | |
| EMRSETWINDOWEXTEX :: struct { | |
| emr : EMR, | |
| szlExtent : SIZEL, | |
| }; | |
| PEMRSETWINDOWEXTEX :: ^EMRSETWINDOWEXTEX; | |
| EMRSCALEVIEWPORTEXTEX :: struct { | |
| emr : EMR, | |
| xNum : LONG, | |
| xDenom : LONG, | |
| yNum : LONG, | |
| yDenom : LONG, | |
| }; | |
| PEMRSCALEVIEWPORTEXTEX :: ^EMRSCALEVIEWPORTEXTEX; | |
| EMRSCALEWINDOWEXTEX :: struct { | |
| emr : EMR, | |
| xNum : LONG, | |
| xDenom : LONG, | |
| yNum : LONG, | |
| yDenom : LONG, | |
| }; | |
| PEMRSCALEWINDOWEXTEX :: ^EMRSCALEWINDOWEXTEX; | |
| EMRSETWORLDTRANSFORM :: struct { | |
| emr : EMR, | |
| xform : XFORM, | |
| }; | |
| PEMRSETWORLDTRANSFORM :: ^EMRSETWORLDTRANSFORM; | |
| EMRMODIFYWORLDTRANSFORM :: struct { | |
| emr : EMR, | |
| xform : XFORM, | |
| iMode : DWORD, | |
| }; | |
| PEMRMODIFYWORLDTRANSFORM :: ^EMRMODIFYWORLDTRANSFORM; | |
| EMRSETPIXELV :: struct { | |
| emr : EMR, | |
| ptlPixel : POINTL, | |
| crColor : COLORREF, | |
| }; | |
| PEMRSETPIXELV :: ^EMRSETPIXELV; | |
| EMREXTFLOODFILL :: struct { | |
| emr : EMR, | |
| ptlStart : POINTL, | |
| crColor : COLORREF, | |
| iMode : DWORD, | |
| }; | |
| PEMREXTFLOODFILL :: ^EMREXTFLOODFILL; | |
| EMRELLIPSE :: struct { | |
| emr : EMR, | |
| rclBox : RECTL, | |
| }; | |
| PEMRELLIPSE :: ^EMRELLIPSE; | |
| EMRRECTANGLE :: struct { | |
| emr : EMR, | |
| rclBox : RECTL, | |
| }; | |
| PEMRRECTANGLE :: ^EMRRECTANGLE; | |
| EMRROUNDRECT :: struct { | |
| emr : EMR, | |
| rclBox : RECTL, | |
| szlCorner : SIZEL, | |
| }; | |
| PEMRROUNDRECT :: ^EMRROUNDRECT; | |
| EMRARC :: struct { | |
| emr : EMR, | |
| rclBox : RECTL, | |
| ptlStart : POINTL, | |
| ptlEnd : POINTL, | |
| }; | |
| PEMRARC :: ^EMRARC; | |
| EMRARCTO :: struct { | |
| emr : EMR, | |
| rclBox : RECTL, | |
| ptlStart : POINTL, | |
| ptlEnd : POINTL, | |
| }; | |
| PEMRARCTO :: ^EMRARCTO; | |
| EMRCHORD :: struct { | |
| emr : EMR, | |
| rclBox : RECTL, | |
| ptlStart : POINTL, | |
| ptlEnd : POINTL, | |
| }; | |
| PEMRCHORD :: ^EMRCHORD; | |
| EMRPIE :: struct { | |
| emr : EMR, | |
| rclBox : RECTL, | |
| ptlStart : POINTL, | |
| ptlEnd : POINTL, | |
| }; | |
| PEMRPIE :: ^EMRPIE; | |
| EMRANGLEARC :: struct { | |
| emr : EMR, | |
| ptlCenter : POINTL, | |
| nRadius : DWORD, | |
| eStartAngle : FLOAT, | |
| eSweepAngle : FLOAT, | |
| }; | |
| PEMRANGLEARC :: ^EMRANGLEARC; | |
| EMRPOLYLINE :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cptl : DWORD, | |
| aptl : [1]POINTL, | |
| }; | |
| PEMRPOLYLINE :: ^EMRPOLYLINE; | |
| EMRPOLYBEZIER :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cptl : DWORD, | |
| aptl : [1]POINTL, | |
| }; | |
| PEMRPOLYBEZIER :: ^EMRPOLYBEZIER; | |
| EMRPOLYGON :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cptl : DWORD, | |
| aptl : [1]POINTL, | |
| }; | |
| PEMRPOLYGON :: ^EMRPOLYGON; | |
| EMRPOLYBEZIERTO :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cptl : DWORD, | |
| aptl : [1]POINTL, | |
| }; | |
| PEMRPOLYBEZIERTO :: ^EMRPOLYBEZIERTO; | |
| EMRPOLYLINETO :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cptl : DWORD, | |
| aptl : [1]POINTL, | |
| }; | |
| PEMRPOLYLINETO :: ^EMRPOLYLINETO; | |
| EMRPOLYLINE16 :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cpts : DWORD, | |
| apts : [1]POINTS, | |
| }; | |
| PEMRPOLYLINE16 :: ^EMRPOLYLINE16; | |
| EMRPOLYBEZIER16 :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cpts : DWORD, | |
| apts : [1]POINTS, | |
| }; | |
| PEMRPOLYBEZIER16 :: ^EMRPOLYBEZIER16; | |
| EMRPOLYGON16 :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cpts : DWORD, | |
| apts : [1]POINTS, | |
| }; | |
| PEMRPOLYGON16 :: ^EMRPOLYGON16; | |
| EMRPOLYBEZIERTO16 :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cpts : DWORD, | |
| apts : [1]POINTS, | |
| }; | |
| PEMRPOLYBEZIERTO16 :: ^EMRPOLYBEZIERTO16; | |
| EMRPOLYLINETO16 :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cpts : DWORD, | |
| apts : [1]POINTS, | |
| }; | |
| PEMRPOLYLINETO16 :: ^EMRPOLYLINETO16; | |
| EMRPOLYDRAW :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cptl : DWORD, | |
| aptl : [1]POINTL, | |
| abTypes : [1]BYTE, | |
| }; | |
| PEMRPOLYDRAW :: ^EMRPOLYDRAW; | |
| EMRPOLYDRAW16 :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cpts : DWORD, | |
| apts : [1]POINTS, | |
| abTypes : [1]BYTE, | |
| }; | |
| PEMRPOLYDRAW16 :: ^EMRPOLYDRAW16; | |
| EMRPOLYPOLYLINE :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| nPolys : DWORD, | |
| cptl : DWORD, | |
| aPolyCounts : [1]DWORD, | |
| aptl : [1]POINTL, | |
| }; | |
| PEMRPOLYPOLYLINE :: ^EMRPOLYPOLYLINE; | |
| EMRPOLYPOLYGON :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| nPolys : DWORD, | |
| cptl : DWORD, | |
| aPolyCounts : [1]DWORD, | |
| aptl : [1]POINTL, | |
| }; | |
| PEMRPOLYPOLYGON :: ^EMRPOLYPOLYGON; | |
| EMRPOLYPOLYLINE16 :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| nPolys : DWORD, | |
| cpts : DWORD, | |
| aPolyCounts : [1]DWORD, | |
| apts : [1]POINTS, | |
| }; | |
| PEMRPOLYPOLYLINE16 :: ^EMRPOLYPOLYLINE16; | |
| EMRPOLYPOLYGON16 :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| nPolys : DWORD, | |
| cpts : DWORD, | |
| aPolyCounts : [1]DWORD, | |
| apts : [1]POINTS, | |
| }; | |
| PEMRPOLYPOLYGON16 :: ^EMRPOLYPOLYGON16; | |
| EMRINVERTRGN :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cbRgnData : DWORD, | |
| RgnData : [1]BYTE, | |
| }; | |
| PEMRINVERTRGN :: ^EMRINVERTRGN; | |
| EMRPAINTRGN :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cbRgnData : DWORD, | |
| RgnData : [1]BYTE, | |
| }; | |
| PEMRPAINTRGN :: ^EMRPAINTRGN; | |
| EMRFILLRGN :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cbRgnData : DWORD, | |
| ihBrush : DWORD, | |
| RgnData : [1]BYTE, | |
| }; | |
| PEMRFILLRGN :: ^EMRFILLRGN; | |
| EMRFRAMERGN :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cbRgnData : DWORD, | |
| ihBrush : DWORD, | |
| szlStroke : SIZEL, | |
| RgnData : [1]BYTE, | |
| }; | |
| PEMRFRAMERGN :: ^EMRFRAMERGN; | |
| EMREXTSELECTCLIPRGN :: struct { | |
| emr : EMR, | |
| cbRgnData : DWORD, | |
| iMode : DWORD, | |
| RgnData : [1]BYTE, | |
| }; | |
| PEMREXTSELECTCLIPRGN :: ^EMREXTSELECTCLIPRGN; | |
| EMREXTTEXTOUTA :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| iGraphicsMode : DWORD, | |
| exScale : FLOAT, | |
| eyScale : FLOAT, | |
| emrtext : EMRTEXT, | |
| }; | |
| PEMREXTTEXTOUTA :: ^EMREXTTEXTOUTA; | |
| EMREXTTEXTOUTW :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| iGraphicsMode : DWORD, | |
| exScale : FLOAT, | |
| eyScale : FLOAT, | |
| emrtext : EMRTEXT, | |
| }; | |
| PEMREXTTEXTOUTW :: ^EMREXTTEXTOUTW; | |
| EMRPOLYTEXTOUTA :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| iGraphicsMode : DWORD, | |
| exScale : FLOAT, | |
| eyScale : FLOAT, | |
| cStrings : LONG, | |
| aemrtext : [1]EMRTEXT, | |
| }; | |
| PEMRPOLYTEXTOUTA :: ^EMRPOLYTEXTOUTA; | |
| EMRPOLYTEXTOUTW :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| iGraphicsMode : DWORD, | |
| exScale : FLOAT, | |
| eyScale : FLOAT, | |
| cStrings : LONG, | |
| aemrtext : [1]EMRTEXT, | |
| }; | |
| PEMRPOLYTEXTOUTW :: ^EMRPOLYTEXTOUTW; | |
| EMRBITBLT :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| xDest : LONG, | |
| yDest : LONG, | |
| cxDest : LONG, | |
| cyDest : LONG, | |
| dwRop : DWORD, | |
| xSrc : LONG, | |
| ySrc : LONG, | |
| xformSrc : XFORM, | |
| crBkColorSrc : COLORREF, | |
| iUsageSrc : DWORD, | |
| offBmiSrc : DWORD, | |
| cbBmiSrc : DWORD, | |
| offBitsSrc : DWORD, | |
| cbBitsSrc : DWORD, | |
| }; | |
| PEMRBITBLT :: ^EMRBITBLT; | |
| EMRSTRETCHBLT :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| xDest : LONG, | |
| yDest : LONG, | |
| cxDest : LONG, | |
| cyDest : LONG, | |
| dwRop : DWORD, | |
| xSrc : LONG, | |
| ySrc : LONG, | |
| xformSrc : XFORM, | |
| crBkColorSrc : COLORREF, | |
| iUsageSrc : DWORD, | |
| offBmiSrc : DWORD, | |
| cbBmiSrc : DWORD, | |
| offBitsSrc : DWORD, | |
| cbBitsSrc : DWORD, | |
| cxSrc : LONG, | |
| cySrc : LONG, | |
| }; | |
| PEMRSTRETCHBLT :: ^EMRSTRETCHBLT; | |
| EMRMASKBLT :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| xDest : LONG, | |
| yDest : LONG, | |
| cxDest : LONG, | |
| cyDest : LONG, | |
| dwRop : DWORD, | |
| xSrc : LONG, | |
| ySrc : LONG, | |
| xformSrc : XFORM, | |
| crBkColorSrc : COLORREF, | |
| iUsageSrc : DWORD, | |
| offBmiSrc : DWORD, | |
| cbBmiSrc : DWORD, | |
| offBitsSrc : DWORD, | |
| cbBitsSrc : DWORD, | |
| xMask : LONG, | |
| yMask : LONG, | |
| iUsageMask : DWORD, | |
| offBmiMask : DWORD, | |
| cbBmiMask : DWORD, | |
| offBitsMask : DWORD, | |
| cbBitsMask : DWORD, | |
| }; | |
| PEMRMASKBLT :: ^EMRMASKBLT; | |
| EMRPLGBLT :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| aptlDest : [3]POINTL, | |
| xSrc : LONG, | |
| ySrc : LONG, | |
| cxSrc : LONG, | |
| cySrc : LONG, | |
| xformSrc : XFORM, | |
| crBkColorSrc : COLORREF, | |
| iUsageSrc : DWORD, | |
| offBmiSrc : DWORD, | |
| cbBmiSrc : DWORD, | |
| offBitsSrc : DWORD, | |
| cbBitsSrc : DWORD, | |
| xMask : LONG, | |
| yMask : LONG, | |
| iUsageMask : DWORD, | |
| offBmiMask : DWORD, | |
| cbBmiMask : DWORD, | |
| offBitsMask : DWORD, | |
| cbBitsMask : DWORD, | |
| }; | |
| PEMRPLGBLT :: ^EMRPLGBLT; | |
| EMRSETDIBITSTODEVICE :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| xDest : LONG, | |
| yDest : LONG, | |
| xSrc : LONG, | |
| ySrc : LONG, | |
| cxSrc : LONG, | |
| cySrc : LONG, | |
| offBmiSrc : DWORD, | |
| cbBmiSrc : DWORD, | |
| offBitsSrc : DWORD, | |
| cbBitsSrc : DWORD, | |
| iUsageSrc : DWORD, | |
| iStartScan : DWORD, | |
| cScans : DWORD, | |
| }; | |
| PEMRSETDIBITSTODEVICE :: ^EMRSETDIBITSTODEVICE; | |
| EMRSTRETCHDIBITS :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| xDest : LONG, | |
| yDest : LONG, | |
| xSrc : LONG, | |
| ySrc : LONG, | |
| cxSrc : LONG, | |
| cySrc : LONG, | |
| offBmiSrc : DWORD, | |
| cbBmiSrc : DWORD, | |
| offBitsSrc : DWORD, | |
| cbBitsSrc : DWORD, | |
| iUsageSrc : DWORD, | |
| dwRop : DWORD, | |
| cxDest : LONG, | |
| cyDest : LONG, | |
| }; | |
| PEMRSTRETCHDIBITS :: ^EMRSTRETCHDIBITS; | |
| EMREXTCREATEFONTINDIRECTW :: struct { | |
| emr : EMR, | |
| ihFont : DWORD, | |
| elfw : EXTLOGFONTW, | |
| }; | |
| PEMREXTCREATEFONTINDIRECTW :: ^EMREXTCREATEFONTINDIRECTW; | |
| EMRCREATEPALETTE :: struct { | |
| emr : EMR, | |
| ihPal : DWORD, | |
| lgpl : LOGPALETTE, | |
| }; | |
| PEMRCREATEPALETTE :: ^EMRCREATEPALETTE; | |
| EMRCREATEPEN :: struct { | |
| emr : EMR, | |
| ihPen : DWORD, | |
| lopn : LOGPEN, | |
| }; | |
| PEMRCREATEPEN :: ^EMRCREATEPEN; | |
| EMREXTCREATEPEN :: struct { | |
| emr : EMR, | |
| ihPen : DWORD, | |
| offBmi : DWORD, | |
| cbBmi : DWORD, | |
| offBits : DWORD, | |
| cbBits : DWORD, | |
| elp : EXTLOGPEN32, | |
| }; | |
| PEMREXTCREATEPEN :: ^EMREXTCREATEPEN; | |
| EMRCREATEBRUSHINDIRECT :: struct { | |
| emr : EMR, | |
| ihBrush : DWORD, | |
| lb : LOGBRUSH32, | |
| }; | |
| PEMRCREATEBRUSHINDIRECT :: ^EMRCREATEBRUSHINDIRECT; | |
| EMRCREATEMONOBRUSH :: struct { | |
| emr : EMR, | |
| ihBrush : DWORD, | |
| iUsage : DWORD, | |
| offBmi : DWORD, | |
| cbBmi : DWORD, | |
| offBits : DWORD, | |
| cbBits : DWORD, | |
| }; | |
| PEMRCREATEMONOBRUSH :: ^EMRCREATEMONOBRUSH; | |
| EMRCREATEDIBPATTERNBRUSHPT :: struct { | |
| emr : EMR, | |
| ihBrush : DWORD, | |
| iUsage : DWORD, | |
| offBmi : DWORD, | |
| cbBmi : DWORD, | |
| offBits : DWORD, | |
| cbBits : DWORD, | |
| }; | |
| PEMRCREATEDIBPATTERNBRUSHPT :: ^EMRCREATEDIBPATTERNBRUSHPT; | |
| EMRFORMAT :: struct { | |
| dSignature : DWORD, | |
| nVersion : DWORD, | |
| cbData : DWORD, | |
| offData : DWORD, | |
| }; | |
| PEMRFORMAT :: ^EMRFORMAT; | |
| EMRGLSRECORD :: struct { | |
| emr : EMR, | |
| cbData : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PEMRGLSRECORD :: ^EMRGLSRECORD; | |
| EMRGLSBOUNDEDRECORD :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| cbData : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PEMRGLSBOUNDEDRECORD :: ^EMRGLSBOUNDEDRECORD; | |
| EMRPIXELFORMAT :: struct { | |
| emr : EMR, | |
| pfd : PIXELFORMATDESCRIPTOR, | |
| }; | |
| PEMRPIXELFORMAT :: ^EMRPIXELFORMAT; | |
| EMRCREATECOLORSPACE :: struct { | |
| emr : EMR, | |
| ihCS : DWORD, | |
| lcs : LOGCOLORSPACEA, | |
| }; | |
| PEMRCREATECOLORSPACE :: ^EMRCREATECOLORSPACE; | |
| EMRSETCOLORSPACE :: struct { | |
| emr : EMR, | |
| ihCS : DWORD, | |
| }; | |
| PEMRSETCOLORSPACE :: ^EMRSETCOLORSPACE; | |
| EMRSELECTCOLORSPACE :: struct { | |
| emr : EMR, | |
| ihCS : DWORD, | |
| }; | |
| PEMRSELECTCOLORSPACE :: ^EMRSELECTCOLORSPACE; | |
| EMRDELETECOLORSPACE :: struct { | |
| emr : EMR, | |
| ihCS : DWORD, | |
| }; | |
| PEMRDELETECOLORSPACE :: ^EMRDELETECOLORSPACE; | |
| EMREXTESCAPE :: struct { | |
| emr : EMR, | |
| iEscape : INT, | |
| cbEscData : INT, | |
| EscData : [1]BYTE, | |
| }; | |
| PEMREXTESCAPE :: ^EMREXTESCAPE; | |
| EMRDRAWESCAPE :: struct { | |
| emr : EMR, | |
| iEscape : INT, | |
| cbEscData : INT, | |
| EscData : [1]BYTE, | |
| }; | |
| PEMRDRAWESCAPE :: ^EMRDRAWESCAPE; | |
| EMRNAMEDESCAPE :: struct { | |
| emr : EMR, | |
| iEscape : INT, | |
| cbDriver : INT, | |
| cbEscData : INT, | |
| EscData : [1]BYTE, | |
| }; | |
| PEMRNAMEDESCAPE :: ^EMRNAMEDESCAPE; | |
| EMRSETICMPROFILE :: struct { | |
| emr : EMR, | |
| dwFlags : DWORD, | |
| cbName : DWORD, | |
| cbData : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PEMRSETICMPROFILE :: ^EMRSETICMPROFILE; | |
| EMRSETICMPROFILEA :: struct { | |
| emr : EMR, | |
| dwFlags : DWORD, | |
| cbName : DWORD, | |
| cbData : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PEMRSETICMPROFILEA :: ^EMRSETICMPROFILEA; | |
| EMRSETICMPROFILEW :: struct { | |
| emr : EMR, | |
| dwFlags : DWORD, | |
| cbName : DWORD, | |
| cbData : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PEMRSETICMPROFILEW :: ^EMRSETICMPROFILEW; | |
| EMRCREATECOLORSPACEW :: struct { | |
| emr : EMR, | |
| ihCS : DWORD, | |
| lcs : LOGCOLORSPACEW, | |
| dwFlags : DWORD, | |
| cbData : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PEMRCREATECOLORSPACEW :: ^EMRCREATECOLORSPACEW; | |
| EMRCOLORMATCHTOTARGET :: struct { | |
| emr : EMR, | |
| dwAction : DWORD, | |
| dwFlags : DWORD, | |
| cbName : DWORD, | |
| cbData : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PEMRCOLORMATCHTOTARGET :: ^EMRCOLORMATCHTOTARGET; | |
| EMRCOLORCORRECTPALETTE :: struct { | |
| emr : EMR, | |
| ihPalette : DWORD, | |
| nFirstEntry : DWORD, | |
| nPalEntries : DWORD, | |
| nReserved : DWORD, | |
| }; | |
| PEMRCOLORCORRECTPALETTE :: ^EMRCOLORCORRECTPALETTE; | |
| EMRALPHABLEND :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| xDest : LONG, | |
| yDest : LONG, | |
| cxDest : LONG, | |
| cyDest : LONG, | |
| dwRop : DWORD, | |
| xSrc : LONG, | |
| ySrc : LONG, | |
| xformSrc : XFORM, | |
| crBkColorSrc : COLORREF, | |
| iUsageSrc : DWORD, | |
| offBmiSrc : DWORD, | |
| cbBmiSrc : DWORD, | |
| offBitsSrc : DWORD, | |
| cbBitsSrc : DWORD, | |
| cxSrc : LONG, | |
| cySrc : LONG, | |
| }; | |
| PEMRALPHABLEND :: ^EMRALPHABLEND; | |
| EMRGRADIENTFILL :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| nVer : DWORD, | |
| nTri : DWORD, | |
| ulMode : ULONG, | |
| Ver : [1]TRIVERTEX, | |
| }; | |
| PEMRGRADIENTFILL :: ^EMRGRADIENTFILL; | |
| EMRTRANSPARENTBLT :: struct { | |
| emr : EMR, | |
| rclBounds : RECTL, | |
| xDest : LONG, | |
| yDest : LONG, | |
| cxDest : LONG, | |
| cyDest : LONG, | |
| dwRop : DWORD, | |
| xSrc : LONG, | |
| ySrc : LONG, | |
| xformSrc : XFORM, | |
| crBkColorSrc : COLORREF, | |
| iUsageSrc : DWORD, | |
| offBmiSrc : DWORD, | |
| cbBmiSrc : DWORD, | |
| offBitsSrc : DWORD, | |
| cbBitsSrc : DWORD, | |
| cxSrc : LONG, | |
| cySrc : LONG, | |
| }; | |
| PEMRTRANSPARENTBLT :: ^EMRTRANSPARENTBLT; | |
| POINTFLOAT :: struct { | |
| x : FLOAT, | |
| y : FLOAT, | |
| }; | |
| PPOINTFLOAT :: ^POINTFLOAT; | |
| GLYPHMETRICSFLOAT :: struct { | |
| gmfBlackBoxX : FLOAT, | |
| gmfBlackBoxY : FLOAT, | |
| gmfptGlyphOrigin : POINTFLOAT, | |
| gmfCellIncX : FLOAT, | |
| gmfCellIncY : FLOAT, | |
| }; | |
| PGLYPHMETRICSFLOAT :: ^GLYPHMETRICSFLOAT; | |
| LPGLYPHMETRICSFLOAT :: ^GLYPHMETRICSFLOAT; | |
| LAYERPLANEDESCRIPTOR :: struct { | |
| nSize : WORD, | |
| nVersion : WORD, | |
| dwFlags : DWORD, | |
| iPixelType : BYTE, | |
| cColorBits : BYTE, | |
| cRedBits : BYTE, | |
| cRedShift : BYTE, | |
| cGreenBits : BYTE, | |
| cGreenShift : BYTE, | |
| cBlueBits : BYTE, | |
| cBlueShift : BYTE, | |
| cAlphaBits : BYTE, | |
| cAlphaShift : BYTE, | |
| cAccumBits : BYTE, | |
| cAccumRedBits : BYTE, | |
| cAccumGreenBits : BYTE, | |
| cAccumBlueBits : BYTE, | |
| cAccumAlphaBits : BYTE, | |
| cDepthBits : BYTE, | |
| cStencilBits : BYTE, | |
| cAuxBuffers : BYTE, | |
| iLayerPlane : BYTE, | |
| bReserved : BYTE, | |
| crTransparent : COLORREF, | |
| }; | |
| PLAYERPLANEDESCRIPTOR :: ^LAYERPLANEDESCRIPTOR; | |
| LPLAYERPLANEDESCRIPTOR :: ^LAYERPLANEDESCRIPTOR; | |
| WGLSWAP :: struct { | |
| hdc : HDC, | |
| uiFlags : UINT, | |
| }; | |
| PWGLSWAP :: ^WGLSWAP; | |
| LPWGLSWAP :: ^WGLSWAP; | |
| HDWP :: HANDLE; | |
| LPMENUTEMPLATEA :: PVOID; | |
| LPMENUTEMPLATEW :: PVOID; | |
| LPMENUTEMPLATE :: LPMENUTEMPLATEA; | |
| WNDPROC :: (proc "stdcall" (HWND, UINT, WPARAM, LPARAM) -> LRESULT); | |
| DLGPROC :: (proc "stdcall" (HWND, UINT, WPARAM, LPARAM) -> INT_PTR); | |
| TIMERPROC :: proc "stdcall" (HWND, UINT, UINT_PTR, DWORD); | |
| GRAYSTRINGPROC :: (proc "stdcall" (HDC, LPARAM, _c.int) -> BOOL); | |
| WNDENUMPROC :: (proc "stdcall" (HWND, LPARAM) -> BOOL); | |
| HOOKPROC :: (proc "stdcall" (code : _c.int, wParam : WPARAM, lParam : LPARAM) -> LRESULT); | |
| SENDASYNCPROC :: proc "stdcall" (HWND, UINT, ULONG_PTR, LRESULT); | |
| PROPENUMPROCA :: (proc "stdcall" (HWND, LPCSTR, HANDLE) -> BOOL); | |
| PROPENUMPROCW :: (proc "stdcall" (HWND, LPCWSTR, HANDLE) -> BOOL); | |
| PROPENUMPROCEXA :: (proc "stdcall" (HWND, LPSTR, HANDLE, ULONG_PTR) -> BOOL); | |
| PROPENUMPROCEXW :: (proc "stdcall" (HWND, LPWSTR, HANDLE, ULONG_PTR) -> BOOL); | |
| EDITWORDBREAKPROCA :: (proc "stdcall" (lpch : LPSTR, ichCurrent : _c.int, cch : _c.int, code : _c.int) -> _c.int); | |
| EDITWORDBREAKPROCW :: (proc "stdcall" (lpch : LPWSTR, ichCurrent : _c.int, cch : _c.int, code : _c.int) -> _c.int); | |
| DRAWSTATEPROC :: (proc "stdcall" (hdc : HDC, lData : LPARAM, wData : WPARAM, cx : _c.int, cy : _c.int) -> BOOL); | |
| PROPENUMPROC :: PROPENUMPROCA; | |
| PROPENUMPROCEX :: PROPENUMPROCEXA; | |
| EDITWORDBREAKPROC :: EDITWORDBREAKPROCA; | |
| NAMEENUMPROCA :: (proc "stdcall" (LPSTR, LPARAM) -> BOOL); | |
| NAMEENUMPROCW :: (proc "stdcall" (LPWSTR, LPARAM) -> BOOL); | |
| WINSTAENUMPROCA :: NAMEENUMPROCA; | |
| DESKTOPENUMPROCA :: NAMEENUMPROCA; | |
| WINSTAENUMPROCW :: NAMEENUMPROCW; | |
| DESKTOPENUMPROCW :: NAMEENUMPROCW; | |
| WINSTAENUMPROC :: WINSTAENUMPROCA; | |
| DESKTOPENUMPROC :: DESKTOPENUMPROCA; | |
| CBT_CREATEWNDA :: struct { | |
| lpcs : ^CREATESTRUCTA, | |
| hwndInsertAfter : HWND, | |
| }; | |
| LPCBT_CREATEWNDA :: ^CBT_CREATEWNDA; | |
| CBT_CREATEWNDW :: struct { | |
| lpcs : ^CREATESTRUCTW, | |
| hwndInsertAfter : HWND, | |
| }; | |
| LPCBT_CREATEWNDW :: ^CBT_CREATEWNDW; | |
| CBT_CREATEWND :: CBT_CREATEWNDA; | |
| LPCBT_CREATEWND :: LPCBT_CREATEWNDA; | |
| CBTACTIVATESTRUCT :: struct { | |
| fMouse : BOOL, | |
| hWndActive : HWND, | |
| }; | |
| LPCBTACTIVATESTRUCT :: ^CBTACTIVATESTRUCT; | |
| WTSSESSION_NOTIFICATION :: struct { | |
| cbSize : DWORD, | |
| dwSessionId : DWORD, | |
| }; | |
| PWTSSESSION_NOTIFICATION :: ^WTSSESSION_NOTIFICATION; | |
| SHELLHOOKINFO :: struct { | |
| hwnd : HWND, | |
| rc : RECT, | |
| }; | |
| LPSHELLHOOKINFO :: ^SHELLHOOKINFO; | |
| EVENTMSG :: struct { | |
| message : UINT, | |
| paramL : UINT, | |
| paramH : UINT, | |
| time : DWORD, | |
| hwnd : HWND, | |
| }; | |
| PEVENTMSGMSG :: ^EVENTMSG; | |
| NPEVENTMSGMSG :: ^EVENTMSG; | |
| LPEVENTMSGMSG :: ^EVENTMSG; | |
| PEVENTMSG :: ^EVENTMSG; | |
| NPEVENTMSG :: ^EVENTMSG; | |
| LPEVENTMSG :: ^EVENTMSG; | |
| CWPSTRUCT :: struct { | |
| lParam : LPARAM, | |
| wParam : WPARAM, | |
| message : UINT, | |
| hwnd : HWND, | |
| }; | |
| PCWPSTRUCT :: ^CWPSTRUCT; | |
| NPCWPSTRUCT :: ^CWPSTRUCT; | |
| LPCWPSTRUCT :: ^CWPSTRUCT; | |
| CWPRETSTRUCT :: struct { | |
| lResult : LRESULT, | |
| lParam : LPARAM, | |
| wParam : WPARAM, | |
| message : UINT, | |
| hwnd : HWND, | |
| }; | |
| PCWPRETSTRUCT :: ^CWPRETSTRUCT; | |
| NPCWPRETSTRUCT :: ^CWPRETSTRUCT; | |
| LPCWPRETSTRUCT :: ^CWPRETSTRUCT; | |
| KBDLLHOOKSTRUCT :: struct { | |
| vkCode : DWORD, | |
| scanCode : DWORD, | |
| flags : DWORD, | |
| time : DWORD, | |
| dwExtraInfo : ULONG_PTR, | |
| }; | |
| LPKBDLLHOOKSTRUCT :: ^KBDLLHOOKSTRUCT; | |
| PKBDLLHOOKSTRUCT :: ^KBDLLHOOKSTRUCT; | |
| MSLLHOOKSTRUCT :: struct { | |
| pt : POINT, | |
| mouseData : DWORD, | |
| flags : DWORD, | |
| time : DWORD, | |
| dwExtraInfo : ULONG_PTR, | |
| }; | |
| LPMSLLHOOKSTRUCT :: ^MSLLHOOKSTRUCT; | |
| PMSLLHOOKSTRUCT :: ^MSLLHOOKSTRUCT; | |
| DEBUGHOOKINFO :: struct { | |
| idThread : DWORD, | |
| idThreadInstaller : DWORD, | |
| lParam : LPARAM, | |
| wParam : WPARAM, | |
| code : _c.int, | |
| }; | |
| PDEBUGHOOKINFO :: ^DEBUGHOOKINFO; | |
| NPDEBUGHOOKINFO :: ^DEBUGHOOKINFO; | |
| LPDEBUGHOOKINFO :: ^DEBUGHOOKINFO; | |
| MOUSEHOOKSTRUCT :: struct { | |
| pt : POINT, | |
| hwnd : HWND, | |
| wHitTestCode : UINT, | |
| dwExtraInfo : ULONG_PTR, | |
| }; | |
| LPMOUSEHOOKSTRUCT :: ^MOUSEHOOKSTRUCT; | |
| PMOUSEHOOKSTRUCT :: ^MOUSEHOOKSTRUCT; | |
| MOUSEHOOKSTRUCTEX :: struct { | |
| s : MOUSEHOOKSTRUCT, | |
| mouseData : DWORD, | |
| }; | |
| LPMOUSEHOOKSTRUCTEX :: ^MOUSEHOOKSTRUCTEX; | |
| PMOUSEHOOKSTRUCTEX :: ^MOUSEHOOKSTRUCTEX; | |
| HARDWAREHOOKSTRUCT :: struct { | |
| hwnd : HWND, | |
| message : UINT, | |
| wParam : WPARAM, | |
| lParam : LPARAM, | |
| }; | |
| LPHARDWAREHOOKSTRUCT :: ^HARDWAREHOOKSTRUCT; | |
| PHARDWAREHOOKSTRUCT :: ^HARDWAREHOOKSTRUCT; | |
| MOUSEMOVEPOINT :: struct { | |
| x : _c.int, | |
| y : _c.int, | |
| time : DWORD, | |
| dwExtraInfo : ULONG_PTR, | |
| }; | |
| PMOUSEMOVEPOINT :: ^MOUSEMOVEPOINT; | |
| LPMOUSEMOVEPOINT :: ^MOUSEMOVEPOINT; | |
| USEROBJECTFLAGS :: struct { | |
| fInherit : BOOL, | |
| fReserved : BOOL, | |
| dwFlags : DWORD, | |
| }; | |
| PUSEROBJECTFLAGS :: ^USEROBJECTFLAGS; | |
| WNDCLASSEXA :: struct { | |
| cbSize : UINT, | |
| style : UINT, | |
| lpfnWndProc : WNDPROC, | |
| cbClsExtra : _c.int, | |
| cbWndExtra : _c.int, | |
| hInstance : HINSTANCE, | |
| hIcon : HICON, | |
| hCursor : HCURSOR, | |
| hbrBackground : HBRUSH, | |
| lpszMenuName : LPCSTR, | |
| lpszClassName : LPCSTR, | |
| hIconSm : HICON, | |
| }; | |
| PWNDCLASSEXA :: ^WNDCLASSEXA; | |
| NPWNDCLASSEXA :: ^WNDCLASSEXA; | |
| LPWNDCLASSEXA :: ^WNDCLASSEXA; | |
| WNDCLASSEXW :: struct { | |
| cbSize : UINT, | |
| style : UINT, | |
| lpfnWndProc : WNDPROC, | |
| cbClsExtra : _c.int, | |
| cbWndExtra : _c.int, | |
| hInstance : HINSTANCE, | |
| hIcon : HICON, | |
| hCursor : HCURSOR, | |
| hbrBackground : HBRUSH, | |
| lpszMenuName : LPCWSTR, | |
| lpszClassName : LPCWSTR, | |
| hIconSm : HICON, | |
| }; | |
| PWNDCLASSEXW :: ^WNDCLASSEXW; | |
| NPWNDCLASSEXW :: ^WNDCLASSEXW; | |
| LPWNDCLASSEXW :: ^WNDCLASSEXW; | |
| WNDCLASSEX :: WNDCLASSEXA; | |
| PWNDCLASSEX :: PWNDCLASSEXA; | |
| NPWNDCLASSEX :: NPWNDCLASSEXA; | |
| LPWNDCLASSEX :: LPWNDCLASSEXA; | |
| WNDCLASSA :: struct { | |
| style : UINT, | |
| lpfnWndProc : WNDPROC, | |
| cbClsExtra : _c.int, | |
| cbWndExtra : _c.int, | |
| hInstance : HINSTANCE, | |
| hIcon : HICON, | |
| hCursor : HCURSOR, | |
| hbrBackground : HBRUSH, | |
| lpszMenuName : LPCSTR, | |
| lpszClassName : LPCSTR, | |
| }; | |
| PWNDCLASSA :: ^WNDCLASSA; | |
| NPWNDCLASSA :: ^WNDCLASSA; | |
| LPWNDCLASSA :: ^WNDCLASSA; | |
| WNDCLASSW :: struct { | |
| style : UINT, | |
| lpfnWndProc : WNDPROC, | |
| cbClsExtra : _c.int, | |
| cbWndExtra : _c.int, | |
| hInstance : HINSTANCE, | |
| hIcon : HICON, | |
| hCursor : HCURSOR, | |
| hbrBackground : HBRUSH, | |
| lpszMenuName : LPCWSTR, | |
| lpszClassName : LPCWSTR, | |
| }; | |
| PWNDCLASSW :: ^WNDCLASSW; | |
| NPWNDCLASSW :: ^WNDCLASSW; | |
| LPWNDCLASSW :: ^WNDCLASSW; | |
| WNDCLASS :: WNDCLASSA; | |
| PWNDCLASS :: PWNDCLASSA; | |
| NPWNDCLASS :: NPWNDCLASSA; | |
| LPWNDCLASS :: LPWNDCLASSA; | |
| MSG :: struct { | |
| hwnd : HWND, | |
| message : UINT, | |
| wParam : WPARAM, | |
| lParam : LPARAM, | |
| time : DWORD, | |
| pt : POINT, | |
| }; | |
| PMSG :: ^MSG; | |
| NPMSG :: ^MSG; | |
| LPMSG :: ^MSG; | |
| MINMAXINFO :: struct { | |
| ptReserved : POINT, | |
| ptMaxSize : POINT, | |
| ptMaxPosition : POINT, | |
| ptMinTrackSize : POINT, | |
| ptMaxTrackSize : POINT, | |
| }; | |
| PMINMAXINFO :: ^MINMAXINFO; | |
| LPMINMAXINFO :: ^MINMAXINFO; | |
| COPYDATASTRUCT :: struct { | |
| dwData : ULONG_PTR, | |
| cbData : DWORD, | |
| lpData : PVOID, | |
| }; | |
| PCOPYDATASTRUCT :: ^COPYDATASTRUCT; | |
| MDINEXTMENU :: struct { | |
| hmenuIn : HMENU, | |
| hmenuNext : HMENU, | |
| hwndNext : HWND, | |
| }; | |
| PMDINEXTMENU :: ^MDINEXTMENU; | |
| LPMDINEXTMENU :: ^MDINEXTMENU; | |
| POWERBROADCAST_SETTING :: struct { | |
| PowerSetting : GUID, | |
| DataLength : DWORD, | |
| Data : [1]UCHAR, | |
| }; | |
| PPOWERBROADCAST_SETTING :: ^POWERBROADCAST_SETTING; | |
| WINDOWPOS :: struct { | |
| hwnd : HWND, | |
| hwndInsertAfter : HWND, | |
| x : _c.int, | |
| y : _c.int, | |
| cx : _c.int, | |
| cy : _c.int, | |
| flags : UINT, | |
| }; | |
| LPWINDOWPOS :: ^WINDOWPOS; | |
| PWINDOWPOS :: ^WINDOWPOS; | |
| NCCALCSIZE_PARAMS :: struct { | |
| rgrc : [3]RECT, | |
| lppos : PWINDOWPOS, | |
| }; | |
| LPNCCALCSIZE_PARAMS :: ^NCCALCSIZE_PARAMS; | |
| TRACKMOUSEEVENT :: struct { | |
| cbSize : DWORD, | |
| dwFlags : DWORD, | |
| hwndTrack : HWND, | |
| dwHoverTime : DWORD, | |
| }; | |
| LPTRACKMOUSEEVENT :: ^TRACKMOUSEEVENT; | |
| ACCEL :: struct { | |
| fVirt : BYTE, | |
| key : WORD, | |
| cmd : WORD, | |
| }; | |
| LPACCEL :: ^ACCEL; | |
| PAINTSTRUCT :: struct { | |
| hdc : HDC, | |
| fErase : BOOL, | |
| rcPaint : RECT, | |
| fRestore : BOOL, | |
| fIncUpdate : BOOL, | |
| rgbReserved : [32]BYTE, | |
| }; | |
| PPAINTSTRUCT :: ^PAINTSTRUCT; | |
| NPPAINTSTRUCT :: ^PAINTSTRUCT; | |
| LPPAINTSTRUCT :: ^PAINTSTRUCT; | |
| CREATESTRUCTA :: struct { | |
| lpCreateParams : LPVOID, | |
| hInstance : HINSTANCE, | |
| hMenu : HMENU, | |
| hwndParent : HWND, | |
| cy : _c.int, | |
| cx : _c.int, | |
| y : _c.int, | |
| x : _c.int, | |
| style : LONG, | |
| lpszName : LPCSTR, | |
| lpszClass : LPCSTR, | |
| dwExStyle : DWORD, | |
| }; | |
| LPCREATESTRUCTA :: ^CREATESTRUCTA; | |
| CREATESTRUCTW :: struct { | |
| lpCreateParams : LPVOID, | |
| hInstance : HINSTANCE, | |
| hMenu : HMENU, | |
| hwndParent : HWND, | |
| cy : _c.int, | |
| cx : _c.int, | |
| y : _c.int, | |
| x : _c.int, | |
| style : LONG, | |
| lpszName : LPCWSTR, | |
| lpszClass : LPCWSTR, | |
| dwExStyle : DWORD, | |
| }; | |
| LPCREATESTRUCTW :: ^CREATESTRUCTW; | |
| CREATESTRUCT :: CREATESTRUCTA; | |
| LPCREATESTRUCT :: LPCREATESTRUCTA; | |
| WINDOWPLACEMENT :: struct { | |
| length : UINT, | |
| flags : UINT, | |
| showCmd : UINT, | |
| ptMinPosition : POINT, | |
| ptMaxPosition : POINT, | |
| rcNormalPosition : RECT, | |
| }; | |
| PWINDOWPLACEMENT :: ^WINDOWPLACEMENT; | |
| LPWINDOWPLACEMENT :: ^WINDOWPLACEMENT; | |
| NMHDR :: struct { | |
| hwndFrom : HWND, | |
| idFrom : UINT_PTR, | |
| code : UINT, | |
| }; | |
| LPNMHDR :: ^NMHDR; | |
| STYLESTRUCT :: struct { | |
| styleOld : DWORD, | |
| styleNew : DWORD, | |
| }; | |
| LPSTYLESTRUCT :: ^STYLESTRUCT; | |
| MEASUREITEMSTRUCT :: struct { | |
| CtlType : UINT, | |
| CtlID : UINT, | |
| itemID : UINT, | |
| itemWidth : UINT, | |
| itemHeight : UINT, | |
| itemData : ULONG_PTR, | |
| }; | |
| PMEASUREITEMSTRUCT :: ^MEASUREITEMSTRUCT; | |
| LPMEASUREITEMSTRUCT :: ^MEASUREITEMSTRUCT; | |
| DRAWITEMSTRUCT :: struct { | |
| CtlType : UINT, | |
| CtlID : UINT, | |
| itemID : UINT, | |
| itemAction : UINT, | |
| itemState : UINT, | |
| hwndItem : HWND, | |
| hDC : HDC, | |
| rcItem : RECT, | |
| itemData : ULONG_PTR, | |
| }; | |
| PDRAWITEMSTRUCT :: ^DRAWITEMSTRUCT; | |
| LPDRAWITEMSTRUCT :: ^DRAWITEMSTRUCT; | |
| DELETEITEMSTRUCT :: struct { | |
| CtlType : UINT, | |
| CtlID : UINT, | |
| itemID : UINT, | |
| hwndItem : HWND, | |
| itemData : ULONG_PTR, | |
| }; | |
| PDELETEITEMSTRUCT :: ^DELETEITEMSTRUCT; | |
| LPDELETEITEMSTRUCT :: ^DELETEITEMSTRUCT; | |
| COMPAREITEMSTRUCT :: struct { | |
| CtlType : UINT, | |
| CtlID : UINT, | |
| hwndItem : HWND, | |
| itemID1 : UINT, | |
| itemData1 : ULONG_PTR, | |
| itemID2 : UINT, | |
| itemData2 : ULONG_PTR, | |
| dwLocaleId : DWORD, | |
| }; | |
| PCOMPAREITEMSTRUCT :: ^COMPAREITEMSTRUCT; | |
| LPCOMPAREITEMSTRUCT :: ^COMPAREITEMSTRUCT; | |
| BSMINFO :: struct { | |
| cbSize : UINT, | |
| hdesk : HDESK, | |
| hwnd : HWND, | |
| luid : LUID, | |
| }; | |
| PBSMINFO :: ^BSMINFO; | |
| HDEVNOTIFY :: PVOID; | |
| PHDEVNOTIFY :: ^HDEVNOTIFY; | |
| HPOWERNOTIFY :: PVOID; | |
| PHPOWERNOTIFY :: ^HPOWERNOTIFY; | |
| PREGISTERCLASSNAMEW :: (proc "stdcall" (LPCWSTR) -> BOOLEAN); | |
| UPDATELAYEREDWINDOWINFO :: struct { | |
| cbSize : DWORD, | |
| hdcDst : HDC, | |
| pptDst : ^POINT, | |
| psize : ^SIZE, | |
| hdcSrc : HDC, | |
| pptSrc : ^POINT, | |
| crKey : COLORREF, | |
| pblend : ^BLENDFUNCTION, | |
| dwFlags : DWORD, | |
| prcDirty : ^RECT, | |
| }; | |
| PUPDATELAYEREDWINDOWINFO :: ^UPDATELAYEREDWINDOWINFO; | |
| FLASHWINFO :: struct { | |
| cbSize : UINT, | |
| hwnd : HWND, | |
| dwFlags : DWORD, | |
| uCount : UINT, | |
| dwTimeout : DWORD, | |
| }; | |
| PFLASHWINFO :: ^FLASHWINFO; | |
| DLGTEMPLATE :: struct { | |
| style : DWORD, | |
| dwExtendedStyle : DWORD, | |
| cdit : WORD, | |
| x : _c.short, | |
| y : _c.short, | |
| cx : _c.short, | |
| cy : _c.short, | |
| }; | |
| LPDLGTEMPLATEA :: ^DLGTEMPLATE; | |
| LPDLGTEMPLATEW :: ^DLGTEMPLATE; | |
| LPDLGTEMPLATE :: LPDLGTEMPLATEA; | |
| LPCDLGTEMPLATEA :: ^DLGTEMPLATE; | |
| LPCDLGTEMPLATEW :: ^DLGTEMPLATE; | |
| LPCDLGTEMPLATE :: LPCDLGTEMPLATEA; | |
| DLGITEMTEMPLATE :: struct { | |
| style : DWORD, | |
| dwExtendedStyle : DWORD, | |
| x : _c.short, | |
| y : _c.short, | |
| cx : _c.short, | |
| cy : _c.short, | |
| id : WORD, | |
| }; | |
| PDLGITEMTEMPLATEA :: ^DLGITEMTEMPLATE; | |
| PDLGITEMTEMPLATEW :: ^DLGITEMTEMPLATE; | |
| PDLGITEMTEMPLATE :: PDLGITEMTEMPLATEA; | |
| LPDLGITEMTEMPLATEA :: ^DLGITEMTEMPLATE; | |
| LPDLGITEMTEMPLATEW :: ^DLGITEMTEMPLATE; | |
| LPDLGITEMTEMPLATE :: LPDLGITEMTEMPLATEA; | |
| /* DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS :: enum { */ | |
| DIALOG_CONTROL_DPI_CHANGE_BEHAVIORS :: _c.int; | |
| DCDC_DEFAULT :: 0x0000; | |
| DCDC_DISABLE_FONT_UPDATE :: 0x0001; | |
| DCDC_DISABLE_RELAYOUT :: 0x0002; | |
| /* } */ | |
| ; | |
| /* DIALOG_DPI_CHANGE_BEHAVIORS :: enum { */ | |
| DIALOG_DPI_CHANGE_BEHAVIORS :: _c.int; | |
| DDC_DEFAULT :: 0x0000; | |
| DDC_DISABLE_ALL :: 0x0001; | |
| DDC_DISABLE_RESIZE :: 0x0002; | |
| DDC_DISABLE_CONTROL_RELAYOUT :: 0x0004; | |
| /* } */ | |
| ; | |
| MOUSEINPUT :: struct { | |
| dx : LONG, | |
| dy : LONG, | |
| mouseData : DWORD, | |
| dwFlags : DWORD, | |
| time : DWORD, | |
| dwExtraInfo : ULONG_PTR, | |
| }; | |
| PMOUSEINPUT :: ^MOUSEINPUT; | |
| LPMOUSEINPUT :: ^MOUSEINPUT; | |
| KEYBDINPUT :: struct { | |
| wVk : WORD, | |
| wScan : WORD, | |
| dwFlags : DWORD, | |
| time : DWORD, | |
| dwExtraInfo : ULONG_PTR, | |
| }; | |
| PKEYBDINPUT :: ^KEYBDINPUT; | |
| LPKEYBDINPUT :: ^KEYBDINPUT; | |
| HARDWAREINPUT :: struct { | |
| uMsg : DWORD, | |
| wParamL : WORD, | |
| wParamH : WORD, | |
| }; | |
| PHARDWAREINPUT :: ^HARDWAREINPUT; | |
| LPHARDWAREINPUT :: ^HARDWAREINPUT; | |
| INPUT :: struct { | |
| type : DWORD, | |
| u : struct #raw_union { | |
| mi : MOUSEINPUT, | |
| ki : KEYBDINPUT, | |
| hi : HARDWAREINPUT, | |
| }, | |
| }; | |
| PINPUT :: ^INPUT; | |
| LPINPUT :: ^INPUT; | |
| HTOUCHINPUT__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HTOUCHINPUT :: ^HTOUCHINPUT__; | |
| TOUCHINPUT :: struct { | |
| x : LONG, | |
| y : LONG, | |
| hSource : HANDLE, | |
| dwID : DWORD, | |
| dwFlags : DWORD, | |
| dwMask : DWORD, | |
| dwTime : DWORD, | |
| dwExtraInfo : ULONG_PTR, | |
| cxContact : DWORD, | |
| cyContact : DWORD, | |
| }; | |
| PTOUCHINPUT :: ^TOUCHINPUT; | |
| PCTOUCHINPUT :: ^TOUCHINPUT; | |
| /* tagPOINTER_INPUT_TYPE :: enum { */ | |
| tagPOINTER_INPUT_TYPE :: _c.int; | |
| PT_POINTER :: 1; | |
| PT_TOUCH :: 2; | |
| PT_PEN :: 3; | |
| PT_MOUSE :: 4; | |
| PT_TOUCHPAD :: 5; | |
| /* } */ | |
| ; | |
| POINTER_INPUT_TYPE :: DWORD; | |
| POINTER_FLAGS :: UINT32; | |
| /* POINTER_BUTTON_CHANGE_TYPE :: enum { */ | |
| POINTER_BUTTON_CHANGE_TYPE :: _c.int; | |
| POINTER_CHANGE_NONE :: 0; | |
| POINTER_CHANGE_FIRSTBUTTON_DOWN :: POINTER_CHANGE_NONE + 1; | |
| POINTER_CHANGE_FIRSTBUTTON_UP :: POINTER_CHANGE_FIRSTBUTTON_DOWN + 1; | |
| POINTER_CHANGE_SECONDBUTTON_DOWN :: POINTER_CHANGE_FIRSTBUTTON_UP + 1; | |
| POINTER_CHANGE_SECONDBUTTON_UP :: POINTER_CHANGE_SECONDBUTTON_DOWN + 1; | |
| POINTER_CHANGE_THIRDBUTTON_DOWN :: POINTER_CHANGE_SECONDBUTTON_UP + 1; | |
| POINTER_CHANGE_THIRDBUTTON_UP :: POINTER_CHANGE_THIRDBUTTON_DOWN + 1; | |
| POINTER_CHANGE_FOURTHBUTTON_DOWN :: POINTER_CHANGE_THIRDBUTTON_UP + 1; | |
| POINTER_CHANGE_FOURTHBUTTON_UP :: POINTER_CHANGE_FOURTHBUTTON_DOWN + 1; | |
| POINTER_CHANGE_FIFTHBUTTON_DOWN :: POINTER_CHANGE_FOURTHBUTTON_UP + 1; | |
| POINTER_CHANGE_FIFTHBUTTON_UP :: POINTER_CHANGE_FIFTHBUTTON_DOWN + 1; | |
| /* } */ | |
| ; | |
| POINTER_INFO :: struct { | |
| pointerType : POINTER_INPUT_TYPE, | |
| pointerId : UINT32, | |
| frameId : UINT32, | |
| pointerFlags : POINTER_FLAGS, | |
| sourceDevice : HANDLE, | |
| hwndTarget : HWND, | |
| ptPixelLocation : POINT, | |
| ptHimetricLocation : POINT, | |
| ptPixelLocationRaw : POINT, | |
| ptHimetricLocationRaw : POINT, | |
| dwTime : DWORD, | |
| historyCount : UINT32, | |
| InputData : INT32, | |
| dwKeyStates : DWORD, | |
| PerformanceCount : UINT64, | |
| ButtonChangeType : POINTER_BUTTON_CHANGE_TYPE, | |
| }; | |
| TOUCH_FLAGS :: UINT32; | |
| TOUCH_MASK :: UINT32; | |
| POINTER_TOUCH_INFO :: struct { | |
| pointerInfo : POINTER_INFO, | |
| touchFlags : TOUCH_FLAGS, | |
| touchMask : TOUCH_MASK, | |
| rcContact : RECT, | |
| rcContactRaw : RECT, | |
| orientation : UINT32, | |
| pressure : UINT32, | |
| }; | |
| PEN_FLAGS :: UINT32; | |
| PEN_MASK :: UINT32; | |
| POINTER_PEN_INFO :: struct { | |
| pointerInfo : POINTER_INFO, | |
| penFlags : PEN_FLAGS, | |
| penMask : PEN_MASK, | |
| pressure : UINT32, | |
| rotation : UINT32, | |
| tiltX : INT32, | |
| tiltY : INT32, | |
| }; | |
| /* POINTER_FEEDBACK_MODE :: enum { */ | |
| POINTER_FEEDBACK_MODE :: _c.int; | |
| POINTER_FEEDBACK_DEFAULT :: 1; | |
| POINTER_FEEDBACK_INDIRECT :: 2; | |
| POINTER_FEEDBACK_NONE :: 3; | |
| /* } */ | |
| ; | |
| USAGE_PROPERTIES :: struct { | |
| level : USHORT, | |
| page : USHORT, | |
| usage : USHORT, | |
| logicalMinimum : INT32, | |
| logicalMaximum : INT32, | |
| unit : USHORT, | |
| exponent : USHORT, | |
| count : BYTE, | |
| physicalMinimum : INT32, | |
| physicalMaximum : INT32, | |
| }; | |
| PUSAGE_PROPERTIES :: ^USAGE_PROPERTIES; | |
| POINTER_TYPE_INFO :: struct { | |
| type : POINTER_INPUT_TYPE, | |
| u : struct #raw_union { | |
| touchInfo : POINTER_TOUCH_INFO, | |
| penInfo : POINTER_PEN_INFO, | |
| }, | |
| }; | |
| PPOINTER_TYPE_INFO :: ^POINTER_TYPE_INFO; | |
| INPUT_INJECTION_VALUE :: struct { | |
| page : USHORT, | |
| usage : USHORT, | |
| value : INT32, | |
| index : USHORT, | |
| }; | |
| PINPUT_INJECTION_VALUE :: ^INPUT_INJECTION_VALUE; | |
| HSYNTHETICPOINTERDEVICE__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HSYNTHETICPOINTERDEVICE :: ^HSYNTHETICPOINTERDEVICE__; | |
| TOUCH_HIT_TESTING_PROXIMITY_EVALUATION :: struct { | |
| score : UINT16, | |
| adjustedPoint : POINT, | |
| }; | |
| PTOUCH_HIT_TESTING_PROXIMITY_EVALUATION :: ^TOUCH_HIT_TESTING_PROXIMITY_EVALUATION; | |
| TOUCH_HIT_TESTING_INPUT :: struct { | |
| pointerId : UINT32, | |
| point : POINT, | |
| boundingBox : RECT, | |
| nonOccludedBoundingBox : RECT, | |
| orientation : UINT32, | |
| }; | |
| PTOUCH_HIT_TESTING_INPUT :: ^TOUCH_HIT_TESTING_INPUT; | |
| /* FEEDBACK_TYPE :: enum { */ | |
| FEEDBACK_TYPE :: _c.int; | |
| FEEDBACK_TOUCH_CONTACTVISUALIZATION :: 1; | |
| FEEDBACK_PEN_BARRELVISUALIZATION :: 2; | |
| FEEDBACK_PEN_TAP :: 3; | |
| FEEDBACK_PEN_DOUBLETAP :: 4; | |
| FEEDBACK_PEN_PRESSANDHOLD :: 5; | |
| FEEDBACK_PEN_RIGHTTAP :: 6; | |
| FEEDBACK_TOUCH_TAP :: 7; | |
| FEEDBACK_TOUCH_DOUBLETAP :: 8; | |
| FEEDBACK_TOUCH_PRESSANDHOLD :: 9; | |
| FEEDBACK_TOUCH_RIGHTTAP :: 10; | |
| FEEDBACK_GESTURE_PRESSANDTAP :: 11; | |
| FEEDBACK_MAX :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| INPUT_TRANSFORM :: struct { | |
| u : struct #raw_union { | |
| s : struct { | |
| _11 : _c.float, | |
| _12 : _c.float, | |
| _13 : _c.float, | |
| _14 : _c.float, | |
| _21 : _c.float, | |
| _22 : _c.float, | |
| _23 : _c.float, | |
| _24 : _c.float, | |
| _31 : _c.float, | |
| _32 : _c.float, | |
| _33 : _c.float, | |
| _34 : _c.float, | |
| _41 : _c.float, | |
| _42 : _c.float, | |
| _43 : _c.float, | |
| _44 : _c.float, | |
| }, | |
| m : [4][4]_c.float, | |
| }, | |
| }; | |
| LASTINPUTINFO :: struct { | |
| cbSize : UINT, | |
| dwTime : DWORD, | |
| }; | |
| PLASTINPUTINFO :: ^LASTINPUTINFO; | |
| TPMPARAMS :: struct { | |
| cbSize : UINT, | |
| rcExclude : RECT, | |
| }; | |
| LPTPMPARAMS :: ^TPMPARAMS; | |
| MENUINFO :: struct { | |
| cbSize : DWORD, | |
| fMask : DWORD, | |
| dwStyle : DWORD, | |
| cyMax : UINT, | |
| hbrBack : HBRUSH, | |
| dwContextHelpID : DWORD, | |
| dwMenuData : ULONG_PTR, | |
| }; | |
| LPMENUINFO :: ^MENUINFO; | |
| LPCMENUINFO :: ^MENUINFO; | |
| MENUGETOBJECTINFO :: struct { | |
| dwFlags : DWORD, | |
| uPos : UINT, | |
| hmenu : HMENU, | |
| riid : PVOID, | |
| pvObj : PVOID, | |
| }; | |
| PMENUGETOBJECTINFO :: ^MENUGETOBJECTINFO; | |
| MENUITEMINFOA :: struct { | |
| cbSize : UINT, | |
| fMask : UINT, | |
| fType : UINT, | |
| fState : UINT, | |
| wID : UINT, | |
| hSubMenu : HMENU, | |
| hbmpChecked : HBITMAP, | |
| hbmpUnchecked : HBITMAP, | |
| dwItemData : ULONG_PTR, | |
| dwTypeData : LPSTR, | |
| cch : UINT, | |
| hbmpItem : HBITMAP, | |
| }; | |
| LPMENUITEMINFOA :: ^MENUITEMINFOA; | |
| MENUITEMINFOW :: struct { | |
| cbSize : UINT, | |
| fMask : UINT, | |
| fType : UINT, | |
| fState : UINT, | |
| wID : UINT, | |
| hSubMenu : HMENU, | |
| hbmpChecked : HBITMAP, | |
| hbmpUnchecked : HBITMAP, | |
| dwItemData : ULONG_PTR, | |
| dwTypeData : LPWSTR, | |
| cch : UINT, | |
| hbmpItem : HBITMAP, | |
| }; | |
| LPMENUITEMINFOW :: ^MENUITEMINFOW; | |
| MENUITEMINFO :: MENUITEMINFOA; | |
| LPMENUITEMINFO :: LPMENUITEMINFOA; | |
| LPCMENUITEMINFOA :: ^MENUITEMINFOA; | |
| LPCMENUITEMINFOW :: ^MENUITEMINFOW; | |
| LPCMENUITEMINFO :: LPCMENUITEMINFOA; | |
| DROPSTRUCT :: struct { | |
| hwndSource : HWND, | |
| hwndSink : HWND, | |
| wFmt : DWORD, | |
| dwData : ULONG_PTR, | |
| ptDrop : POINT, | |
| dwControlData : DWORD, | |
| }; | |
| PDROPSTRUCT :: ^DROPSTRUCT; | |
| LPDROPSTRUCT :: ^DROPSTRUCT; | |
| DRAWTEXTPARAMS :: struct { | |
| cbSize : UINT, | |
| iTabLength : _c.int, | |
| iLeftMargin : _c.int, | |
| iRightMargin : _c.int, | |
| uiLengthDrawn : UINT, | |
| }; | |
| LPDRAWTEXTPARAMS :: ^DRAWTEXTPARAMS; | |
| HELPINFO :: struct { | |
| cbSize : UINT, | |
| iContextType : _c.int, | |
| iCtrlId : _c.int, | |
| hItemHandle : HANDLE, | |
| dwContextId : DWORD_PTR, | |
| MousePos : POINT, | |
| }; | |
| LPHELPINFO :: ^HELPINFO; | |
| MSGBOXCALLBACK :: proc "stdcall" (lpHelpInfo : LPHELPINFO); | |
| MSGBOXPARAMSA :: struct { | |
| cbSize : UINT, | |
| hwndOwner : HWND, | |
| hInstance : HINSTANCE, | |
| lpszText : LPCSTR, | |
| lpszCaption : LPCSTR, | |
| dwStyle : DWORD, | |
| lpszIcon : LPCSTR, | |
| dwContextHelpId : DWORD_PTR, | |
| lpfnMsgBoxCallback : MSGBOXCALLBACK, | |
| dwLanguageId : DWORD, | |
| }; | |
| PMSGBOXPARAMSA :: ^MSGBOXPARAMSA; | |
| LPMSGBOXPARAMSA :: ^MSGBOXPARAMSA; | |
| MSGBOXPARAMSW :: struct { | |
| cbSize : UINT, | |
| hwndOwner : HWND, | |
| hInstance : HINSTANCE, | |
| lpszText : LPCWSTR, | |
| lpszCaption : LPCWSTR, | |
| dwStyle : DWORD, | |
| lpszIcon : LPCWSTR, | |
| dwContextHelpId : DWORD_PTR, | |
| lpfnMsgBoxCallback : MSGBOXCALLBACK, | |
| dwLanguageId : DWORD, | |
| }; | |
| PMSGBOXPARAMSW :: ^MSGBOXPARAMSW; | |
| LPMSGBOXPARAMSW :: ^MSGBOXPARAMSW; | |
| MSGBOXPARAMS :: MSGBOXPARAMSA; | |
| PMSGBOXPARAMS :: PMSGBOXPARAMSA; | |
| LPMSGBOXPARAMS :: LPMSGBOXPARAMSA; | |
| MENUITEMTEMPLATEHEADER :: struct { | |
| versionNumber : WORD, | |
| offset : WORD, | |
| }; | |
| PMENUITEMTEMPLATEHEADER :: ^MENUITEMTEMPLATEHEADER; | |
| MENUITEMTEMPLATE :: struct { | |
| mtOption : WORD, | |
| mtID : WORD, | |
| mtString : [1]WCHAR, | |
| }; | |
| PMENUITEMTEMPLATE :: ^MENUITEMTEMPLATE; | |
| ICONINFO :: struct { | |
| fIcon : BOOL, | |
| xHotspot : DWORD, | |
| yHotspot : DWORD, | |
| hbmMask : HBITMAP, | |
| hbmColor : HBITMAP, | |
| }; | |
| PICONINFO :: ^ICONINFO; | |
| CURSORSHAPE :: struct { | |
| xHotSpot : _c.int, | |
| yHotSpot : _c.int, | |
| cx : _c.int, | |
| cy : _c.int, | |
| cbWidth : _c.int, | |
| Planes : BYTE, | |
| BitsPixel : BYTE, | |
| }; | |
| LPCURSORSHAPE :: ^CURSORSHAPE; | |
| ICONINFOEXA :: struct { | |
| cbSize : DWORD, | |
| fIcon : BOOL, | |
| xHotspot : DWORD, | |
| yHotspot : DWORD, | |
| hbmMask : HBITMAP, | |
| hbmColor : HBITMAP, | |
| wResID : WORD, | |
| szModName : [260]CHAR, | |
| szResName : [260]CHAR, | |
| }; | |
| PICONINFOEXA :: ^ICONINFOEXA; | |
| ICONINFOEXW :: struct { | |
| cbSize : DWORD, | |
| fIcon : BOOL, | |
| xHotspot : DWORD, | |
| yHotspot : DWORD, | |
| hbmMask : HBITMAP, | |
| hbmColor : HBITMAP, | |
| wResID : WORD, | |
| szModName : [260]WCHAR, | |
| szResName : [260]WCHAR, | |
| }; | |
| PICONINFOEXW :: ^ICONINFOEXW; | |
| ICONINFOEX :: ICONINFOEXA; | |
| PICONINFOEX :: PICONINFOEXA; | |
| /* EDIT_CONTROL_FEATURE :: enum { */ | |
| EDIT_CONTROL_FEATURE :: _c.int; | |
| EDIT_CONTROL_FEATURE_ENTERPRISE_DATA_PROTECTION_PASTE_SUPPORT :: 0; | |
| EDIT_CONTROL_FEATURE_PASTE_NOTIFICATIONS :: 1; | |
| /* } */ | |
| ; | |
| SCROLLINFO :: struct { | |
| cbSize : UINT, | |
| fMask : UINT, | |
| nMin : _c.int, | |
| nMax : _c.int, | |
| nPage : UINT, | |
| nPos : _c.int, | |
| nTrackPos : _c.int, | |
| }; | |
| LPSCROLLINFO :: ^SCROLLINFO; | |
| LPCSCROLLINFO :: ^SCROLLINFO; | |
| MDICREATESTRUCTA :: struct { | |
| szClass : LPCSTR, | |
| szTitle : LPCSTR, | |
| hOwner : HANDLE, | |
| x : _c.int, | |
| y : _c.int, | |
| cx : _c.int, | |
| cy : _c.int, | |
| style : DWORD, | |
| lParam : LPARAM, | |
| }; | |
| LPMDICREATESTRUCTA :: ^MDICREATESTRUCTA; | |
| MDICREATESTRUCTW :: struct { | |
| szClass : LPCWSTR, | |
| szTitle : LPCWSTR, | |
| hOwner : HANDLE, | |
| x : _c.int, | |
| y : _c.int, | |
| cx : _c.int, | |
| cy : _c.int, | |
| style : DWORD, | |
| lParam : LPARAM, | |
| }; | |
| LPMDICREATESTRUCTW :: ^MDICREATESTRUCTW; | |
| MDICREATESTRUCT :: MDICREATESTRUCTA; | |
| LPMDICREATESTRUCT :: LPMDICREATESTRUCTA; | |
| CLIENTCREATESTRUCT :: struct { | |
| hWindowMenu : HANDLE, | |
| idFirstChild : UINT, | |
| }; | |
| LPCLIENTCREATESTRUCT :: ^CLIENTCREATESTRUCT; | |
| HELPPOLY :: DWORD; | |
| MULTIKEYHELPA :: struct { | |
| mkSize : DWORD, | |
| mkKeylist : CHAR, | |
| szKeyphrase : [1]CHAR, | |
| }; | |
| PMULTIKEYHELPA :: ^MULTIKEYHELPA; | |
| LPMULTIKEYHELPA :: ^MULTIKEYHELPA; | |
| MULTIKEYHELPW :: struct { | |
| mkSize : DWORD, | |
| mkKeylist : WCHAR, | |
| szKeyphrase : [1]WCHAR, | |
| }; | |
| PMULTIKEYHELPW :: ^MULTIKEYHELPW; | |
| LPMULTIKEYHELPW :: ^MULTIKEYHELPW; | |
| MULTIKEYHELP :: MULTIKEYHELPA; | |
| PMULTIKEYHELP :: PMULTIKEYHELPA; | |
| LPMULTIKEYHELP :: LPMULTIKEYHELPA; | |
| HELPWININFOA :: struct { | |
| wStructSize : _c.int, | |
| x : _c.int, | |
| y : _c.int, | |
| dx : _c.int, | |
| dy : _c.int, | |
| wMax : _c.int, | |
| rgchMember : [2]CHAR, | |
| }; | |
| PHELPWININFOA :: ^HELPWININFOA; | |
| LPHELPWININFOA :: ^HELPWININFOA; | |
| HELPWININFOW :: struct { | |
| wStructSize : _c.int, | |
| x : _c.int, | |
| y : _c.int, | |
| dx : _c.int, | |
| dy : _c.int, | |
| wMax : _c.int, | |
| rgchMember : [2]WCHAR, | |
| }; | |
| PHELPWININFOW :: ^HELPWININFOW; | |
| LPHELPWININFOW :: ^HELPWININFOW; | |
| HELPWININFO :: HELPWININFOA; | |
| PHELPWININFO :: PHELPWININFOA; | |
| LPHELPWININFO :: LPHELPWININFOA; | |
| TOUCHPREDICTIONPARAMETERS :: struct { | |
| cbSize : UINT, | |
| dwLatency : UINT, | |
| dwSampleTime : UINT, | |
| bUseHWTimeStamp : UINT, | |
| }; | |
| PTOUCHPREDICTIONPARAMETERS :: ^TOUCHPREDICTIONPARAMETERS; | |
| /* HANDEDNESS :: enum { */ | |
| HANDEDNESS :: _c.int; | |
| HANDEDNESS_LEFT :: 0; | |
| HANDEDNESS_RIGHT :: HANDEDNESS_LEFT + 1; | |
| /* } */ | |
| PHANDEDNESS :: ^HANDEDNESS; | |
| NONCLIENTMETRICSA :: struct { | |
| cbSize : UINT, | |
| iBorderWidth : _c.int, | |
| iScrollWidth : _c.int, | |
| iScrollHeight : _c.int, | |
| iCaptionWidth : _c.int, | |
| iCaptionHeight : _c.int, | |
| lfCaptionFont : LOGFONTA, | |
| iSmCaptionWidth : _c.int, | |
| iSmCaptionHeight : _c.int, | |
| lfSmCaptionFont : LOGFONTA, | |
| iMenuWidth : _c.int, | |
| iMenuHeight : _c.int, | |
| lfMenuFont : LOGFONTA, | |
| lfStatusFont : LOGFONTA, | |
| lfMessageFont : LOGFONTA, | |
| iPaddedBorderWidth : _c.int, | |
| }; | |
| PNONCLIENTMETRICSA :: ^NONCLIENTMETRICSA; | |
| LPNONCLIENTMETRICSA :: ^NONCLIENTMETRICSA; | |
| NONCLIENTMETRICSW :: struct { | |
| cbSize : UINT, | |
| iBorderWidth : _c.int, | |
| iScrollWidth : _c.int, | |
| iScrollHeight : _c.int, | |
| iCaptionWidth : _c.int, | |
| iCaptionHeight : _c.int, | |
| lfCaptionFont : LOGFONTW, | |
| iSmCaptionWidth : _c.int, | |
| iSmCaptionHeight : _c.int, | |
| lfSmCaptionFont : LOGFONTW, | |
| iMenuWidth : _c.int, | |
| iMenuHeight : _c.int, | |
| lfMenuFont : LOGFONTW, | |
| lfStatusFont : LOGFONTW, | |
| lfMessageFont : LOGFONTW, | |
| iPaddedBorderWidth : _c.int, | |
| }; | |
| PNONCLIENTMETRICSW :: ^NONCLIENTMETRICSW; | |
| LPNONCLIENTMETRICSW :: ^NONCLIENTMETRICSW; | |
| NONCLIENTMETRICS :: NONCLIENTMETRICSA; | |
| PNONCLIENTMETRICS :: PNONCLIENTMETRICSA; | |
| LPNONCLIENTMETRICS :: LPNONCLIENTMETRICSA; | |
| MINIMIZEDMETRICS :: struct { | |
| cbSize : UINT, | |
| iWidth : _c.int, | |
| iHorzGap : _c.int, | |
| iVertGap : _c.int, | |
| iArrange : _c.int, | |
| }; | |
| PMINIMIZEDMETRICS :: ^MINIMIZEDMETRICS; | |
| LPMINIMIZEDMETRICS :: ^MINIMIZEDMETRICS; | |
| ICONMETRICSA :: struct { | |
| cbSize : UINT, | |
| iHorzSpacing : _c.int, | |
| iVertSpacing : _c.int, | |
| iTitleWrap : _c.int, | |
| lfFont : LOGFONTA, | |
| }; | |
| PICONMETRICSA :: ^ICONMETRICSA; | |
| LPICONMETRICSA :: ^ICONMETRICSA; | |
| ICONMETRICSW :: struct { | |
| cbSize : UINT, | |
| iHorzSpacing : _c.int, | |
| iVertSpacing : _c.int, | |
| iTitleWrap : _c.int, | |
| lfFont : LOGFONTW, | |
| }; | |
| PICONMETRICSW :: ^ICONMETRICSW; | |
| LPICONMETRICSW :: ^ICONMETRICSW; | |
| ICONMETRICS :: ICONMETRICSA; | |
| PICONMETRICS :: PICONMETRICSA; | |
| LPICONMETRICS :: LPICONMETRICSA; | |
| ANIMATIONINFO :: struct { | |
| cbSize : UINT, | |
| iMinAnimate : _c.int, | |
| }; | |
| LPANIMATIONINFO :: ^ANIMATIONINFO; | |
| SERIALKEYSA :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| lpszActivePort : LPSTR, | |
| lpszPort : LPSTR, | |
| iBaudRate : UINT, | |
| iPortState : UINT, | |
| iActive : UINT, | |
| }; | |
| LPSERIALKEYSA :: ^SERIALKEYSA; | |
| SERIALKEYSW :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| lpszActivePort : LPWSTR, | |
| lpszPort : LPWSTR, | |
| iBaudRate : UINT, | |
| iPortState : UINT, | |
| iActive : UINT, | |
| }; | |
| LPSERIALKEYSW :: ^SERIALKEYSW; | |
| SERIALKEYS :: SERIALKEYSA; | |
| LPSERIALKEYS :: LPSERIALKEYSA; | |
| HIGHCONTRASTA :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| lpszDefaultScheme : LPSTR, | |
| }; | |
| LPHIGHCONTRASTA :: ^HIGHCONTRASTA; | |
| HIGHCONTRASTW :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| lpszDefaultScheme : LPWSTR, | |
| }; | |
| LPHIGHCONTRASTW :: ^HIGHCONTRASTW; | |
| HIGHCONTRAST :: HIGHCONTRASTA; | |
| LPHIGHCONTRAST :: LPHIGHCONTRASTA; | |
| VIDEOPARAMETERS :: struct { | |
| Guid : GUID, | |
| dwOffset : ULONG, | |
| dwCommand : ULONG, | |
| dwFlags : ULONG, | |
| dwMode : ULONG, | |
| dwTVStandard : ULONG, | |
| dwAvailableModes : ULONG, | |
| dwAvailableTVStandard : ULONG, | |
| dwFlickerFilter : ULONG, | |
| dwOverScanX : ULONG, | |
| dwOverScanY : ULONG, | |
| dwMaxUnscaledX : ULONG, | |
| dwMaxUnscaledY : ULONG, | |
| dwPositionX : ULONG, | |
| dwPositionY : ULONG, | |
| dwBrightness : ULONG, | |
| dwContrast : ULONG, | |
| dwCPType : ULONG, | |
| dwCPCommand : ULONG, | |
| dwCPStandard : ULONG, | |
| dwCPKey : ULONG, | |
| bCP_APSTriggerBits : ULONG, | |
| bOEMCopyProtection : [256]UCHAR, | |
| }; | |
| PVIDEOPARAMETERS :: ^VIDEOPARAMETERS; | |
| LPVIDEOPARAMETERS :: ^VIDEOPARAMETERS; | |
| FILTERKEYS :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| iWaitMSec : DWORD, | |
| iDelayMSec : DWORD, | |
| iRepeatMSec : DWORD, | |
| iBounceMSec : DWORD, | |
| }; | |
| LPFILTERKEYS :: ^FILTERKEYS; | |
| STICKYKEYS :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| }; | |
| LPSTICKYKEYS :: ^STICKYKEYS; | |
| MOUSEKEYS :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| iMaxSpeed : DWORD, | |
| iTimeToMaxSpeed : DWORD, | |
| iCtrlSpeed : DWORD, | |
| dwReserved1 : DWORD, | |
| dwReserved2 : DWORD, | |
| }; | |
| LPMOUSEKEYS :: ^MOUSEKEYS; | |
| ACCESSTIMEOUT :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| iTimeOutMSec : DWORD, | |
| }; | |
| LPACCESSTIMEOUT :: ^ACCESSTIMEOUT; | |
| SOUNDSENTRYA :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| iFSTextEffect : DWORD, | |
| iFSTextEffectMSec : DWORD, | |
| iFSTextEffectColorBits : DWORD, | |
| iFSGrafEffect : DWORD, | |
| iFSGrafEffectMSec : DWORD, | |
| iFSGrafEffectColor : DWORD, | |
| iWindowsEffect : DWORD, | |
| iWindowsEffectMSec : DWORD, | |
| lpszWindowsEffectDLL : LPSTR, | |
| iWindowsEffectOrdinal : DWORD, | |
| }; | |
| LPSOUNDSENTRYA :: ^SOUNDSENTRYA; | |
| SOUNDSENTRYW :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| iFSTextEffect : DWORD, | |
| iFSTextEffectMSec : DWORD, | |
| iFSTextEffectColorBits : DWORD, | |
| iFSGrafEffect : DWORD, | |
| iFSGrafEffectMSec : DWORD, | |
| iFSGrafEffectColor : DWORD, | |
| iWindowsEffect : DWORD, | |
| iWindowsEffectMSec : DWORD, | |
| lpszWindowsEffectDLL : LPWSTR, | |
| iWindowsEffectOrdinal : DWORD, | |
| }; | |
| LPSOUNDSENTRYW :: ^SOUNDSENTRYW; | |
| SOUNDSENTRY :: SOUNDSENTRYA; | |
| LPSOUNDSENTRY :: LPSOUNDSENTRYA; | |
| TOGGLEKEYS :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| }; | |
| LPTOGGLEKEYS :: ^TOGGLEKEYS; | |
| AUDIODESCRIPTION :: struct { | |
| cbSize : UINT, | |
| Enabled : BOOL, | |
| Locale : LCID, | |
| }; | |
| LPAUDIODESCRIPTION :: ^AUDIODESCRIPTION; | |
| MONITORINFO :: struct { | |
| cbSize : DWORD, | |
| rcMonitor : RECT, | |
| rcWork : RECT, | |
| dwFlags : DWORD, | |
| }; | |
| LPMONITORINFO :: ^MONITORINFO; | |
| MONITORINFOEXA :: struct { | |
| s : MONITORINFO, | |
| szDevice : [32]CHAR, | |
| }; | |
| LPMONITORINFOEXA :: ^MONITORINFOEXA; | |
| MONITORINFOEXW :: struct { | |
| s : MONITORINFO, | |
| szDevice : [32]WCHAR, | |
| }; | |
| LPMONITORINFOEXW :: ^MONITORINFOEXW; | |
| MONITORINFOEX :: MONITORINFOEXA; | |
| LPMONITORINFOEX :: LPMONITORINFOEXA; | |
| MONITORENUMPROC :: (proc "stdcall" (HMONITOR, HDC, LPRECT, LPARAM) -> BOOL); | |
| WINEVENTPROC :: proc "stdcall" (hWinEventHook : HWINEVENTHOOK, event : DWORD, hwnd : HWND, idObject : LONG, idChild : LONG, idEventThread : DWORD, dwmsEventTime : DWORD); | |
| GUITHREADINFO :: struct { | |
| cbSize : DWORD, | |
| flags : DWORD, | |
| hwndActive : HWND, | |
| hwndFocus : HWND, | |
| hwndCapture : HWND, | |
| hwndMenuOwner : HWND, | |
| hwndMoveSize : HWND, | |
| hwndCaret : HWND, | |
| rcCaret : RECT, | |
| }; | |
| PGUITHREADINFO :: ^GUITHREADINFO; | |
| LPGUITHREADINFO :: ^GUITHREADINFO; | |
| CURSORINFO :: struct { | |
| cbSize : DWORD, | |
| flags : DWORD, | |
| hCursor : HCURSOR, | |
| ptScreenPos : POINT, | |
| }; | |
| PCURSORINFO :: ^CURSORINFO; | |
| LPCURSORINFO :: ^CURSORINFO; | |
| WINDOWINFO :: struct { | |
| cbSize : DWORD, | |
| rcWindow : RECT, | |
| rcClient : RECT, | |
| dwStyle : DWORD, | |
| dwExStyle : DWORD, | |
| dwWindowStatus : DWORD, | |
| cxWindowBorders : UINT, | |
| cyWindowBorders : UINT, | |
| atomWindowType : ATOM, | |
| wCreatorVersion : WORD, | |
| }; | |
| PWINDOWINFO :: ^WINDOWINFO; | |
| LPWINDOWINFO :: ^WINDOWINFO; | |
| TITLEBARINFO :: struct { | |
| cbSize : DWORD, | |
| rcTitleBar : RECT, | |
| rgstate : [5 + 1]DWORD, | |
| }; | |
| PTITLEBARINFO :: ^TITLEBARINFO; | |
| LPTITLEBARINFO :: ^TITLEBARINFO; | |
| TITLEBARINFOEX :: struct { | |
| cbSize : DWORD, | |
| rcTitleBar : RECT, | |
| rgstate : [5 + 1]DWORD, | |
| rgrect : [5 + 1]RECT, | |
| }; | |
| PTITLEBARINFOEX :: ^TITLEBARINFOEX; | |
| LPTITLEBARINFOEX :: ^TITLEBARINFOEX; | |
| MENUBARINFO :: struct { | |
| cbSize : DWORD, | |
| rcBar : RECT, | |
| hMenu : HMENU, | |
| hwndMenu : HWND, | |
| using _ : bit_field { | |
| fBarFocused : 1, | |
| fFocused : 1, | |
| }, | |
| }; | |
| PMENUBARINFO :: ^MENUBARINFO; | |
| LPMENUBARINFO :: ^MENUBARINFO; | |
| SCROLLBARINFO :: struct { | |
| cbSize : DWORD, | |
| rcScrollBar : RECT, | |
| dxyLineButton : _c.int, | |
| xyThumbTop : _c.int, | |
| xyThumbBottom : _c.int, | |
| reserved : _c.int, | |
| rgstate : [5 + 1]DWORD, | |
| }; | |
| PSCROLLBARINFO :: ^SCROLLBARINFO; | |
| LPSCROLLBARINFO :: ^SCROLLBARINFO; | |
| COMBOBOXINFO :: struct { | |
| cbSize : DWORD, | |
| rcItem : RECT, | |
| rcButton : RECT, | |
| stateButton : DWORD, | |
| hwndCombo : HWND, | |
| hwndItem : HWND, | |
| hwndList : HWND, | |
| }; | |
| PCOMBOBOXINFO :: ^COMBOBOXINFO; | |
| LPCOMBOBOXINFO :: ^COMBOBOXINFO; | |
| ALTTABINFO :: struct { | |
| cbSize : DWORD, | |
| cItems : _c.int, | |
| cColumns : _c.int, | |
| cRows : _c.int, | |
| iColFocus : _c.int, | |
| iRowFocus : _c.int, | |
| cxItem : _c.int, | |
| cyItem : _c.int, | |
| ptStart : POINT, | |
| }; | |
| PALTTABINFO :: ^ALTTABINFO; | |
| LPALTTABINFO :: ^ALTTABINFO; | |
| HRAWINPUT__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HRAWINPUT :: ^HRAWINPUT__; | |
| RAWINPUTHEADER :: struct { | |
| dwType : DWORD, | |
| dwSize : DWORD, | |
| hDevice : HANDLE, | |
| wParam : WPARAM, | |
| }; | |
| PRAWINPUTHEADER :: ^RAWINPUTHEADER; | |
| LPRAWINPUTHEADER :: ^RAWINPUTHEADER; | |
| RAWMOUSE :: struct { | |
| usFlags : USHORT, | |
| u : struct #raw_union { | |
| ulButtons : ULONG, | |
| s : struct { | |
| usButtonFlags : USHORT, | |
| usButtonData : USHORT, | |
| }, | |
| }, | |
| ulRawButtons : ULONG, | |
| lLastX : LONG, | |
| lLastY : LONG, | |
| ulExtraInformation : ULONG, | |
| }; | |
| PRAWMOUSE :: ^RAWMOUSE; | |
| LPRAWMOUSE :: ^RAWMOUSE; | |
| RAWKEYBOARD :: struct { | |
| MakeCode : USHORT, | |
| Flags : USHORT, | |
| Reserved : USHORT, | |
| VKey : USHORT, | |
| Message : UINT, | |
| ExtraInformation : ULONG, | |
| }; | |
| PRAWKEYBOARD :: ^RAWKEYBOARD; | |
| LPRAWKEYBOARD :: ^RAWKEYBOARD; | |
| RAWHID :: struct { | |
| dwSizeHid : DWORD, | |
| dwCount : DWORD, | |
| bRawData : [1]BYTE, | |
| }; | |
| PRAWHID :: ^RAWHID; | |
| LPRAWHID :: ^RAWHID; | |
| RAWINPUT :: struct { | |
| header : RAWINPUTHEADER, | |
| data : struct #raw_union { | |
| mouse : RAWMOUSE, | |
| keyboard : RAWKEYBOARD, | |
| hid : RAWHID, | |
| }, | |
| }; | |
| PRAWINPUT :: ^RAWINPUT; | |
| LPRAWINPUT :: ^RAWINPUT; | |
| RID_DEVICE_INFO_MOUSE :: struct { | |
| dwId : DWORD, | |
| dwNumberOfButtons : DWORD, | |
| dwSampleRate : DWORD, | |
| fHasHorizontalWheel : BOOL, | |
| }; | |
| PRID_DEVICE_INFO_MOUSE :: ^RID_DEVICE_INFO_MOUSE; | |
| RID_DEVICE_INFO_KEYBOARD :: struct { | |
| dwType : DWORD, | |
| dwSubType : DWORD, | |
| dwKeyboardMode : DWORD, | |
| dwNumberOfFunctionKeys : DWORD, | |
| dwNumberOfIndicators : DWORD, | |
| dwNumberOfKeysTotal : DWORD, | |
| }; | |
| PRID_DEVICE_INFO_KEYBOARD :: ^RID_DEVICE_INFO_KEYBOARD; | |
| RID_DEVICE_INFO_HID :: struct { | |
| dwVendorId : DWORD, | |
| dwProductId : DWORD, | |
| dwVersionNumber : DWORD, | |
| usUsagePage : USHORT, | |
| usUsage : USHORT, | |
| }; | |
| PRID_DEVICE_INFO_HID :: ^RID_DEVICE_INFO_HID; | |
| RID_DEVICE_INFO :: struct { | |
| cbSize : DWORD, | |
| dwType : DWORD, | |
| u : struct #raw_union { | |
| mouse : RID_DEVICE_INFO_MOUSE, | |
| keyboard : RID_DEVICE_INFO_KEYBOARD, | |
| hid : RID_DEVICE_INFO_HID, | |
| }, | |
| }; | |
| PRID_DEVICE_INFO :: ^RID_DEVICE_INFO; | |
| LPRID_DEVICE_INFO :: ^RID_DEVICE_INFO; | |
| RAWINPUTDEVICE :: struct { | |
| usUsagePage : USHORT, | |
| usUsage : USHORT, | |
| dwFlags : DWORD, | |
| hwndTarget : HWND, | |
| }; | |
| PRAWINPUTDEVICE :: ^RAWINPUTDEVICE; | |
| LPRAWINPUTDEVICE :: ^RAWINPUTDEVICE; | |
| PCRAWINPUTDEVICE :: ^RAWINPUTDEVICE; | |
| RAWINPUTDEVICELIST :: struct { | |
| hDevice : HANDLE, | |
| dwType : DWORD, | |
| }; | |
| PRAWINPUTDEVICELIST :: ^RAWINPUTDEVICELIST; | |
| /* POINTER_DEVICE_TYPE :: enum { */ | |
| POINTER_DEVICE_TYPE :: _c.int; | |
| POINTER_DEVICE_TYPE_INTEGRATED_PEN :: 0x00000001; | |
| POINTER_DEVICE_TYPE_EXTERNAL_PEN :: 0x00000002; | |
| POINTER_DEVICE_TYPE_TOUCH :: 0x00000003; | |
| POINTER_DEVICE_TYPE_TOUCH_PAD :: 0x00000004; | |
| POINTER_DEVICE_TYPE_MAX :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| POINTER_DEVICE_INFO :: struct { | |
| displayOrientation : DWORD, | |
| device : HANDLE, | |
| pointerDeviceType : POINTER_DEVICE_TYPE, | |
| monitor : HMONITOR, | |
| startingCursorId : ULONG, | |
| maxActiveContacts : USHORT, | |
| productString : [520]WCHAR, | |
| }; | |
| POINTER_DEVICE_PROPERTY :: struct { | |
| logicalMin : INT32, | |
| logicalMax : INT32, | |
| physicalMin : INT32, | |
| physicalMax : INT32, | |
| unit : UINT32, | |
| unitExponent : UINT32, | |
| usagePageId : USHORT, | |
| usageId : USHORT, | |
| }; | |
| /* POINTER_DEVICE_CURSOR_TYPE :: enum { */ | |
| POINTER_DEVICE_CURSOR_TYPE :: _c.int; | |
| POINTER_DEVICE_CURSOR_TYPE_UNKNOWN :: 0x00000000; | |
| POINTER_DEVICE_CURSOR_TYPE_TIP :: 0x00000001; | |
| POINTER_DEVICE_CURSOR_TYPE_ERASER :: 0x00000002; | |
| POINTER_DEVICE_CURSOR_TYPE_MAX :: 0xFFFFFFFF; | |
| /* } */ | |
| ; | |
| POINTER_DEVICE_CURSOR_INFO :: struct { | |
| cursorId : UINT32, | |
| cursor : POINTER_DEVICE_CURSOR_TYPE, | |
| }; | |
| CHANGEFILTERSTRUCT :: struct { | |
| cbSize : DWORD, | |
| ExtStatus : DWORD, | |
| }; | |
| PCHANGEFILTERSTRUCT :: ^CHANGEFILTERSTRUCT; | |
| HGESTUREINFO__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HGESTUREINFO :: ^HGESTUREINFO__; | |
| GESTUREINFO :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| dwID : DWORD, | |
| hwndTarget : HWND, | |
| ptsLocation : POINTS, | |
| dwInstanceID : DWORD, | |
| dwSequenceID : DWORD, | |
| ullArguments : ULONGLONG, | |
| cbExtraArgs : UINT, | |
| }; | |
| PGESTUREINFO :: ^GESTUREINFO; | |
| PCGESTUREINFO :: ^GESTUREINFO; | |
| GESTURENOTIFYSTRUCT :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| hwndTarget : HWND, | |
| ptsLocation : POINTS, | |
| dwInstanceID : DWORD, | |
| }; | |
| PGESTURENOTIFYSTRUCT :: ^GESTURENOTIFYSTRUCT; | |
| GESTURECONFIG :: struct { | |
| dwID : DWORD, | |
| dwWant : DWORD, | |
| dwBlock : DWORD, | |
| }; | |
| PGESTURECONFIG :: ^GESTURECONFIG; | |
| /* INPUT_MESSAGE_DEVICE_TYPE :: enum { */ | |
| INPUT_MESSAGE_DEVICE_TYPE :: _c.int; | |
| IMDT_UNAVAILABLE :: 0x00000000; | |
| IMDT_KEYBOARD :: 0x00000001; | |
| IMDT_MOUSE :: 0x00000002; | |
| IMDT_TOUCH :: 0x00000004; | |
| IMDT_PEN :: 0x00000008; | |
| IMDT_TOUCHPAD :: 0x00000010; | |
| /* } */ | |
| ; | |
| /* INPUT_MESSAGE_ORIGIN_ID :: enum { */ | |
| INPUT_MESSAGE_ORIGIN_ID :: _c.int; | |
| IMO_UNAVAILABLE :: 0x00000000; | |
| IMO_HARDWARE :: 0x00000001; | |
| IMO_INJECTED :: 0x00000002; | |
| IMO_SYSTEM :: 0x00000004; | |
| /* } */ | |
| ; | |
| INPUT_MESSAGE_SOURCE :: struct { | |
| deviceType : INPUT_MESSAGE_DEVICE_TYPE, | |
| originId : INPUT_MESSAGE_ORIGIN_ID, | |
| }; | |
| /* AR_STATE :: enum { */ | |
| AR_STATE :: _c.int; | |
| AR_ENABLED :: 0x0; | |
| AR_DISABLED :: 0x1; | |
| AR_SUPPRESSED :: 0x2; | |
| AR_REMOTESESSION :: 0x4; | |
| AR_MULTIMON :: 0x8; | |
| AR_NOSENSOR :: 0x10; | |
| AR_NOT_SUPPORTED :: 0x20; | |
| AR_DOCKED :: 0x40; | |
| AR_LAPTOP :: 0x80; | |
| /* } */ | |
| PAR_STATE :: ^AR_STATE; | |
| /* ORIENTATION_PREFERENCE :: enum { */ | |
| ORIENTATION_PREFERENCE :: _c.int; | |
| ORIENTATION_PREFERENCE_NONE :: 0x0; | |
| ORIENTATION_PREFERENCE_LANDSCAPE :: 0x1; | |
| ORIENTATION_PREFERENCE_PORTRAIT :: 0x2; | |
| ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED :: 0x4; | |
| ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED :: 0x8; | |
| /* } */ | |
| ; | |
| LGRPID :: DWORD; | |
| LCTYPE :: DWORD; | |
| CALTYPE :: DWORD; | |
| CALID :: DWORD; | |
| CPINFO :: struct { | |
| MaxCharSize : UINT, | |
| DefaultChar : [2]BYTE, | |
| LeadByte : [12]BYTE, | |
| }; | |
| LPCPINFO :: ^CPINFO; | |
| GEOTYPE :: DWORD; | |
| GEOCLASS :: DWORD; | |
| GEOID :: LONG; | |
| CPINFOEXA :: struct { | |
| MaxCharSize : UINT, | |
| DefaultChar : [2]BYTE, | |
| LeadByte : [12]BYTE, | |
| UnicodeDefaultChar : WCHAR, | |
| CodePage : UINT, | |
| CodePageName : [260]CHAR, | |
| }; | |
| LPCPINFOEXA :: ^CPINFOEXA; | |
| CPINFOEXW :: struct { | |
| MaxCharSize : UINT, | |
| DefaultChar : [2]BYTE, | |
| LeadByte : [12]BYTE, | |
| UnicodeDefaultChar : WCHAR, | |
| CodePage : UINT, | |
| CodePageName : [260]WCHAR, | |
| }; | |
| LPCPINFOEXW :: ^CPINFOEXW; | |
| CPINFOEX :: CPINFOEXA; | |
| LPCPINFOEX :: LPCPINFOEXA; | |
| NUMBERFMTA :: struct { | |
| NumDigits : UINT, | |
| LeadingZero : UINT, | |
| Grouping : UINT, | |
| lpDecimalSep : LPSTR, | |
| lpThousandSep : LPSTR, | |
| NegativeOrder : UINT, | |
| }; | |
| LPNUMBERFMTA :: ^NUMBERFMTA; | |
| NUMBERFMTW :: struct { | |
| NumDigits : UINT, | |
| LeadingZero : UINT, | |
| Grouping : UINT, | |
| lpDecimalSep : LPWSTR, | |
| lpThousandSep : LPWSTR, | |
| NegativeOrder : UINT, | |
| }; | |
| LPNUMBERFMTW :: ^NUMBERFMTW; | |
| NUMBERFMT :: NUMBERFMTA; | |
| LPNUMBERFMT :: LPNUMBERFMTA; | |
| CURRENCYFMTA :: struct { | |
| NumDigits : UINT, | |
| LeadingZero : UINT, | |
| Grouping : UINT, | |
| lpDecimalSep : LPSTR, | |
| lpThousandSep : LPSTR, | |
| NegativeOrder : UINT, | |
| PositiveOrder : UINT, | |
| lpCurrencySymbol : LPSTR, | |
| }; | |
| LPCURRENCYFMTA :: ^CURRENCYFMTA; | |
| CURRENCYFMTW :: struct { | |
| NumDigits : UINT, | |
| LeadingZero : UINT, | |
| Grouping : UINT, | |
| lpDecimalSep : LPWSTR, | |
| lpThousandSep : LPWSTR, | |
| NegativeOrder : UINT, | |
| PositiveOrder : UINT, | |
| lpCurrencySymbol : LPWSTR, | |
| }; | |
| LPCURRENCYFMTW :: ^CURRENCYFMTW; | |
| CURRENCYFMT :: CURRENCYFMTA; | |
| LPCURRENCYFMT :: LPCURRENCYFMTA; | |
| /* SYSNLS_FUNCTION :: enum { */ | |
| SYSNLS_FUNCTION :: _c.int; | |
| COMPARE_STRING :: 0x0001; | |
| /* } */ | |
| ; | |
| NLS_FUNCTION :: DWORD; | |
| NLSVERSIONINFO :: struct { | |
| dwNLSVersionInfoSize : DWORD, | |
| dwNLSVersion : DWORD, | |
| dwDefinedVersion : DWORD, | |
| dwEffectiveId : DWORD, | |
| guidCustomVersion : GUID, | |
| }; | |
| LPNLSVERSIONINFO :: ^NLSVERSIONINFO; | |
| NLSVERSIONINFOEX :: struct { | |
| dwNLSVersionInfoSize : DWORD, | |
| dwNLSVersion : DWORD, | |
| dwDefinedVersion : DWORD, | |
| dwEffectiveId : DWORD, | |
| guidCustomVersion : GUID, | |
| }; | |
| LPNLSVERSIONINFOEX :: ^NLSVERSIONINFOEX; | |
| /* SYSGEOTYPE :: enum { */ | |
| SYSGEOTYPE :: _c.int; | |
| GEO_NATION :: 0x0001; | |
| GEO_LATITUDE :: 0x0002; | |
| GEO_LONGITUDE :: 0x0003; | |
| GEO_ISO2 :: 0x0004; | |
| GEO_ISO3 :: 0x0005; | |
| GEO_RFC1766 :: 0x0006; | |
| GEO_LCID :: 0x0007; | |
| GEO_FRIENDLYNAME :: 0x0008; | |
| GEO_OFFICIALNAME :: 0x0009; | |
| GEO_TIMEZONES :: 0x000A; | |
| GEO_OFFICIALLANGUAGES :: 0x000B; | |
| GEO_ISO_UN_NUMBER :: 0x000C; | |
| GEO_PARENT :: 0x000D; | |
| GEO_DIALINGCODE :: 0x000E; | |
| GEO_CURRENCYCODE :: 0x000F; | |
| GEO_CURRENCYSYMBOL :: 0x0010; | |
| GEO_NAME :: 0x0011; | |
| GEO_ID :: 0x0012; | |
| /* } */ | |
| ; | |
| /* SYSGEOCLASS :: enum { */ | |
| SYSGEOCLASS :: _c.int; | |
| GEOCLASS_NATION :: 16; | |
| GEOCLASS_REGION :: 14; | |
| GEOCLASS_ALL :: 0; | |
| /* } */ | |
| ; | |
| /* NORM_FORM :: enum { */ | |
| NORM_FORM :: _c.int; | |
| NormalizationOther :: 0; | |
| NormalizationC :: 0x1; | |
| NormalizationD :: 0x2; | |
| NormalizationKC :: 0x5; | |
| NormalizationKD :: 0x6; | |
| /* } */ | |
| ; | |
| LANGUAGEGROUP_ENUMPROCA :: (proc "stdcall" (LGRPID, LPSTR, LPSTR, DWORD, LONG_PTR) -> BOOL); | |
| LANGGROUPLOCALE_ENUMPROCA :: (proc "stdcall" (LGRPID, LCID, LPSTR, LONG_PTR) -> BOOL); | |
| UILANGUAGE_ENUMPROCA :: (proc "stdcall" (LPSTR, LONG_PTR) -> BOOL); | |
| CODEPAGE_ENUMPROCA :: (proc "stdcall" (LPSTR) -> BOOL); | |
| DATEFMT_ENUMPROCA :: (proc "stdcall" (LPSTR) -> BOOL); | |
| DATEFMT_ENUMPROCEXA :: (proc "stdcall" (LPSTR, CALID) -> BOOL); | |
| TIMEFMT_ENUMPROCA :: (proc "stdcall" (LPSTR) -> BOOL); | |
| CALINFO_ENUMPROCA :: (proc "stdcall" (LPSTR) -> BOOL); | |
| CALINFO_ENUMPROCEXA :: (proc "stdcall" (LPSTR, CALID) -> BOOL); | |
| LOCALE_ENUMPROCA :: (proc "stdcall" (LPSTR) -> BOOL); | |
| LOCALE_ENUMPROCW :: (proc "stdcall" (LPWSTR) -> BOOL); | |
| LANGUAGEGROUP_ENUMPROCW :: (proc "stdcall" (LGRPID, LPWSTR, LPWSTR, DWORD, LONG_PTR) -> BOOL); | |
| LANGGROUPLOCALE_ENUMPROCW :: (proc "stdcall" (LGRPID, LCID, LPWSTR, LONG_PTR) -> BOOL); | |
| UILANGUAGE_ENUMPROCW :: (proc "stdcall" (LPWSTR, LONG_PTR) -> BOOL); | |
| CODEPAGE_ENUMPROCW :: (proc "stdcall" (LPWSTR) -> BOOL); | |
| DATEFMT_ENUMPROCW :: (proc "stdcall" (LPWSTR) -> BOOL); | |
| DATEFMT_ENUMPROCEXW :: (proc "stdcall" (LPWSTR, CALID) -> BOOL); | |
| TIMEFMT_ENUMPROCW :: (proc "stdcall" (LPWSTR) -> BOOL); | |
| CALINFO_ENUMPROCW :: (proc "stdcall" (LPWSTR) -> BOOL); | |
| CALINFO_ENUMPROCEXW :: (proc "stdcall" (LPWSTR, CALID) -> BOOL); | |
| GEO_ENUMPROC :: (proc "stdcall" (GEOID) -> BOOL); | |
| GEO_ENUMNAMEPROC :: (proc "stdcall" (PWSTR, LPARAM) -> BOOL); | |
| FILEMUIINFO :: struct { | |
| dwSize : DWORD, | |
| dwVersion : DWORD, | |
| dwFileType : DWORD, | |
| pChecksum : [16]BYTE, | |
| pServiceChecksum : [16]BYTE, | |
| dwLanguageNameOffset : DWORD, | |
| dwTypeIDMainSize : DWORD, | |
| dwTypeIDMainOffset : DWORD, | |
| dwTypeNameMainOffset : DWORD, | |
| dwTypeIDMUISize : DWORD, | |
| dwTypeIDMUIOffset : DWORD, | |
| dwTypeNameMUIOffset : DWORD, | |
| abBuffer : [8]BYTE, | |
| }; | |
| PFILEMUIINFO :: ^FILEMUIINFO; | |
| CALINFO_ENUMPROCEXEX :: (proc "stdcall" (LPWSTR, CALID, LPWSTR, LPARAM) -> BOOL); | |
| DATEFMT_ENUMPROCEXEX :: (proc "stdcall" (LPWSTR, CALID, LPARAM) -> BOOL); | |
| TIMEFMT_ENUMPROCEX :: (proc "stdcall" (LPWSTR, LPARAM) -> BOOL); | |
| LOCALE_ENUMPROCEX :: (proc "stdcall" (LPWSTR, DWORD, LPARAM) -> BOOL); | |
| COORD :: struct { | |
| X : SHORT, | |
| Y : SHORT, | |
| }; | |
| PCOORD :: ^COORD; | |
| SMALL_RECT :: struct { | |
| Left : SHORT, | |
| Top : SHORT, | |
| Right : SHORT, | |
| Bottom : SHORT, | |
| }; | |
| PSMALL_RECT :: ^SMALL_RECT; | |
| KEY_EVENT_RECORD :: struct { | |
| bKeyDown : BOOL, | |
| wRepeatCount : WORD, | |
| wVirtualKeyCode : WORD, | |
| wVirtualScanCode : WORD, | |
| uChar : struct #raw_union { | |
| UnicodeChar : WCHAR, | |
| AsciiChar : CHAR, | |
| }, | |
| dwControlKeyState : DWORD, | |
| }; | |
| PKEY_EVENT_RECORD :: ^KEY_EVENT_RECORD; | |
| MOUSE_EVENT_RECORD :: struct { | |
| dwMousePosition : COORD, | |
| dwButtonState : DWORD, | |
| dwControlKeyState : DWORD, | |
| dwEventFlags : DWORD, | |
| }; | |
| PMOUSE_EVENT_RECORD :: ^MOUSE_EVENT_RECORD; | |
| WINDOW_BUFFER_SIZE_RECORD :: struct { | |
| dwSize : COORD, | |
| }; | |
| PWINDOW_BUFFER_SIZE_RECORD :: ^WINDOW_BUFFER_SIZE_RECORD; | |
| MENU_EVENT_RECORD :: struct { | |
| dwCommandId : UINT, | |
| }; | |
| PMENU_EVENT_RECORD :: ^MENU_EVENT_RECORD; | |
| FOCUS_EVENT_RECORD :: struct { | |
| bSetFocus : BOOL, | |
| }; | |
| PFOCUS_EVENT_RECORD :: ^FOCUS_EVENT_RECORD; | |
| INPUT_RECORD :: struct { | |
| EventType : WORD, | |
| Event : struct #raw_union { | |
| KeyEvent : KEY_EVENT_RECORD, | |
| MouseEvent : MOUSE_EVENT_RECORD, | |
| WindowBufferSizeEvent : WINDOW_BUFFER_SIZE_RECORD, | |
| MenuEvent : MENU_EVENT_RECORD, | |
| FocusEvent : FOCUS_EVENT_RECORD, | |
| }, | |
| }; | |
| PINPUT_RECORD :: ^INPUT_RECORD; | |
| CHAR_INFO :: struct { | |
| Char : struct #raw_union { | |
| UnicodeChar : WCHAR, | |
| AsciiChar : CHAR, | |
| }, | |
| Attributes : WORD, | |
| }; | |
| PCHAR_INFO :: ^CHAR_INFO; | |
| CONSOLE_FONT_INFO :: struct { | |
| nFont : DWORD, | |
| dwFontSize : COORD, | |
| }; | |
| PCONSOLE_FONT_INFO :: ^CONSOLE_FONT_INFO; | |
| HPCON :: rawptr; | |
| CONSOLE_READCONSOLE_CONTROL :: struct { | |
| nLength : ULONG, | |
| nInitialChars : ULONG, | |
| dwCtrlWakeupMask : ULONG, | |
| dwControlKeyState : ULONG, | |
| }; | |
| PCONSOLE_READCONSOLE_CONTROL :: ^CONSOLE_READCONSOLE_CONTROL; | |
| PHANDLER_ROUTINE :: (proc "stdcall" (CtrlType : DWORD) -> BOOL); | |
| CONSOLE_CURSOR_INFO :: struct { | |
| dwSize : DWORD, | |
| bVisible : BOOL, | |
| }; | |
| PCONSOLE_CURSOR_INFO :: ^CONSOLE_CURSOR_INFO; | |
| CONSOLE_SCREEN_BUFFER_INFO :: struct { | |
| dwSize : COORD, | |
| dwCursorPosition : COORD, | |
| wAttributes : WORD, | |
| srWindow : SMALL_RECT, | |
| dwMaximumWindowSize : COORD, | |
| }; | |
| PCONSOLE_SCREEN_BUFFER_INFO :: ^CONSOLE_SCREEN_BUFFER_INFO; | |
| CONSOLE_SCREEN_BUFFER_INFOEX :: struct { | |
| cbSize : ULONG, | |
| dwSize : COORD, | |
| dwCursorPosition : COORD, | |
| wAttributes : WORD, | |
| srWindow : SMALL_RECT, | |
| dwMaximumWindowSize : COORD, | |
| wPopupAttributes : WORD, | |
| bFullscreenSupported : BOOL, | |
| ColorTable : [16]COLORREF, | |
| }; | |
| PCONSOLE_SCREEN_BUFFER_INFOEX :: ^CONSOLE_SCREEN_BUFFER_INFOEX; | |
| CONSOLE_FONT_INFOEX :: struct { | |
| cbSize : ULONG, | |
| nFont : DWORD, | |
| dwFontSize : COORD, | |
| FontFamily : UINT, | |
| FontWeight : UINT, | |
| FaceName : [32]WCHAR, | |
| }; | |
| PCONSOLE_FONT_INFOEX :: ^CONSOLE_FONT_INFOEX; | |
| CONSOLE_SELECTION_INFO :: struct { | |
| dwFlags : DWORD, | |
| dwSelectionAnchor : COORD, | |
| srSelection : SMALL_RECT, | |
| }; | |
| PCONSOLE_SELECTION_INFO :: ^CONSOLE_SELECTION_INFO; | |
| CONSOLE_HISTORY_INFO :: struct { | |
| cbSize : UINT, | |
| HistoryBufferSize : UINT, | |
| NumberOfHistoryBuffers : UINT, | |
| dwFlags : DWORD, | |
| }; | |
| PCONSOLE_HISTORY_INFO :: ^CONSOLE_HISTORY_INFO; | |
| VS_FIXEDFILEINFO :: struct { | |
| 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, | |
| }; | |
| LSTATUS :: LONG; | |
| REGSAM :: ACCESS_MASK; | |
| val_context :: struct { | |
| valuelen : _c.int, | |
| value_context : LPVOID, | |
| val_buff_ptr : LPVOID, | |
| }; | |
| PVALCONTEXT :: ^val_context; | |
| PVALUEA :: struct { | |
| pv_valuename : LPSTR, | |
| pv_valuelen : _c.int, | |
| pv_value_context : LPVOID, | |
| pv_type : DWORD, | |
| }; | |
| PPVALUEA :: ^PVALUEA; | |
| PVALUEW :: struct { | |
| pv_valuename : LPWSTR, | |
| pv_valuelen : _c.int, | |
| pv_value_context : LPVOID, | |
| pv_type : DWORD, | |
| }; | |
| PPVALUEW :: ^PVALUEW; | |
| PVALUE :: PVALUEA; | |
| PPVALUE :: PPVALUEA; | |
| QUERYHANDLER :: #type (proc(keycontext : LPVOID, val_list : PVALCONTEXT, num_vals : DWORD, outputbuffer : LPVOID, total_outlen : ^DWORD, input_blen : DWORD) -> DWORD); | |
| PQUERYHANDLER :: ^QUERYHANDLER; | |
| REG_PROVIDER :: struct { | |
| pi_R0_1val : PQUERYHANDLER, | |
| pi_R0_allvals : PQUERYHANDLER, | |
| pi_R3_1val : PQUERYHANDLER, | |
| pi_R3_allvals : PQUERYHANDLER, | |
| pi_flags : DWORD, | |
| pi_key_context : LPVOID, | |
| }; | |
| PPROVIDER :: ^REG_PROVIDER; | |
| VALENTA :: struct { | |
| ve_valuename : LPSTR, | |
| ve_valuelen : DWORD, | |
| ve_valueptr : DWORD_PTR, | |
| ve_type : DWORD, | |
| }; | |
| PVALENTA :: ^VALENTA; | |
| VALENTW :: struct { | |
| ve_valuename : LPWSTR, | |
| ve_valuelen : DWORD, | |
| ve_valueptr : DWORD_PTR, | |
| ve_type : DWORD, | |
| }; | |
| PVALENTW :: ^VALENTW; | |
| VALENT :: VALENTA; | |
| PVALENT :: PVALENTA; | |
| NETRESOURCEA :: struct { | |
| dwScope : DWORD, | |
| dwType : DWORD, | |
| dwDisplayType : DWORD, | |
| dwUsage : DWORD, | |
| lpLocalName : LPSTR, | |
| lpRemoteName : LPSTR, | |
| lpComment : LPSTR, | |
| lpProvider : LPSTR, | |
| }; | |
| LPNETRESOURCEA :: ^NETRESOURCEA; | |
| NETRESOURCEW :: struct { | |
| dwScope : DWORD, | |
| dwType : DWORD, | |
| dwDisplayType : DWORD, | |
| dwUsage : DWORD, | |
| lpLocalName : LPWSTR, | |
| lpRemoteName : LPWSTR, | |
| lpComment : LPWSTR, | |
| lpProvider : LPWSTR, | |
| }; | |
| LPNETRESOURCEW :: ^NETRESOURCEW; | |
| NETRESOURCE :: NETRESOURCEA; | |
| LPNETRESOURCE :: LPNETRESOURCEA; | |
| CONNECTDLGSTRUCTA :: struct { | |
| cbStructure : DWORD, | |
| hwndOwner : HWND, | |
| lpConnRes : LPNETRESOURCEA, | |
| dwFlags : DWORD, | |
| dwDevNum : DWORD, | |
| }; | |
| LPCONNECTDLGSTRUCTA :: ^CONNECTDLGSTRUCTA; | |
| CONNECTDLGSTRUCTW :: struct { | |
| cbStructure : DWORD, | |
| hwndOwner : HWND, | |
| lpConnRes : LPNETRESOURCEW, | |
| dwFlags : DWORD, | |
| dwDevNum : DWORD, | |
| }; | |
| LPCONNECTDLGSTRUCTW :: ^CONNECTDLGSTRUCTW; | |
| CONNECTDLGSTRUCT :: CONNECTDLGSTRUCTA; | |
| LPCONNECTDLGSTRUCT :: LPCONNECTDLGSTRUCTA; | |
| DISCDLGSTRUCTA :: struct { | |
| cbStructure : DWORD, | |
| hwndOwner : HWND, | |
| lpLocalName : LPSTR, | |
| lpRemoteName : LPSTR, | |
| dwFlags : DWORD, | |
| }; | |
| LPDISCDLGSTRUCTA :: ^DISCDLGSTRUCTA; | |
| DISCDLGSTRUCTW :: struct { | |
| cbStructure : DWORD, | |
| hwndOwner : HWND, | |
| lpLocalName : LPWSTR, | |
| lpRemoteName : LPWSTR, | |
| dwFlags : DWORD, | |
| }; | |
| LPDISCDLGSTRUCTW :: ^DISCDLGSTRUCTW; | |
| DISCDLGSTRUCT :: DISCDLGSTRUCTA; | |
| LPDISCDLGSTRUCT :: LPDISCDLGSTRUCTA; | |
| UNIVERSAL_NAME_INFOA :: struct { | |
| lpUniversalName : LPSTR, | |
| }; | |
| LPUNIVERSAL_NAME_INFOA :: ^UNIVERSAL_NAME_INFOA; | |
| UNIVERSAL_NAME_INFOW :: struct { | |
| lpUniversalName : LPWSTR, | |
| }; | |
| LPUNIVERSAL_NAME_INFOW :: ^UNIVERSAL_NAME_INFOW; | |
| UNIVERSAL_NAME_INFO :: UNIVERSAL_NAME_INFOA; | |
| LPUNIVERSAL_NAME_INFO :: LPUNIVERSAL_NAME_INFOA; | |
| REMOTE_NAME_INFOA :: struct { | |
| lpUniversalName : LPSTR, | |
| lpConnectionName : LPSTR, | |
| lpRemainingPath : LPSTR, | |
| }; | |
| LPREMOTE_NAME_INFOA :: ^REMOTE_NAME_INFOA; | |
| REMOTE_NAME_INFOW :: struct { | |
| lpUniversalName : LPWSTR, | |
| lpConnectionName : LPWSTR, | |
| lpRemainingPath : LPWSTR, | |
| }; | |
| LPREMOTE_NAME_INFOW :: ^REMOTE_NAME_INFOW; | |
| REMOTE_NAME_INFO :: REMOTE_NAME_INFOA; | |
| LPREMOTE_NAME_INFO :: LPREMOTE_NAME_INFOA; | |
| NETINFOSTRUCT :: struct { | |
| cbStructure : DWORD, | |
| dwProviderVersion : DWORD, | |
| dwStatus : DWORD, | |
| dwCharacteristics : DWORD, | |
| dwHandle : ULONG_PTR, | |
| wNetType : WORD, | |
| dwPrinters : DWORD, | |
| dwDrives : DWORD, | |
| }; | |
| LPNETINFOSTRUCT :: ^NETINFOSTRUCT; | |
| NETCONNECTINFOSTRUCT :: struct { | |
| cbStructure : DWORD, | |
| dwFlags : DWORD, | |
| dwSpeed : DWORD, | |
| dwDelay : DWORD, | |
| dwOptDataSize : DWORD, | |
| }; | |
| LPNETCONNECTINFOSTRUCT :: ^NETCONNECTINFOSTRUCT; | |
| DDEACK :: bit_field { | |
| bAppReturnCode : 8, | |
| reserved : 6, | |
| fBusy : 1, | |
| fAck : 1, | |
| }; | |
| DDEADVISE :: struct { | |
| using _ : bit_field { | |
| reserved : 14, | |
| fDeferUpd : 1, | |
| fAckReq : 1, | |
| }, | |
| cfFormat : _c.short, | |
| }; | |
| DDEDATA :: struct { | |
| using _ : bit_field { | |
| unused : 12, | |
| fResponse : 1, | |
| fRelease : 1, | |
| reserved : 1, | |
| fAckReq : 1, | |
| }, | |
| cfFormat : _c.short, | |
| Value : [1]BYTE, | |
| }; | |
| DDEPOKE :: struct { | |
| using _ : bit_field { | |
| unused : 13, | |
| fRelease : 1, | |
| fReserved : 2, | |
| }, | |
| cfFormat : _c.short, | |
| Value : [1]BYTE, | |
| }; | |
| DDELN :: struct { | |
| using _ : bit_field { | |
| unused : 13, | |
| fRelease : 1, | |
| fDeferUpd : 1, | |
| fAckReq : 1, | |
| }, | |
| cfFormat : _c.short, | |
| }; | |
| DDEUP :: struct { | |
| using _ : bit_field { | |
| unused : 12, | |
| fAck : 1, | |
| fRelease : 1, | |
| fReserved : 1, | |
| fAckReq : 1, | |
| }, | |
| cfFormat : _c.short, | |
| rgb : [1]BYTE, | |
| }; | |
| HCONVLIST__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HCONVLIST :: ^HCONVLIST__; | |
| HCONV__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HCONV :: ^HCONV__; | |
| HSZ__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HSZ :: ^HSZ__; | |
| HDDEDATA__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HDDEDATA :: ^HDDEDATA__; | |
| HSZPAIR :: struct { | |
| hszSvc : HSZ, | |
| hszTopic : HSZ, | |
| }; | |
| PHSZPAIR :: ^HSZPAIR; | |
| CONVCONTEXT :: struct { | |
| cb : UINT, | |
| wFlags : UINT, | |
| wCountryID : UINT, | |
| iCodePage : _c.int, | |
| dwLangID : DWORD, | |
| dwSecurity : DWORD, | |
| qos : SECURITY_QUALITY_OF_SERVICE, | |
| }; | |
| PCONVCONTEXT :: ^CONVCONTEXT; | |
| CONVINFO :: struct { | |
| cb : DWORD, | |
| hUser : DWORD_PTR, | |
| hConvPartner : HCONV, | |
| hszSvcPartner : HSZ, | |
| hszServiceReq : HSZ, | |
| hszTopic : HSZ, | |
| hszItem : HSZ, | |
| wFmt : UINT, | |
| wType : UINT, | |
| wStatus : UINT, | |
| wConvst : UINT, | |
| wLastError : UINT, | |
| hConvList : HCONVLIST, | |
| ConvCtxt : CONVCONTEXT, | |
| hwnd : HWND, | |
| hwndPartner : HWND, | |
| }; | |
| PCONVINFO :: ^CONVINFO; | |
| FNCALLBACK :: #type (proc "stdcall" (wType : UINT, wFmt : UINT, hConv : HCONV, hsz1 : HSZ, hsz2 : HSZ, hData : HDDEDATA, dwData1 : ULONG_PTR, dwData2 : ULONG_PTR) -> HDDEDATA); | |
| PFNCALLBACK :: (proc "stdcall" (wType : UINT, wFmt : UINT, hConv : HCONV, hsz1 : HSZ, hsz2 : HSZ, hData : HDDEDATA, dwData1 : ULONG_PTR, dwData2 : ULONG_PTR) -> HDDEDATA); | |
| DDEML_MSG_HOOK_DATA :: struct { | |
| uiLo : UINT_PTR, | |
| uiHi : UINT_PTR, | |
| cbData : DWORD, | |
| Data : [8]DWORD, | |
| }; | |
| PDDEML_MSG_HOOK_DATA :: ^DDEML_MSG_HOOK_DATA; | |
| MONMSGSTRUCT :: struct { | |
| cb : UINT, | |
| hwndTo : HWND, | |
| dwTime : DWORD, | |
| hTask : HANDLE, | |
| wMsg : UINT, | |
| wParam : WPARAM, | |
| lParam : LPARAM, | |
| dmhd : DDEML_MSG_HOOK_DATA, | |
| }; | |
| PMONMSGSTRUCT :: ^MONMSGSTRUCT; | |
| MONCBSTRUCT :: struct { | |
| cb : UINT, | |
| dwTime : DWORD, | |
| hTask : HANDLE, | |
| dwRet : DWORD, | |
| wType : UINT, | |
| wFmt : UINT, | |
| hConv : HCONV, | |
| hsz1 : HSZ, | |
| hsz2 : HSZ, | |
| hData : HDDEDATA, | |
| dwData1 : ULONG_PTR, | |
| dwData2 : ULONG_PTR, | |
| cc : CONVCONTEXT, | |
| cbData : DWORD, | |
| Data : [8]DWORD, | |
| }; | |
| PMONCBSTRUCT :: ^MONCBSTRUCT; | |
| MONHSZSTRUCTA :: struct { | |
| cb : UINT, | |
| fsAction : BOOL, | |
| dwTime : DWORD, | |
| hsz : HSZ, | |
| hTask : HANDLE, | |
| str : [1]CHAR, | |
| }; | |
| PMONHSZSTRUCTA :: ^MONHSZSTRUCTA; | |
| MONHSZSTRUCTW :: struct { | |
| cb : UINT, | |
| fsAction : BOOL, | |
| dwTime : DWORD, | |
| hsz : HSZ, | |
| hTask : HANDLE, | |
| str : [1]WCHAR, | |
| }; | |
| PMONHSZSTRUCTW :: ^MONHSZSTRUCTW; | |
| MONHSZSTRUCT :: MONHSZSTRUCTA; | |
| PMONHSZSTRUCT :: PMONHSZSTRUCTA; | |
| MONERRSTRUCT :: struct { | |
| cb : UINT, | |
| wLastError : UINT, | |
| dwTime : DWORD, | |
| hTask : HANDLE, | |
| }; | |
| PMONERRSTRUCT :: ^MONERRSTRUCT; | |
| MONLINKSTRUCT :: struct { | |
| cb : UINT, | |
| dwTime : DWORD, | |
| hTask : HANDLE, | |
| fEstablished : BOOL, | |
| fNoData : BOOL, | |
| hszSvc : HSZ, | |
| hszTopic : HSZ, | |
| hszItem : HSZ, | |
| wFmt : UINT, | |
| fServer : BOOL, | |
| hConvServer : HCONV, | |
| hConvClient : HCONV, | |
| }; | |
| PMONLINKSTRUCT :: ^MONLINKSTRUCT; | |
| MONCONVSTRUCT :: struct { | |
| cb : UINT, | |
| fConnect : BOOL, | |
| dwTime : DWORD, | |
| hTask : HANDLE, | |
| hszSvc : HSZ, | |
| hszTopic : HSZ, | |
| hConvClient : HCONV, | |
| hConvServer : HCONV, | |
| }; | |
| PMONCONVSTRUCT :: ^MONCONVSTRUCT; | |
| CRGB :: struct { | |
| bRed : BYTE, | |
| bGreen : BYTE, | |
| bBlue : BYTE, | |
| bExtra : BYTE, | |
| }; | |
| MMVERSION :: UINT; | |
| MMRESULT :: UINT; | |
| LPUINT :: ^UINT; | |
| MMTIME :: struct { | |
| wType : UINT, | |
| u : struct #raw_union { | |
| ms : DWORD, | |
| sample : DWORD, | |
| cb : DWORD, | |
| ticks : DWORD, | |
| smpte : struct { | |
| hour : BYTE, | |
| min : BYTE, | |
| sec : BYTE, | |
| frame : BYTE, | |
| fps : BYTE, | |
| dummy : BYTE, | |
| pad : [2]BYTE, | |
| }, | |
| midi : struct { | |
| songptrpos : DWORD, | |
| }, | |
| }, | |
| }; | |
| PMMTIME :: ^MMTIME; | |
| NPMMTIME :: ^MMTIME; | |
| LPMMTIME :: ^MMTIME; | |
| HDRVR__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HDRVR :: ^HDRVR__; | |
| DRVCALLBACK :: #type proc "stdcall" (hdrvr : HDRVR, uMsg : UINT, dwUser : DWORD_PTR, dw1 : DWORD_PTR, dw2 : DWORD_PTR); | |
| LPDRVCALLBACK :: ^DRVCALLBACK; | |
| PDRVCALLBACK :: ^DRVCALLBACK; | |
| MCIERROR :: DWORD; | |
| MCIDEVICEID :: UINT; | |
| YIELDPROC :: (proc "stdcall" (mciId : MCIDEVICEID, dwYieldData : DWORD) -> UINT); | |
| MCI_GENERIC_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| }; | |
| PMCI_GENERIC_PARMS :: ^MCI_GENERIC_PARMS; | |
| LPMCI_GENERIC_PARMS :: ^MCI_GENERIC_PARMS; | |
| MCI_OPEN_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| wDeviceID : MCIDEVICEID, | |
| lpstrDeviceType : LPCSTR, | |
| lpstrElementName : LPCSTR, | |
| lpstrAlias : LPCSTR, | |
| }; | |
| PMCI_OPEN_PARMSA :: ^MCI_OPEN_PARMSA; | |
| LPMCI_OPEN_PARMSA :: ^MCI_OPEN_PARMSA; | |
| MCI_OPEN_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| wDeviceID : MCIDEVICEID, | |
| lpstrDeviceType : LPCWSTR, | |
| lpstrElementName : LPCWSTR, | |
| lpstrAlias : LPCWSTR, | |
| }; | |
| PMCI_OPEN_PARMSW :: ^MCI_OPEN_PARMSW; | |
| LPMCI_OPEN_PARMSW :: ^MCI_OPEN_PARMSW; | |
| MCI_OPEN_PARMS :: MCI_OPEN_PARMSA; | |
| PMCI_OPEN_PARMS :: PMCI_OPEN_PARMSA; | |
| LPMCI_OPEN_PARMS :: LPMCI_OPEN_PARMSA; | |
| MCI_PLAY_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwFrom : DWORD, | |
| dwTo : DWORD, | |
| }; | |
| PMCI_PLAY_PARMS :: ^MCI_PLAY_PARMS; | |
| LPMCI_PLAY_PARMS :: ^MCI_PLAY_PARMS; | |
| MCI_SEEK_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwTo : DWORD, | |
| }; | |
| PMCI_SEEK_PARMS :: ^MCI_SEEK_PARMS; | |
| LPMCI_SEEK_PARMS :: ^MCI_SEEK_PARMS; | |
| MCI_STATUS_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwReturn : DWORD_PTR, | |
| dwItem : DWORD, | |
| dwTrack : DWORD, | |
| }; | |
| PMCI_STATUS_PARMS :: ^MCI_STATUS_PARMS; | |
| LPMCI_STATUS_PARMS :: ^MCI_STATUS_PARMS; | |
| MCI_INFO_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpstrReturn : LPSTR, | |
| dwRetSize : DWORD, | |
| }; | |
| LPMCI_INFO_PARMSA :: ^MCI_INFO_PARMSA; | |
| MCI_INFO_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpstrReturn : LPWSTR, | |
| dwRetSize : DWORD, | |
| }; | |
| LPMCI_INFO_PARMSW :: ^MCI_INFO_PARMSW; | |
| MCI_INFO_PARMS :: MCI_INFO_PARMSA; | |
| LPMCI_INFO_PARMS :: LPMCI_INFO_PARMSA; | |
| MCI_GETDEVCAPS_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwReturn : DWORD, | |
| dwItem : DWORD, | |
| }; | |
| PMCI_GETDEVCAPS_PARMS :: ^MCI_GETDEVCAPS_PARMS; | |
| LPMCI_GETDEVCAPS_PARMS :: ^MCI_GETDEVCAPS_PARMS; | |
| MCI_SYSINFO_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpstrReturn : LPSTR, | |
| dwRetSize : DWORD, | |
| dwNumber : DWORD, | |
| wDeviceType : UINT, | |
| }; | |
| PMCI_SYSINFO_PARMSA :: ^MCI_SYSINFO_PARMSA; | |
| LPMCI_SYSINFO_PARMSA :: ^MCI_SYSINFO_PARMSA; | |
| MCI_SYSINFO_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpstrReturn : LPWSTR, | |
| dwRetSize : DWORD, | |
| dwNumber : DWORD, | |
| wDeviceType : UINT, | |
| }; | |
| PMCI_SYSINFO_PARMSW :: ^MCI_SYSINFO_PARMSW; | |
| LPMCI_SYSINFO_PARMSW :: ^MCI_SYSINFO_PARMSW; | |
| MCI_SYSINFO_PARMS :: MCI_SYSINFO_PARMSA; | |
| PMCI_SYSINFO_PARMS :: PMCI_SYSINFO_PARMSA; | |
| LPMCI_SYSINFO_PARMS :: LPMCI_SYSINFO_PARMSA; | |
| MCI_SET_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwTimeFormat : DWORD, | |
| dwAudio : DWORD, | |
| }; | |
| PMCI_SET_PARMS :: ^MCI_SET_PARMS; | |
| LPMCI_SET_PARMS :: ^MCI_SET_PARMS; | |
| MCI_BREAK_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| nVirtKey : _c.int, | |
| hwndBreak : HWND, | |
| }; | |
| PMCI_BREAK_PARMS :: ^MCI_BREAK_PARMS; | |
| LPMCI_BREAK_PARMS :: ^MCI_BREAK_PARMS; | |
| MCI_SAVE_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpfilename : LPCSTR, | |
| }; | |
| PMCI_SAVE_PARMSA :: ^MCI_SAVE_PARMSA; | |
| LPMCI_SAVE_PARMSA :: ^MCI_SAVE_PARMSA; | |
| MCI_SAVE_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpfilename : LPCWSTR, | |
| }; | |
| PMCI_SAVE_PARMSW :: ^MCI_SAVE_PARMSW; | |
| LPMCI_SAVE_PARMSW :: ^MCI_SAVE_PARMSW; | |
| MCI_SAVE_PARMS :: MCI_SAVE_PARMSA; | |
| PMCI_SAVE_PARMS :: PMCI_SAVE_PARMSA; | |
| LPMCI_SAVE_PARMS :: LPMCI_SAVE_PARMSA; | |
| MCI_LOAD_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpfilename : LPCSTR, | |
| }; | |
| PMCI_LOAD_PARMSA :: ^MCI_LOAD_PARMSA; | |
| LPMCI_LOAD_PARMSA :: ^MCI_LOAD_PARMSA; | |
| MCI_LOAD_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpfilename : LPCWSTR, | |
| }; | |
| PMCI_LOAD_PARMSW :: ^MCI_LOAD_PARMSW; | |
| LPMCI_LOAD_PARMSW :: ^MCI_LOAD_PARMSW; | |
| MCI_LOAD_PARMS :: MCI_LOAD_PARMSA; | |
| PMCI_LOAD_PARMS :: PMCI_LOAD_PARMSA; | |
| LPMCI_LOAD_PARMS :: LPMCI_LOAD_PARMSA; | |
| MCI_RECORD_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwFrom : DWORD, | |
| dwTo : DWORD, | |
| }; | |
| LPMCI_RECORD_PARMS :: ^MCI_RECORD_PARMS; | |
| MCI_VD_PLAY_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwFrom : DWORD, | |
| dwTo : DWORD, | |
| dwSpeed : DWORD, | |
| }; | |
| PMCI_VD_PLAY_PARMS :: ^MCI_VD_PLAY_PARMS; | |
| LPMCI_VD_PLAY_PARMS :: ^MCI_VD_PLAY_PARMS; | |
| MCI_VD_STEP_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwFrames : DWORD, | |
| }; | |
| PMCI_VD_STEP_PARMS :: ^MCI_VD_STEP_PARMS; | |
| LPMCI_VD_STEP_PARMS :: ^MCI_VD_STEP_PARMS; | |
| MCI_VD_ESCAPE_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpstrCommand : LPCSTR, | |
| }; | |
| PMCI_VD_ESCAPE_PARMSA :: ^MCI_VD_ESCAPE_PARMSA; | |
| LPMCI_VD_ESCAPE_PARMSA :: ^MCI_VD_ESCAPE_PARMSA; | |
| MCI_VD_ESCAPE_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpstrCommand : LPCWSTR, | |
| }; | |
| PMCI_VD_ESCAPE_PARMSW :: ^MCI_VD_ESCAPE_PARMSW; | |
| LPMCI_VD_ESCAPE_PARMSW :: ^MCI_VD_ESCAPE_PARMSW; | |
| MCI_VD_ESCAPE_PARMS :: MCI_VD_ESCAPE_PARMSA; | |
| PMCI_VD_ESCAPE_PARMS :: PMCI_VD_ESCAPE_PARMSA; | |
| LPMCI_VD_ESCAPE_PARMS :: LPMCI_VD_ESCAPE_PARMSA; | |
| MCI_WAVE_OPEN_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| wDeviceID : MCIDEVICEID, | |
| lpstrDeviceType : LPCSTR, | |
| lpstrElementName : LPCSTR, | |
| lpstrAlias : LPCSTR, | |
| dwBufferSeconds : DWORD, | |
| }; | |
| PMCI_WAVE_OPEN_PARMSA :: ^MCI_WAVE_OPEN_PARMSA; | |
| LPMCI_WAVE_OPEN_PARMSA :: ^MCI_WAVE_OPEN_PARMSA; | |
| MCI_WAVE_OPEN_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| wDeviceID : MCIDEVICEID, | |
| lpstrDeviceType : LPCWSTR, | |
| lpstrElementName : LPCWSTR, | |
| lpstrAlias : LPCWSTR, | |
| dwBufferSeconds : DWORD, | |
| }; | |
| PMCI_WAVE_OPEN_PARMSW :: ^MCI_WAVE_OPEN_PARMSW; | |
| LPMCI_WAVE_OPEN_PARMSW :: ^MCI_WAVE_OPEN_PARMSW; | |
| MCI_WAVE_OPEN_PARMS :: MCI_WAVE_OPEN_PARMSA; | |
| PMCI_WAVE_OPEN_PARMS :: PMCI_WAVE_OPEN_PARMSA; | |
| LPMCI_WAVE_OPEN_PARMS :: LPMCI_WAVE_OPEN_PARMSA; | |
| MCI_WAVE_DELETE_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwFrom : DWORD, | |
| dwTo : DWORD, | |
| }; | |
| PMCI_WAVE_DELETE_PARMS :: ^MCI_WAVE_DELETE_PARMS; | |
| LPMCI_WAVE_DELETE_PARMS :: ^MCI_WAVE_DELETE_PARMS; | |
| MCI_WAVE_SET_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwTimeFormat : DWORD, | |
| dwAudio : DWORD, | |
| wInput : UINT, | |
| wOutput : UINT, | |
| wFormatTag : WORD, | |
| wReserved2 : WORD, | |
| nChannels : WORD, | |
| wReserved3 : WORD, | |
| nSamplesPerSec : DWORD, | |
| nAvgBytesPerSec : DWORD, | |
| nBlockAlign : WORD, | |
| wReserved4 : WORD, | |
| wBitsPerSample : WORD, | |
| wReserved5 : WORD, | |
| }; | |
| PMCI_WAVE_SET_PARMS :: ^MCI_WAVE_SET_PARMS; | |
| LPMCI_WAVE_SET_PARMS :: ^MCI_WAVE_SET_PARMS; | |
| MCI_SEQ_SET_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwTimeFormat : DWORD, | |
| dwAudio : DWORD, | |
| dwTempo : DWORD, | |
| dwPort : DWORD, | |
| dwSlave : DWORD, | |
| dwMaster : DWORD, | |
| dwOffset : DWORD, | |
| }; | |
| PMCI_SEQ_SET_PARMS :: ^MCI_SEQ_SET_PARMS; | |
| LPMCI_SEQ_SET_PARMS :: ^MCI_SEQ_SET_PARMS; | |
| MCI_ANIM_OPEN_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| wDeviceID : MCIDEVICEID, | |
| lpstrDeviceType : LPCSTR, | |
| lpstrElementName : LPCSTR, | |
| lpstrAlias : LPCSTR, | |
| dwStyle : DWORD, | |
| hWndParent : HWND, | |
| }; | |
| PMCI_ANIM_OPEN_PARMSA :: ^MCI_ANIM_OPEN_PARMSA; | |
| LPMCI_ANIM_OPEN_PARMSA :: ^MCI_ANIM_OPEN_PARMSA; | |
| MCI_ANIM_OPEN_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| wDeviceID : MCIDEVICEID, | |
| lpstrDeviceType : LPCWSTR, | |
| lpstrElementName : LPCWSTR, | |
| lpstrAlias : LPCWSTR, | |
| dwStyle : DWORD, | |
| hWndParent : HWND, | |
| }; | |
| PMCI_ANIM_OPEN_PARMSW :: ^MCI_ANIM_OPEN_PARMSW; | |
| LPMCI_ANIM_OPEN_PARMSW :: ^MCI_ANIM_OPEN_PARMSW; | |
| MCI_ANIM_OPEN_PARMS :: MCI_ANIM_OPEN_PARMSA; | |
| PMCI_ANIM_OPEN_PARMS :: PMCI_ANIM_OPEN_PARMSA; | |
| LPMCI_ANIM_OPEN_PARMS :: LPMCI_ANIM_OPEN_PARMSA; | |
| MCI_ANIM_PLAY_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwFrom : DWORD, | |
| dwTo : DWORD, | |
| dwSpeed : DWORD, | |
| }; | |
| PMCI_ANIM_PLAY_PARMS :: ^MCI_ANIM_PLAY_PARMS; | |
| LPMCI_ANIM_PLAY_PARMS :: ^MCI_ANIM_PLAY_PARMS; | |
| MCI_ANIM_STEP_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| dwFrames : DWORD, | |
| }; | |
| PMCI_ANIM_STEP_PARMS :: ^MCI_ANIM_STEP_PARMS; | |
| LPMCI_ANIM_STEP_PARMS :: ^MCI_ANIM_STEP_PARMS; | |
| MCI_ANIM_WINDOW_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| hWnd : HWND, | |
| nCmdShow : UINT, | |
| lpstrText : LPCSTR, | |
| }; | |
| PMCI_ANIM_WINDOW_PARMSA :: ^MCI_ANIM_WINDOW_PARMSA; | |
| LPMCI_ANIM_WINDOW_PARMSA :: ^MCI_ANIM_WINDOW_PARMSA; | |
| MCI_ANIM_WINDOW_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| hWnd : HWND, | |
| nCmdShow : UINT, | |
| lpstrText : LPCWSTR, | |
| }; | |
| PMCI_ANIM_WINDOW_PARMSW :: ^MCI_ANIM_WINDOW_PARMSW; | |
| LPMCI_ANIM_WINDOW_PARMSW :: ^MCI_ANIM_WINDOW_PARMSW; | |
| MCI_ANIM_WINDOW_PARMS :: MCI_ANIM_WINDOW_PARMSA; | |
| PMCI_ANIM_WINDOW_PARMS :: PMCI_ANIM_WINDOW_PARMSA; | |
| LPMCI_ANIM_WINDOW_PARMS :: LPMCI_ANIM_WINDOW_PARMSA; | |
| MCI_ANIM_RECT_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| rc : RECT, | |
| }; | |
| PMCI_ANIM_RECT_PARMS :: ^MCI_ANIM_RECT_PARMS; | |
| LPMCI_ANIM_RECT_PARMS :: ^MCI_ANIM_RECT_PARMS; | |
| MCI_ANIM_UPDATE_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| rc : RECT, | |
| hDC : HDC, | |
| }; | |
| PMCI_ANIM_UPDATE_PARMS :: ^MCI_ANIM_UPDATE_PARMS; | |
| LPMCI_ANIM_UPDATE_PARMS :: ^MCI_ANIM_UPDATE_PARMS; | |
| MCI_OVLY_OPEN_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| wDeviceID : MCIDEVICEID, | |
| lpstrDeviceType : LPCSTR, | |
| lpstrElementName : LPCSTR, | |
| lpstrAlias : LPCSTR, | |
| dwStyle : DWORD, | |
| hWndParent : HWND, | |
| }; | |
| PMCI_OVLY_OPEN_PARMSA :: ^MCI_OVLY_OPEN_PARMSA; | |
| LPMCI_OVLY_OPEN_PARMSA :: ^MCI_OVLY_OPEN_PARMSA; | |
| MCI_OVLY_OPEN_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| wDeviceID : MCIDEVICEID, | |
| lpstrDeviceType : LPCWSTR, | |
| lpstrElementName : LPCWSTR, | |
| lpstrAlias : LPCWSTR, | |
| dwStyle : DWORD, | |
| hWndParent : HWND, | |
| }; | |
| PMCI_OVLY_OPEN_PARMSW :: ^MCI_OVLY_OPEN_PARMSW; | |
| LPMCI_OVLY_OPEN_PARMSW :: ^MCI_OVLY_OPEN_PARMSW; | |
| MCI_OVLY_OPEN_PARMS :: MCI_OVLY_OPEN_PARMSA; | |
| PMCI_OVLY_OPEN_PARMS :: PMCI_OVLY_OPEN_PARMSA; | |
| LPMCI_OVLY_OPEN_PARMS :: LPMCI_OVLY_OPEN_PARMSA; | |
| MCI_OVLY_WINDOW_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| hWnd : HWND, | |
| nCmdShow : UINT, | |
| lpstrText : LPCSTR, | |
| }; | |
| PMCI_OVLY_WINDOW_PARMSA :: ^MCI_OVLY_WINDOW_PARMSA; | |
| LPMCI_OVLY_WINDOW_PARMSA :: ^MCI_OVLY_WINDOW_PARMSA; | |
| MCI_OVLY_WINDOW_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| hWnd : HWND, | |
| nCmdShow : UINT, | |
| lpstrText : LPCWSTR, | |
| }; | |
| PMCI_OVLY_WINDOW_PARMSW :: ^MCI_OVLY_WINDOW_PARMSW; | |
| LPMCI_OVLY_WINDOW_PARMSW :: ^MCI_OVLY_WINDOW_PARMSW; | |
| MCI_OVLY_WINDOW_PARMS :: MCI_OVLY_WINDOW_PARMSA; | |
| PMCI_OVLY_WINDOW_PARMS :: PMCI_OVLY_WINDOW_PARMSA; | |
| LPMCI_OVLY_WINDOW_PARMS :: LPMCI_OVLY_WINDOW_PARMSA; | |
| MCI_OVLY_RECT_PARMS :: struct { | |
| dwCallback : DWORD_PTR, | |
| rc : RECT, | |
| }; | |
| PMCI_OVLY_RECT_PARMS :: ^MCI_OVLY_RECT_PARMS; | |
| LPMCI_OVLY_RECT_PARMS :: ^MCI_OVLY_RECT_PARMS; | |
| MCI_OVLY_SAVE_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpfilename : LPCSTR, | |
| rc : RECT, | |
| }; | |
| PMCI_OVLY_SAVE_PARMSA :: ^MCI_OVLY_SAVE_PARMSA; | |
| LPMCI_OVLY_SAVE_PARMSA :: ^MCI_OVLY_SAVE_PARMSA; | |
| MCI_OVLY_SAVE_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpfilename : LPCWSTR, | |
| rc : RECT, | |
| }; | |
| PMCI_OVLY_SAVE_PARMSW :: ^MCI_OVLY_SAVE_PARMSW; | |
| LPMCI_OVLY_SAVE_PARMSW :: ^MCI_OVLY_SAVE_PARMSW; | |
| MCI_OVLY_SAVE_PARMS :: MCI_OVLY_SAVE_PARMSA; | |
| PMCI_OVLY_SAVE_PARMS :: PMCI_OVLY_SAVE_PARMSA; | |
| LPMCI_OVLY_SAVE_PARMS :: LPMCI_OVLY_SAVE_PARMSA; | |
| MCI_OVLY_LOAD_PARMSA :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpfilename : LPCSTR, | |
| rc : RECT, | |
| }; | |
| PMCI_OVLY_LOAD_PARMSA :: ^MCI_OVLY_LOAD_PARMSA; | |
| LPMCI_OVLY_LOAD_PARMSA :: ^MCI_OVLY_LOAD_PARMSA; | |
| MCI_OVLY_LOAD_PARMSW :: struct { | |
| dwCallback : DWORD_PTR, | |
| lpfilename : LPCWSTR, | |
| rc : RECT, | |
| }; | |
| PMCI_OVLY_LOAD_PARMSW :: ^MCI_OVLY_LOAD_PARMSW; | |
| LPMCI_OVLY_LOAD_PARMSW :: ^MCI_OVLY_LOAD_PARMSW; | |
| MCI_OVLY_LOAD_PARMS :: MCI_OVLY_LOAD_PARMSA; | |
| PMCI_OVLY_LOAD_PARMS :: PMCI_OVLY_LOAD_PARMSA; | |
| LPMCI_OVLY_LOAD_PARMS :: LPMCI_OVLY_LOAD_PARMSA; | |
| DRVCONFIGINFOEX :: struct { | |
| dwDCISize : DWORD, | |
| lpszDCISectionName : LPCWSTR, | |
| lpszDCIAliasName : LPCWSTR, | |
| dnDevNode : DWORD, | |
| }; | |
| PDRVCONFIGINFOEX :: ^DRVCONFIGINFOEX; | |
| NPDRVCONFIGINFOEX :: ^DRVCONFIGINFOEX; | |
| LPDRVCONFIGINFOEX :: ^DRVCONFIGINFOEX; | |
| DRVCONFIGINFO :: struct { | |
| dwDCISize : DWORD, | |
| lpszDCISectionName : LPCWSTR, | |
| lpszDCIAliasName : LPCWSTR, | |
| }; | |
| PDRVCONFIGINFO :: ^DRVCONFIGINFO; | |
| NPDRVCONFIGINFO :: ^DRVCONFIGINFO; | |
| LPDRVCONFIGINFO :: ^DRVCONFIGINFO; | |
| DRIVERPROC :: (proc "stdcall" (DWORD_PTR, HDRVR, UINT, LPARAM, LPARAM) -> LRESULT); | |
| DRIVERMSGPROC :: (proc "stdcall" (DWORD, DWORD, DWORD_PTR, DWORD_PTR, DWORD_PTR) -> DWORD); | |
| FOURCC :: DWORD; | |
| HPSTR :: ^_c.uchar; | |
| HMMIO__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HMMIO :: ^HMMIO__; | |
| MMIOPROC :: #type (proc "stdcall" (lpmmioinfo : LPSTR, uMsg : UINT, lParam1 : LPARAM, lParam2 : LPARAM) -> LRESULT); | |
| LPMMIOPROC :: ^MMIOPROC; | |
| MMIOINFO :: struct { | |
| dwFlags : DWORD, | |
| fccIOProc : FOURCC, | |
| pIOProc : LPMMIOPROC, | |
| wErrorRet : UINT, | |
| htask : HTASK, | |
| cchBuffer : LONG, | |
| pchBuffer : HPSTR, | |
| pchNext : HPSTR, | |
| pchEndRead : HPSTR, | |
| pchEndWrite : HPSTR, | |
| lBufOffset : LONG, | |
| lDiskOffset : LONG, | |
| adwInfo : [3]DWORD, | |
| dwReserved1 : DWORD, | |
| dwReserved2 : DWORD, | |
| hmmio : HMMIO, | |
| }; | |
| PMMIOINFO :: ^MMIOINFO; | |
| NPMMIOINFO :: ^MMIOINFO; | |
| LPMMIOINFO :: ^MMIOINFO; | |
| LPCMMIOINFO :: ^MMIOINFO; | |
| MMCKINFO :: struct { | |
| ckid : FOURCC, | |
| cksize : DWORD, | |
| fccType : FOURCC, | |
| dwDataOffset : DWORD, | |
| dwFlags : DWORD, | |
| }; | |
| PMMCKINFO :: ^MMCKINFO; | |
| NPMMCKINFO :: ^MMCKINFO; | |
| LPMMCKINFO :: ^MMCKINFO; | |
| LPCMMCKINFO :: ^MMCKINFO; | |
| TIMECALLBACK :: #type proc "stdcall" (uTimerID : UINT, uMsg : UINT, dwUser : DWORD_PTR, dw1 : DWORD_PTR, dw2 : DWORD_PTR); | |
| LPTIMECALLBACK :: ^TIMECALLBACK; | |
| HWAVE__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HWAVE :: ^HWAVE__; | |
| HWAVEIN__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HWAVEIN :: ^HWAVEIN__; | |
| HWAVEOUT__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HWAVEOUT :: ^HWAVEOUT__; | |
| LPHWAVEIN :: ^HWAVEIN; | |
| LPHWAVEOUT :: ^HWAVEOUT; | |
| WAVECALLBACK :: DRVCALLBACK; | |
| LPWAVECALLBACK :: ^WAVECALLBACK; | |
| WAVEHDR :: struct { | |
| lpData : LPSTR, | |
| dwBufferLength : DWORD, | |
| dwBytesRecorded : DWORD, | |
| dwUser : DWORD_PTR, | |
| dwFlags : DWORD, | |
| dwLoops : DWORD, | |
| lpNext : ^WAVEHDR, | |
| reserved : DWORD_PTR, | |
| }; | |
| PWAVEHDR :: ^WAVEHDR; | |
| NPWAVEHDR :: ^WAVEHDR; | |
| LPWAVEHDR :: ^WAVEHDR; | |
| WAVEOUTCAPSA :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| dwFormats : DWORD, | |
| wChannels : WORD, | |
| wReserved1 : WORD, | |
| dwSupport : DWORD, | |
| }; | |
| PWAVEOUTCAPSA :: ^WAVEOUTCAPSA; | |
| NPWAVEOUTCAPSA :: ^WAVEOUTCAPSA; | |
| LPWAVEOUTCAPSA :: ^WAVEOUTCAPSA; | |
| WAVEOUTCAPSW :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| dwFormats : DWORD, | |
| wChannels : WORD, | |
| wReserved1 : WORD, | |
| dwSupport : DWORD, | |
| }; | |
| PWAVEOUTCAPSW :: ^WAVEOUTCAPSW; | |
| NPWAVEOUTCAPSW :: ^WAVEOUTCAPSW; | |
| LPWAVEOUTCAPSW :: ^WAVEOUTCAPSW; | |
| WAVEOUTCAPS :: WAVEOUTCAPSA; | |
| PWAVEOUTCAPS :: PWAVEOUTCAPSA; | |
| NPWAVEOUTCAPS :: NPWAVEOUTCAPSA; | |
| LPWAVEOUTCAPS :: LPWAVEOUTCAPSA; | |
| WAVEOUTCAPS2A :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| dwFormats : DWORD, | |
| wChannels : WORD, | |
| wReserved1 : WORD, | |
| dwSupport : DWORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PWAVEOUTCAPS2A :: ^WAVEOUTCAPS2A; | |
| NPWAVEOUTCAPS2A :: ^WAVEOUTCAPS2A; | |
| LPWAVEOUTCAPS2A :: ^WAVEOUTCAPS2A; | |
| WAVEOUTCAPS2W :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| dwFormats : DWORD, | |
| wChannels : WORD, | |
| wReserved1 : WORD, | |
| dwSupport : DWORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PWAVEOUTCAPS2W :: ^WAVEOUTCAPS2W; | |
| NPWAVEOUTCAPS2W :: ^WAVEOUTCAPS2W; | |
| LPWAVEOUTCAPS2W :: ^WAVEOUTCAPS2W; | |
| WAVEOUTCAPS2 :: WAVEOUTCAPS2A; | |
| PWAVEOUTCAPS2 :: PWAVEOUTCAPS2A; | |
| NPWAVEOUTCAPS2 :: NPWAVEOUTCAPS2A; | |
| LPWAVEOUTCAPS2 :: LPWAVEOUTCAPS2A; | |
| WAVEINCAPSA :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| dwFormats : DWORD, | |
| wChannels : WORD, | |
| wReserved1 : WORD, | |
| }; | |
| PWAVEINCAPSA :: ^WAVEINCAPSA; | |
| NPWAVEINCAPSA :: ^WAVEINCAPSA; | |
| LPWAVEINCAPSA :: ^WAVEINCAPSA; | |
| WAVEINCAPSW :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| dwFormats : DWORD, | |
| wChannels : WORD, | |
| wReserved1 : WORD, | |
| }; | |
| PWAVEINCAPSW :: ^WAVEINCAPSW; | |
| NPWAVEINCAPSW :: ^WAVEINCAPSW; | |
| LPWAVEINCAPSW :: ^WAVEINCAPSW; | |
| WAVEINCAPS :: WAVEINCAPSA; | |
| PWAVEINCAPS :: PWAVEINCAPSA; | |
| NPWAVEINCAPS :: NPWAVEINCAPSA; | |
| LPWAVEINCAPS :: LPWAVEINCAPSA; | |
| WAVEINCAPS2A :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| dwFormats : DWORD, | |
| wChannels : WORD, | |
| wReserved1 : WORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PWAVEINCAPS2A :: ^WAVEINCAPS2A; | |
| NPWAVEINCAPS2A :: ^WAVEINCAPS2A; | |
| LPWAVEINCAPS2A :: ^WAVEINCAPS2A; | |
| WAVEINCAPS2W :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| dwFormats : DWORD, | |
| wChannels : WORD, | |
| wReserved1 : WORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PWAVEINCAPS2W :: ^WAVEINCAPS2W; | |
| NPWAVEINCAPS2W :: ^WAVEINCAPS2W; | |
| LPWAVEINCAPS2W :: ^WAVEINCAPS2W; | |
| WAVEINCAPS2 :: WAVEINCAPS2A; | |
| PWAVEINCAPS2 :: PWAVEINCAPS2A; | |
| NPWAVEINCAPS2 :: NPWAVEINCAPS2A; | |
| LPWAVEINCAPS2 :: LPWAVEINCAPS2A; | |
| WAVEFORMAT :: struct { | |
| wFormatTag : WORD, | |
| nChannels : WORD, | |
| nSamplesPerSec : DWORD, | |
| nAvgBytesPerSec : DWORD, | |
| nBlockAlign : WORD, | |
| }; | |
| PWAVEFORMAT :: ^WAVEFORMAT; | |
| NPWAVEFORMAT :: ^WAVEFORMAT; | |
| LPWAVEFORMAT :: ^WAVEFORMAT; | |
| PCMWAVEFORMAT :: struct { | |
| wf : WAVEFORMAT, | |
| wBitsPerSample : WORD, | |
| }; | |
| PPCMWAVEFORMAT :: ^PCMWAVEFORMAT; | |
| NPPCMWAVEFORMAT :: ^PCMWAVEFORMAT; | |
| LPPCMWAVEFORMAT :: ^PCMWAVEFORMAT; | |
| WAVEFORMATEX :: struct { | |
| wFormatTag : WORD, | |
| nChannels : WORD, | |
| nSamplesPerSec : DWORD, | |
| nAvgBytesPerSec : DWORD, | |
| nBlockAlign : WORD, | |
| wBitsPerSample : WORD, | |
| cbSize : WORD, | |
| }; | |
| PWAVEFORMATEX :: ^WAVEFORMATEX; | |
| NPWAVEFORMATEX :: ^WAVEFORMATEX; | |
| LPWAVEFORMATEX :: ^WAVEFORMATEX; | |
| LPCWAVEFORMATEX :: ^WAVEFORMATEX; | |
| HMIDI__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HMIDI :: ^HMIDI__; | |
| HMIDIIN__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HMIDIIN :: ^HMIDIIN__; | |
| HMIDIOUT__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HMIDIOUT :: ^HMIDIOUT__; | |
| HMIDISTRM__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HMIDISTRM :: ^HMIDISTRM__; | |
| LPHMIDI :: ^HMIDI; | |
| LPHMIDIIN :: ^HMIDIIN; | |
| LPHMIDIOUT :: ^HMIDIOUT; | |
| LPHMIDISTRM :: ^HMIDISTRM; | |
| MIDICALLBACK :: DRVCALLBACK; | |
| LPMIDICALLBACK :: ^MIDICALLBACK; | |
| PATCHARRAY :: [128]WORD; | |
| LPPATCHARRAY :: ^WORD; | |
| KEYARRAY :: [128]WORD; | |
| LPKEYARRAY :: ^WORD; | |
| MIDIOUTCAPSA :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| wTechnology : WORD, | |
| wVoices : WORD, | |
| wNotes : WORD, | |
| wChannelMask : WORD, | |
| dwSupport : DWORD, | |
| }; | |
| PMIDIOUTCAPSA :: ^MIDIOUTCAPSA; | |
| NPMIDIOUTCAPSA :: ^MIDIOUTCAPSA; | |
| LPMIDIOUTCAPSA :: ^MIDIOUTCAPSA; | |
| MIDIOUTCAPSW :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| wTechnology : WORD, | |
| wVoices : WORD, | |
| wNotes : WORD, | |
| wChannelMask : WORD, | |
| dwSupport : DWORD, | |
| }; | |
| PMIDIOUTCAPSW :: ^MIDIOUTCAPSW; | |
| NPMIDIOUTCAPSW :: ^MIDIOUTCAPSW; | |
| LPMIDIOUTCAPSW :: ^MIDIOUTCAPSW; | |
| MIDIOUTCAPS :: MIDIOUTCAPSA; | |
| PMIDIOUTCAPS :: PMIDIOUTCAPSA; | |
| NPMIDIOUTCAPS :: NPMIDIOUTCAPSA; | |
| LPMIDIOUTCAPS :: LPMIDIOUTCAPSA; | |
| MIDIOUTCAPS2A :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| wTechnology : WORD, | |
| wVoices : WORD, | |
| wNotes : WORD, | |
| wChannelMask : WORD, | |
| dwSupport : DWORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PMIDIOUTCAPS2A :: ^MIDIOUTCAPS2A; | |
| NPMIDIOUTCAPS2A :: ^MIDIOUTCAPS2A; | |
| LPMIDIOUTCAPS2A :: ^MIDIOUTCAPS2A; | |
| MIDIOUTCAPS2W :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| wTechnology : WORD, | |
| wVoices : WORD, | |
| wNotes : WORD, | |
| wChannelMask : WORD, | |
| dwSupport : DWORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PMIDIOUTCAPS2W :: ^MIDIOUTCAPS2W; | |
| NPMIDIOUTCAPS2W :: ^MIDIOUTCAPS2W; | |
| LPMIDIOUTCAPS2W :: ^MIDIOUTCAPS2W; | |
| MIDIOUTCAPS2 :: MIDIOUTCAPS2A; | |
| PMIDIOUTCAPS2 :: PMIDIOUTCAPS2A; | |
| NPMIDIOUTCAPS2 :: NPMIDIOUTCAPS2A; | |
| LPMIDIOUTCAPS2 :: LPMIDIOUTCAPS2A; | |
| MIDIINCAPSA :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| dwSupport : DWORD, | |
| }; | |
| PMIDIINCAPSA :: ^MIDIINCAPSA; | |
| NPMIDIINCAPSA :: ^MIDIINCAPSA; | |
| LPMIDIINCAPSA :: ^MIDIINCAPSA; | |
| MIDIINCAPSW :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| dwSupport : DWORD, | |
| }; | |
| PMIDIINCAPSW :: ^MIDIINCAPSW; | |
| NPMIDIINCAPSW :: ^MIDIINCAPSW; | |
| LPMIDIINCAPSW :: ^MIDIINCAPSW; | |
| MIDIINCAPS :: MIDIINCAPSA; | |
| PMIDIINCAPS :: PMIDIINCAPSA; | |
| NPMIDIINCAPS :: NPMIDIINCAPSA; | |
| LPMIDIINCAPS :: LPMIDIINCAPSA; | |
| MIDIINCAPS2A :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| dwSupport : DWORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PMIDIINCAPS2A :: ^MIDIINCAPS2A; | |
| NPMIDIINCAPS2A :: ^MIDIINCAPS2A; | |
| LPMIDIINCAPS2A :: ^MIDIINCAPS2A; | |
| MIDIINCAPS2W :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| dwSupport : DWORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PMIDIINCAPS2W :: ^MIDIINCAPS2W; | |
| NPMIDIINCAPS2W :: ^MIDIINCAPS2W; | |
| LPMIDIINCAPS2W :: ^MIDIINCAPS2W; | |
| MIDIINCAPS2 :: MIDIINCAPS2A; | |
| PMIDIINCAPS2 :: PMIDIINCAPS2A; | |
| NPMIDIINCAPS2 :: NPMIDIINCAPS2A; | |
| LPMIDIINCAPS2 :: LPMIDIINCAPS2A; | |
| MIDIHDR :: struct { | |
| lpData : LPSTR, | |
| dwBufferLength : DWORD, | |
| dwBytesRecorded : DWORD, | |
| dwUser : DWORD_PTR, | |
| dwFlags : DWORD, | |
| lpNext : ^MIDIHDR, | |
| reserved : DWORD_PTR, | |
| dwOffset : DWORD, | |
| dwReserved : [8]DWORD_PTR, | |
| }; | |
| PMIDIHDR :: ^MIDIHDR; | |
| NPMIDIHDR :: ^MIDIHDR; | |
| LPMIDIHDR :: ^MIDIHDR; | |
| MIDIEVENT :: struct { | |
| dwDeltaTime : DWORD, | |
| dwStreamID : DWORD, | |
| dwEvent : DWORD, | |
| dwParms : [1]DWORD, | |
| }; | |
| MIDISTRMBUFFVER :: struct { | |
| dwVersion : DWORD, | |
| dwMid : DWORD, | |
| dwOEMVersion : DWORD, | |
| }; | |
| MIDIPROPTIMEDIV :: struct { | |
| cbStruct : DWORD, | |
| dwTimeDiv : DWORD, | |
| }; | |
| LPMIDIPROPTIMEDIV :: ^MIDIPROPTIMEDIV; | |
| MIDIPROPTEMPO :: struct { | |
| cbStruct : DWORD, | |
| dwTempo : DWORD, | |
| }; | |
| LPMIDIPROPTEMPO :: ^MIDIPROPTEMPO; | |
| AUXCAPSA :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| wTechnology : WORD, | |
| wReserved1 : WORD, | |
| dwSupport : DWORD, | |
| }; | |
| PAUXCAPSA :: ^AUXCAPSA; | |
| NPAUXCAPSA :: ^AUXCAPSA; | |
| LPAUXCAPSA :: ^AUXCAPSA; | |
| AUXCAPSW :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| wTechnology : WORD, | |
| wReserved1 : WORD, | |
| dwSupport : DWORD, | |
| }; | |
| PAUXCAPSW :: ^AUXCAPSW; | |
| NPAUXCAPSW :: ^AUXCAPSW; | |
| LPAUXCAPSW :: ^AUXCAPSW; | |
| AUXCAPS :: AUXCAPSA; | |
| PAUXCAPS :: PAUXCAPSA; | |
| NPAUXCAPS :: NPAUXCAPSA; | |
| LPAUXCAPS :: LPAUXCAPSA; | |
| AUXCAPS2A :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| wTechnology : WORD, | |
| wReserved1 : WORD, | |
| dwSupport : DWORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PAUXCAPS2A :: ^AUXCAPS2A; | |
| NPAUXCAPS2A :: ^AUXCAPS2A; | |
| LPAUXCAPS2A :: ^AUXCAPS2A; | |
| AUXCAPS2W :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| wTechnology : WORD, | |
| wReserved1 : WORD, | |
| dwSupport : DWORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PAUXCAPS2W :: ^AUXCAPS2W; | |
| NPAUXCAPS2W :: ^AUXCAPS2W; | |
| LPAUXCAPS2W :: ^AUXCAPS2W; | |
| AUXCAPS2 :: AUXCAPS2A; | |
| PAUXCAPS2 :: PAUXCAPS2A; | |
| NPAUXCAPS2 :: NPAUXCAPS2A; | |
| LPAUXCAPS2 :: LPAUXCAPS2A; | |
| HMIXEROBJ__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HMIXEROBJ :: ^HMIXEROBJ__; | |
| LPHMIXEROBJ :: ^HMIXEROBJ; | |
| HMIXER__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HMIXER :: ^HMIXER__; | |
| LPHMIXER :: ^HMIXER; | |
| MIXERCAPSA :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| fdwSupport : DWORD, | |
| cDestinations : DWORD, | |
| }; | |
| PMIXERCAPSA :: ^MIXERCAPSA; | |
| LPMIXERCAPSA :: ^MIXERCAPSA; | |
| MIXERCAPSW :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| fdwSupport : DWORD, | |
| cDestinations : DWORD, | |
| }; | |
| PMIXERCAPSW :: ^MIXERCAPSW; | |
| LPMIXERCAPSW :: ^MIXERCAPSW; | |
| MIXERCAPS :: MIXERCAPSA; | |
| PMIXERCAPS :: PMIXERCAPSA; | |
| LPMIXERCAPS :: LPMIXERCAPSA; | |
| MIXERCAPS2A :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| fdwSupport : DWORD, | |
| cDestinations : DWORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PMIXERCAPS2A :: ^MIXERCAPS2A; | |
| LPMIXERCAPS2A :: ^MIXERCAPS2A; | |
| MIXERCAPS2W :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| fdwSupport : DWORD, | |
| cDestinations : DWORD, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PMIXERCAPS2W :: ^MIXERCAPS2W; | |
| LPMIXERCAPS2W :: ^MIXERCAPS2W; | |
| MIXERCAPS2 :: MIXERCAPS2A; | |
| PMIXERCAPS2 :: PMIXERCAPS2A; | |
| LPMIXERCAPS2 :: LPMIXERCAPS2A; | |
| MIXERLINEA :: struct { | |
| cbStruct : DWORD, | |
| dwDestination : DWORD, | |
| dwSource : DWORD, | |
| dwLineID : DWORD, | |
| fdwLine : DWORD, | |
| dwUser : DWORD_PTR, | |
| dwComponentType : DWORD, | |
| cChannels : DWORD, | |
| cConnections : DWORD, | |
| cControls : DWORD, | |
| szShortName : [16]CHAR, | |
| szName : [64]CHAR, | |
| Target : struct { | |
| dwType : DWORD, | |
| dwDeviceID : DWORD, | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]CHAR, | |
| }, | |
| }; | |
| PMIXERLINEA :: ^MIXERLINEA; | |
| LPMIXERLINEA :: ^MIXERLINEA; | |
| MIXERLINEW :: struct { | |
| cbStruct : DWORD, | |
| dwDestination : DWORD, | |
| dwSource : DWORD, | |
| dwLineID : DWORD, | |
| fdwLine : DWORD, | |
| dwUser : DWORD_PTR, | |
| dwComponentType : DWORD, | |
| cChannels : DWORD, | |
| cConnections : DWORD, | |
| cControls : DWORD, | |
| szShortName : [16]WCHAR, | |
| szName : [64]WCHAR, | |
| Target : struct { | |
| dwType : DWORD, | |
| dwDeviceID : DWORD, | |
| wMid : WORD, | |
| wPid : WORD, | |
| vDriverVersion : MMVERSION, | |
| szPname : [32]WCHAR, | |
| }, | |
| }; | |
| PMIXERLINEW :: ^MIXERLINEW; | |
| LPMIXERLINEW :: ^MIXERLINEW; | |
| MIXERLINE :: MIXERLINEA; | |
| PMIXERLINE :: PMIXERLINEA; | |
| LPMIXERLINE :: LPMIXERLINEA; | |
| MIXERCONTROLA :: struct { | |
| cbStruct : DWORD, | |
| dwControlID : DWORD, | |
| dwControlType : DWORD, | |
| fdwControl : DWORD, | |
| cMultipleItems : DWORD, | |
| szShortName : [16]CHAR, | |
| szName : [64]CHAR, | |
| Bounds : struct #raw_union { | |
| s : struct { | |
| lMinimum : LONG, | |
| lMaximum : LONG, | |
| }, | |
| s2 : struct { | |
| dwMinimum : DWORD, | |
| dwMaximum : DWORD, | |
| }, | |
| dwReserved : [6]DWORD, | |
| }, | |
| Metrics : struct #raw_union { | |
| cSteps : DWORD, | |
| cbCustomData : DWORD, | |
| dwReserved : [6]DWORD, | |
| }, | |
| }; | |
| PMIXERCONTROLA :: ^MIXERCONTROLA; | |
| LPMIXERCONTROLA :: ^MIXERCONTROLA; | |
| MIXERCONTROLW :: struct { | |
| cbStruct : DWORD, | |
| dwControlID : DWORD, | |
| dwControlType : DWORD, | |
| fdwControl : DWORD, | |
| cMultipleItems : DWORD, | |
| szShortName : [16]WCHAR, | |
| szName : [64]WCHAR, | |
| Bounds : struct #raw_union { | |
| s : struct { | |
| lMinimum : LONG, | |
| lMaximum : LONG, | |
| }, | |
| s2 : struct { | |
| dwMinimum : DWORD, | |
| dwMaximum : DWORD, | |
| }, | |
| dwReserved : [6]DWORD, | |
| }, | |
| Metrics : struct #raw_union { | |
| cSteps : DWORD, | |
| cbCustomData : DWORD, | |
| dwReserved : [6]DWORD, | |
| }, | |
| }; | |
| PMIXERCONTROLW :: ^MIXERCONTROLW; | |
| LPMIXERCONTROLW :: ^MIXERCONTROLW; | |
| MIXERCONTROL :: MIXERCONTROLA; | |
| PMIXERCONTROL :: PMIXERCONTROLA; | |
| LPMIXERCONTROL :: LPMIXERCONTROLA; | |
| MIXERLINECONTROLSA :: struct { | |
| cbStruct : DWORD, | |
| dwLineID : DWORD, | |
| u : struct #raw_union { | |
| dwControlID : DWORD, | |
| dwControlType : DWORD, | |
| }, | |
| cControls : DWORD, | |
| cbmxctrl : DWORD, | |
| pamxctrl : LPMIXERCONTROLA, | |
| }; | |
| PMIXERLINECONTROLSA :: ^MIXERLINECONTROLSA; | |
| LPMIXERLINECONTROLSA :: ^MIXERLINECONTROLSA; | |
| MIXERLINECONTROLSW :: struct { | |
| cbStruct : DWORD, | |
| dwLineID : DWORD, | |
| u : struct #raw_union { | |
| dwControlID : DWORD, | |
| dwControlType : DWORD, | |
| }, | |
| cControls : DWORD, | |
| cbmxctrl : DWORD, | |
| pamxctrl : LPMIXERCONTROLW, | |
| }; | |
| PMIXERLINECONTROLSW :: ^MIXERLINECONTROLSW; | |
| LPMIXERLINECONTROLSW :: ^MIXERLINECONTROLSW; | |
| MIXERLINECONTROLS :: MIXERLINECONTROLSA; | |
| PMIXERLINECONTROLS :: PMIXERLINECONTROLSA; | |
| LPMIXERLINECONTROLS :: LPMIXERLINECONTROLSA; | |
| MIXERCONTROLDETAILS :: struct { | |
| cbStruct : DWORD, | |
| dwControlID : DWORD, | |
| cChannels : DWORD, | |
| u : struct #raw_union { | |
| hwndOwner : HWND, | |
| cMultipleItems : DWORD, | |
| }, | |
| cbDetails : DWORD, | |
| paDetails : LPVOID, | |
| }; | |
| PMIXERCONTROLDETAILS :: ^MIXERCONTROLDETAILS; | |
| LPMIXERCONTROLDETAILS :: ^MIXERCONTROLDETAILS; | |
| MIXERCONTROLDETAILS_LISTTEXTA :: struct { | |
| dwParam1 : DWORD, | |
| dwParam2 : DWORD, | |
| szName : [64]CHAR, | |
| }; | |
| PMIXERCONTROLDETAILS_LISTTEXTA :: ^MIXERCONTROLDETAILS_LISTTEXTA; | |
| LPMIXERCONTROLDETAILS_LISTTEXTA :: ^MIXERCONTROLDETAILS_LISTTEXTA; | |
| MIXERCONTROLDETAILS_LISTTEXTW :: struct { | |
| dwParam1 : DWORD, | |
| dwParam2 : DWORD, | |
| szName : [64]WCHAR, | |
| }; | |
| PMIXERCONTROLDETAILS_LISTTEXTW :: ^MIXERCONTROLDETAILS_LISTTEXTW; | |
| LPMIXERCONTROLDETAILS_LISTTEXTW :: ^MIXERCONTROLDETAILS_LISTTEXTW; | |
| MIXERCONTROLDETAILS_LISTTEXT :: MIXERCONTROLDETAILS_LISTTEXTA; | |
| PMIXERCONTROLDETAILS_LISTTEXT :: PMIXERCONTROLDETAILS_LISTTEXTA; | |
| LPMIXERCONTROLDETAILS_LISTTEXT :: LPMIXERCONTROLDETAILS_LISTTEXTA; | |
| MIXERCONTROLDETAILS_BOOLEAN :: struct { | |
| fValue : LONG, | |
| }; | |
| PMIXERCONTROLDETAILS_BOOLEAN :: ^MIXERCONTROLDETAILS_BOOLEAN; | |
| LPMIXERCONTROLDETAILS_BOOLEAN :: ^MIXERCONTROLDETAILS_BOOLEAN; | |
| MIXERCONTROLDETAILS_SIGNED :: struct { | |
| lValue : LONG, | |
| }; | |
| PMIXERCONTROLDETAILS_SIGNED :: ^MIXERCONTROLDETAILS_SIGNED; | |
| LPMIXERCONTROLDETAILS_SIGNED :: ^MIXERCONTROLDETAILS_SIGNED; | |
| MIXERCONTROLDETAILS_UNSIGNED :: struct { | |
| dwValue : DWORD, | |
| }; | |
| PMIXERCONTROLDETAILS_UNSIGNED :: ^MIXERCONTROLDETAILS_UNSIGNED; | |
| LPMIXERCONTROLDETAILS_UNSIGNED :: ^MIXERCONTROLDETAILS_UNSIGNED; | |
| TIMECAPS :: struct { | |
| wPeriodMin : UINT, | |
| wPeriodMax : UINT, | |
| }; | |
| PTIMECAPS :: ^TIMECAPS; | |
| NPTIMECAPS :: ^TIMECAPS; | |
| LPTIMECAPS :: ^TIMECAPS; | |
| JOYCAPSA :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| szPname : [32]CHAR, | |
| wXmin : UINT, | |
| wXmax : UINT, | |
| wYmin : UINT, | |
| wYmax : UINT, | |
| wZmin : UINT, | |
| wZmax : UINT, | |
| wNumButtons : UINT, | |
| wPeriodMin : UINT, | |
| wPeriodMax : UINT, | |
| wRmin : UINT, | |
| wRmax : UINT, | |
| wUmin : UINT, | |
| wUmax : UINT, | |
| wVmin : UINT, | |
| wVmax : UINT, | |
| wCaps : UINT, | |
| wMaxAxes : UINT, | |
| wNumAxes : UINT, | |
| wMaxButtons : UINT, | |
| szRegKey : [32]CHAR, | |
| szOEMVxD : [260]CHAR, | |
| }; | |
| PJOYCAPSA :: ^JOYCAPSA; | |
| NPJOYCAPSA :: ^JOYCAPSA; | |
| LPJOYCAPSA :: ^JOYCAPSA; | |
| JOYCAPSW :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| szPname : [32]WCHAR, | |
| wXmin : UINT, | |
| wXmax : UINT, | |
| wYmin : UINT, | |
| wYmax : UINT, | |
| wZmin : UINT, | |
| wZmax : UINT, | |
| wNumButtons : UINT, | |
| wPeriodMin : UINT, | |
| wPeriodMax : UINT, | |
| wRmin : UINT, | |
| wRmax : UINT, | |
| wUmin : UINT, | |
| wUmax : UINT, | |
| wVmin : UINT, | |
| wVmax : UINT, | |
| wCaps : UINT, | |
| wMaxAxes : UINT, | |
| wNumAxes : UINT, | |
| wMaxButtons : UINT, | |
| szRegKey : [32]WCHAR, | |
| szOEMVxD : [260]WCHAR, | |
| }; | |
| PJOYCAPSW :: ^JOYCAPSW; | |
| NPJOYCAPSW :: ^JOYCAPSW; | |
| LPJOYCAPSW :: ^JOYCAPSW; | |
| JOYCAPS :: JOYCAPSA; | |
| PJOYCAPS :: PJOYCAPSA; | |
| NPJOYCAPS :: NPJOYCAPSA; | |
| LPJOYCAPS :: LPJOYCAPSA; | |
| JOYCAPS2A :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| szPname : [32]CHAR, | |
| wXmin : UINT, | |
| wXmax : UINT, | |
| wYmin : UINT, | |
| wYmax : UINT, | |
| wZmin : UINT, | |
| wZmax : UINT, | |
| wNumButtons : UINT, | |
| wPeriodMin : UINT, | |
| wPeriodMax : UINT, | |
| wRmin : UINT, | |
| wRmax : UINT, | |
| wUmin : UINT, | |
| wUmax : UINT, | |
| wVmin : UINT, | |
| wVmax : UINT, | |
| wCaps : UINT, | |
| wMaxAxes : UINT, | |
| wNumAxes : UINT, | |
| wMaxButtons : UINT, | |
| szRegKey : [32]CHAR, | |
| szOEMVxD : [260]CHAR, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PJOYCAPS2A :: ^JOYCAPS2A; | |
| NPJOYCAPS2A :: ^JOYCAPS2A; | |
| LPJOYCAPS2A :: ^JOYCAPS2A; | |
| JOYCAPS2W :: struct { | |
| wMid : WORD, | |
| wPid : WORD, | |
| szPname : [32]WCHAR, | |
| wXmin : UINT, | |
| wXmax : UINT, | |
| wYmin : UINT, | |
| wYmax : UINT, | |
| wZmin : UINT, | |
| wZmax : UINT, | |
| wNumButtons : UINT, | |
| wPeriodMin : UINT, | |
| wPeriodMax : UINT, | |
| wRmin : UINT, | |
| wRmax : UINT, | |
| wUmin : UINT, | |
| wUmax : UINT, | |
| wVmin : UINT, | |
| wVmax : UINT, | |
| wCaps : UINT, | |
| wMaxAxes : UINT, | |
| wNumAxes : UINT, | |
| wMaxButtons : UINT, | |
| szRegKey : [32]WCHAR, | |
| szOEMVxD : [260]WCHAR, | |
| ManufacturerGuid : GUID, | |
| ProductGuid : GUID, | |
| NameGuid : GUID, | |
| }; | |
| PJOYCAPS2W :: ^JOYCAPS2W; | |
| NPJOYCAPS2W :: ^JOYCAPS2W; | |
| LPJOYCAPS2W :: ^JOYCAPS2W; | |
| JOYCAPS2 :: JOYCAPS2A; | |
| PJOYCAPS2 :: PJOYCAPS2A; | |
| NPJOYCAPS2 :: NPJOYCAPS2A; | |
| LPJOYCAPS2 :: LPJOYCAPS2A; | |
| JOYINFO :: struct { | |
| wXpos : UINT, | |
| wYpos : UINT, | |
| wZpos : UINT, | |
| wButtons : UINT, | |
| }; | |
| PJOYINFO :: ^JOYINFO; | |
| NPJOYINFO :: ^JOYINFO; | |
| LPJOYINFO :: ^JOYINFO; | |
| JOYINFOEX :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| dwXpos : DWORD, | |
| dwYpos : DWORD, | |
| dwZpos : DWORD, | |
| dwRpos : DWORD, | |
| dwUpos : DWORD, | |
| dwVpos : DWORD, | |
| dwButtons : DWORD, | |
| dwButtonNumber : DWORD, | |
| dwPOV : DWORD, | |
| dwReserved1 : DWORD, | |
| dwReserved2 : DWORD, | |
| }; | |
| PJOYINFOEX :: ^JOYINFOEX; | |
| NPJOYINFOEX :: ^JOYINFOEX; | |
| LPJOYINFOEX :: ^JOYINFOEX; | |
| NCB :: struct { | |
| ncb_command : UCHAR, | |
| ncb_retcode : UCHAR, | |
| ncb_lsn : UCHAR, | |
| ncb_num : UCHAR, | |
| ncb_buffer : PUCHAR, | |
| ncb_length : WORD, | |
| ncb_callname : [16]UCHAR, | |
| ncb_name : [16]UCHAR, | |
| ncb_rto : UCHAR, | |
| ncb_sto : UCHAR, | |
| ncb_post : proc "stdcall" (^NCB), | |
| ncb_lana_num : UCHAR, | |
| ncb_cmd_cplt : UCHAR, | |
| ncb_reserve : [18]UCHAR, | |
| ncb_event : HANDLE, | |
| }; | |
| PNCB :: ^NCB; | |
| ADAPTER_STATUS :: struct { | |
| adapter_address : [6]UCHAR, | |
| rev_major : UCHAR, | |
| reserved0 : UCHAR, | |
| adapter_type : UCHAR, | |
| rev_minor : UCHAR, | |
| duration : WORD, | |
| frmr_recv : WORD, | |
| frmr_xmit : WORD, | |
| iframe_recv_err : WORD, | |
| xmit_aborts : WORD, | |
| xmit_success : DWORD, | |
| recv_success : DWORD, | |
| iframe_xmit_err : WORD, | |
| recv_buff_unavail : WORD, | |
| t1_timeouts : WORD, | |
| ti_timeouts : WORD, | |
| reserved1 : DWORD, | |
| free_ncbs : WORD, | |
| max_cfg_ncbs : WORD, | |
| max_ncbs : WORD, | |
| xmit_buf_unavail : WORD, | |
| max_dgram_size : WORD, | |
| pending_sess : WORD, | |
| max_cfg_sess : WORD, | |
| max_sess : WORD, | |
| max_sess_pkt_size : WORD, | |
| name_count : WORD, | |
| }; | |
| PADAPTER_STATUS :: ^ADAPTER_STATUS; | |
| NAME_BUFFER :: struct { | |
| name : [16]UCHAR, | |
| name_num : UCHAR, | |
| name_flags : UCHAR, | |
| }; | |
| PNAME_BUFFER :: ^NAME_BUFFER; | |
| SESSION_HEADER :: struct { | |
| sess_name : UCHAR, | |
| num_sess : UCHAR, | |
| rcv_dg_outstanding : UCHAR, | |
| rcv_any_outstanding : UCHAR, | |
| }; | |
| PSESSION_HEADER :: ^SESSION_HEADER; | |
| SESSION_BUFFER :: struct { | |
| lsn : UCHAR, | |
| state : UCHAR, | |
| local_name : [16]UCHAR, | |
| remote_name : [16]UCHAR, | |
| rcvs_outstanding : UCHAR, | |
| sends_outstanding : UCHAR, | |
| }; | |
| PSESSION_BUFFER :: ^SESSION_BUFFER; | |
| LANA_ENUM :: struct { | |
| length : UCHAR, | |
| lana : [254 + 1]UCHAR, | |
| }; | |
| PLANA_ENUM :: ^LANA_ENUM; | |
| FIND_NAME_HEADER :: struct { | |
| node_count : WORD, | |
| reserved : UCHAR, | |
| unique_group : UCHAR, | |
| }; | |
| PFIND_NAME_HEADER :: ^FIND_NAME_HEADER; | |
| FIND_NAME_BUFFER :: struct { | |
| length : UCHAR, | |
| access_control : UCHAR, | |
| frame_control : UCHAR, | |
| destination_addr : [6]UCHAR, | |
| source_addr : [6]UCHAR, | |
| routing_info : [18]UCHAR, | |
| }; | |
| PFIND_NAME_BUFFER :: ^FIND_NAME_BUFFER; | |
| ACTION_HEADER :: struct { | |
| transport_id : ULONG, | |
| action_code : USHORT, | |
| reserved : USHORT, | |
| }; | |
| PACTION_HEADER :: ^ACTION_HEADER; | |
| I_RPC_HANDLE :: rawptr; | |
| RPC_STATUS :: _c.long; | |
| RPC_CSTR :: ^_c.uchar; | |
| RPC_WSTR :: ^_c.ushort; | |
| RPC_CWSTR :: ^_c.ushort; | |
| RPC_BINDING_HANDLE :: I_RPC_HANDLE; | |
| handle_t :: RPC_BINDING_HANDLE; | |
| UUID :: GUID; | |
| RPC_BINDING_VECTOR :: struct { | |
| Count : _c.ulong, | |
| BindingH : [1]RPC_BINDING_HANDLE, | |
| }; | |
| UUID_VECTOR :: struct { | |
| Count : _c.ulong, | |
| Uuid : [1]^UUID, | |
| }; | |
| RPC_IF_HANDLE :: rawptr; | |
| RPC_IF_ID :: struct { | |
| Uuid : UUID, | |
| VersMajor : _c.ushort, | |
| VersMinor : _c.ushort, | |
| }; | |
| RPC_PROTSEQ_VECTORA :: struct { | |
| Count : _c.uint, | |
| Protseq : [1]^_c.uchar, | |
| }; | |
| RPC_PROTSEQ_VECTORW :: struct { | |
| Count : _c.uint, | |
| Protseq : [1]^_c.ushort, | |
| }; | |
| RPC_POLICY :: struct { | |
| Length : _c.uint, | |
| EndpointFlags : _c.ulong, | |
| NICFlags : _c.ulong, | |
| }; | |
| PRPC_POLICY :: ^RPC_POLICY; | |
| RPC_OBJECT_INQ_FN :: #type proc "stdcall" (ObjectUuid : ^UUID, TypeUuid : ^UUID, Status : ^RPC_STATUS); | |
| RPC_IF_CALLBACK_FN :: #type (proc "stdcall" (InterfaceUuid : RPC_IF_HANDLE, Context : rawptr) -> RPC_STATUS); | |
| RPC_SECURITY_CALLBACK_FN :: #type proc "stdcall" (Context : rawptr); | |
| RPC_STATS_VECTOR :: struct { | |
| Count : _c.uint, | |
| Stats : [1]_c.ulong, | |
| }; | |
| RPC_IF_ID_VECTOR :: struct { | |
| Count : _c.ulong, | |
| IfId : [1]^RPC_IF_ID, | |
| }; | |
| RPC_AUTH_IDENTITY_HANDLE :: rawptr; | |
| RPC_AUTHZ_HANDLE :: rawptr; | |
| RPC_SECURITY_QOS :: struct { | |
| Version : _c.ulong, | |
| Capabilities : _c.ulong, | |
| IdentityTracking : _c.ulong, | |
| ImpersonationType : _c.ulong, | |
| }; | |
| PRPC_SECURITY_QOS :: ^RPC_SECURITY_QOS; | |
| SEC_WINNT_AUTH_IDENTITY_W :: struct { | |
| User : ^_c.ushort, | |
| UserLength : _c.ulong, | |
| Domain : ^_c.ushort, | |
| DomainLength : _c.ulong, | |
| Password : ^_c.ushort, | |
| PasswordLength : _c.ulong, | |
| Flags : _c.ulong, | |
| }; | |
| PSEC_WINNT_AUTH_IDENTITY_W :: ^SEC_WINNT_AUTH_IDENTITY_W; | |
| SEC_WINNT_AUTH_IDENTITY_A :: struct { | |
| User : ^_c.uchar, | |
| UserLength : _c.ulong, | |
| Domain : ^_c.uchar, | |
| DomainLength : _c.ulong, | |
| Password : ^_c.uchar, | |
| PasswordLength : _c.ulong, | |
| Flags : _c.ulong, | |
| }; | |
| PSEC_WINNT_AUTH_IDENTITY_A :: ^SEC_WINNT_AUTH_IDENTITY_A; | |
| RPC_HTTP_TRANSPORT_CREDENTIALS_W :: struct { | |
| TransportCredentials : ^SEC_WINNT_AUTH_IDENTITY_W, | |
| Flags : _c.ulong, | |
| AuthenticationTarget : _c.ulong, | |
| NumberOfAuthnSchemes : _c.ulong, | |
| AuthnSchemes : ^_c.ulong, | |
| ServerCertificateSubject : ^_c.ushort, | |
| }; | |
| PRPC_HTTP_TRANSPORT_CREDENTIALS_W :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_W; | |
| RPC_HTTP_TRANSPORT_CREDENTIALS_A :: struct { | |
| TransportCredentials : ^SEC_WINNT_AUTH_IDENTITY_A, | |
| Flags : _c.ulong, | |
| AuthenticationTarget : _c.ulong, | |
| NumberOfAuthnSchemes : _c.ulong, | |
| AuthnSchemes : ^_c.ulong, | |
| ServerCertificateSubject : ^_c.uchar, | |
| }; | |
| PRPC_HTTP_TRANSPORT_CREDENTIALS_A :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_A; | |
| RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W :: struct { | |
| TransportCredentials : ^SEC_WINNT_AUTH_IDENTITY_W, | |
| Flags : _c.ulong, | |
| AuthenticationTarget : _c.ulong, | |
| NumberOfAuthnSchemes : _c.ulong, | |
| AuthnSchemes : ^_c.ulong, | |
| ServerCertificateSubject : ^_c.ushort, | |
| ProxyCredentials : ^SEC_WINNT_AUTH_IDENTITY_W, | |
| NumberOfProxyAuthnSchemes : _c.ulong, | |
| ProxyAuthnSchemes : ^_c.ulong, | |
| }; | |
| PRPC_HTTP_TRANSPORT_CREDENTIALS_V2_W :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_V2_W; | |
| RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A :: struct { | |
| TransportCredentials : ^SEC_WINNT_AUTH_IDENTITY_A, | |
| Flags : _c.ulong, | |
| AuthenticationTarget : _c.ulong, | |
| NumberOfAuthnSchemes : _c.ulong, | |
| AuthnSchemes : ^_c.ulong, | |
| ServerCertificateSubject : ^_c.uchar, | |
| ProxyCredentials : ^SEC_WINNT_AUTH_IDENTITY_A, | |
| NumberOfProxyAuthnSchemes : _c.ulong, | |
| ProxyAuthnSchemes : ^_c.ulong, | |
| }; | |
| PRPC_HTTP_TRANSPORT_CREDENTIALS_V2_A :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_V2_A; | |
| RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W :: struct { | |
| TransportCredentials : RPC_AUTH_IDENTITY_HANDLE, | |
| Flags : _c.ulong, | |
| AuthenticationTarget : _c.ulong, | |
| NumberOfAuthnSchemes : _c.ulong, | |
| AuthnSchemes : ^_c.ulong, | |
| ServerCertificateSubject : ^_c.ushort, | |
| ProxyCredentials : RPC_AUTH_IDENTITY_HANDLE, | |
| NumberOfProxyAuthnSchemes : _c.ulong, | |
| ProxyAuthnSchemes : ^_c.ulong, | |
| }; | |
| PRPC_HTTP_TRANSPORT_CREDENTIALS_V3_W :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_V3_W; | |
| RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A :: struct { | |
| TransportCredentials : RPC_AUTH_IDENTITY_HANDLE, | |
| Flags : _c.ulong, | |
| AuthenticationTarget : _c.ulong, | |
| NumberOfAuthnSchemes : _c.ulong, | |
| AuthnSchemes : ^_c.ulong, | |
| ServerCertificateSubject : ^_c.uchar, | |
| ProxyCredentials : RPC_AUTH_IDENTITY_HANDLE, | |
| NumberOfProxyAuthnSchemes : _c.ulong, | |
| ProxyAuthnSchemes : ^_c.ulong, | |
| }; | |
| PRPC_HTTP_TRANSPORT_CREDENTIALS_V3_A :: ^RPC_HTTP_TRANSPORT_CREDENTIALS_V3_A; | |
| RPC_SECURITY_QOS_V2_W :: struct { | |
| Version : _c.ulong, | |
| Capabilities : _c.ulong, | |
| IdentityTracking : _c.ulong, | |
| ImpersonationType : _c.ulong, | |
| AdditionalSecurityInfoType : _c.ulong, | |
| u : struct #raw_union { | |
| HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W, | |
| }, | |
| }; | |
| PRPC_SECURITY_QOS_V2_W :: ^RPC_SECURITY_QOS_V2_W; | |
| RPC_SECURITY_QOS_V2_A :: struct { | |
| Version : _c.ulong, | |
| Capabilities : _c.ulong, | |
| IdentityTracking : _c.ulong, | |
| ImpersonationType : _c.ulong, | |
| AdditionalSecurityInfoType : _c.ulong, | |
| u : struct #raw_union { | |
| HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A, | |
| }, | |
| }; | |
| PRPC_SECURITY_QOS_V2_A :: ^RPC_SECURITY_QOS_V2_A; | |
| RPC_SECURITY_QOS_V3_W :: struct { | |
| Version : _c.ulong, | |
| Capabilities : _c.ulong, | |
| IdentityTracking : _c.ulong, | |
| ImpersonationType : _c.ulong, | |
| AdditionalSecurityInfoType : _c.ulong, | |
| u : struct #raw_union { | |
| HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W, | |
| }, | |
| Sid : rawptr, | |
| }; | |
| PRPC_SECURITY_QOS_V3_W :: ^RPC_SECURITY_QOS_V3_W; | |
| RPC_SECURITY_QOS_V3_A :: struct { | |
| Version : _c.ulong, | |
| Capabilities : _c.ulong, | |
| IdentityTracking : _c.ulong, | |
| ImpersonationType : _c.ulong, | |
| AdditionalSecurityInfoType : _c.ulong, | |
| u : struct #raw_union { | |
| HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A, | |
| }, | |
| Sid : rawptr, | |
| }; | |
| PRPC_SECURITY_QOS_V3_A :: ^RPC_SECURITY_QOS_V3_A; | |
| RPC_SECURITY_QOS_V4_W :: struct { | |
| Version : _c.ulong, | |
| Capabilities : _c.ulong, | |
| IdentityTracking : _c.ulong, | |
| ImpersonationType : _c.ulong, | |
| AdditionalSecurityInfoType : _c.ulong, | |
| u : struct #raw_union { | |
| HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W, | |
| }, | |
| Sid : rawptr, | |
| EffectiveOnly : _c.uint, | |
| }; | |
| PRPC_SECURITY_QOS_V4_W :: ^RPC_SECURITY_QOS_V4_W; | |
| RPC_SECURITY_QOS_V4_A :: struct { | |
| Version : _c.ulong, | |
| Capabilities : _c.ulong, | |
| IdentityTracking : _c.ulong, | |
| ImpersonationType : _c.ulong, | |
| AdditionalSecurityInfoType : _c.ulong, | |
| u : struct #raw_union { | |
| HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A, | |
| }, | |
| Sid : rawptr, | |
| EffectiveOnly : _c.uint, | |
| }; | |
| PRPC_SECURITY_QOS_V4_A :: ^RPC_SECURITY_QOS_V4_A; | |
| RPC_SECURITY_QOS_V5_W :: struct { | |
| Version : _c.ulong, | |
| Capabilities : _c.ulong, | |
| IdentityTracking : _c.ulong, | |
| ImpersonationType : _c.ulong, | |
| AdditionalSecurityInfoType : _c.ulong, | |
| u : struct #raw_union { | |
| HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_W, | |
| }, | |
| Sid : rawptr, | |
| EffectiveOnly : _c.uint, | |
| ServerSecurityDescriptor : rawptr, | |
| }; | |
| PRPC_SECURITY_QOS_V5_W :: ^RPC_SECURITY_QOS_V5_W; | |
| RPC_SECURITY_QOS_V5_A :: struct { | |
| Version : _c.ulong, | |
| Capabilities : _c.ulong, | |
| IdentityTracking : _c.ulong, | |
| ImpersonationType : _c.ulong, | |
| AdditionalSecurityInfoType : _c.ulong, | |
| u : struct #raw_union { | |
| HttpCredentials : ^RPC_HTTP_TRANSPORT_CREDENTIALS_A, | |
| }, | |
| Sid : rawptr, | |
| EffectiveOnly : _c.uint, | |
| ServerSecurityDescriptor : rawptr, | |
| }; | |
| PRPC_SECURITY_QOS_V5_A :: ^RPC_SECURITY_QOS_V5_A; | |
| RPC_BINDING_HANDLE_TEMPLATE_V1_W :: struct { | |
| Version : _c.ulong, | |
| Flags : _c.ulong, | |
| ProtocolSequence : _c.ulong, | |
| NetworkAddress : ^_c.ushort, | |
| StringEndpoint : ^_c.ushort, | |
| u1 : struct #raw_union { | |
| Reserved : ^_c.ushort, | |
| }, | |
| ObjectUuid : UUID, | |
| }; | |
| PRPC_BINDING_HANDLE_TEMPLATE_V1_W :: ^RPC_BINDING_HANDLE_TEMPLATE_V1_W; | |
| RPC_BINDING_HANDLE_TEMPLATE_V1_A :: struct { | |
| Version : _c.ulong, | |
| Flags : _c.ulong, | |
| ProtocolSequence : _c.ulong, | |
| NetworkAddress : ^_c.uchar, | |
| StringEndpoint : ^_c.uchar, | |
| u1 : struct #raw_union { | |
| Reserved : ^_c.uchar, | |
| }, | |
| ObjectUuid : UUID, | |
| }; | |
| PRPC_BINDING_HANDLE_TEMPLATE_V1_A :: ^RPC_BINDING_HANDLE_TEMPLATE_V1_A; | |
| RPC_BINDING_HANDLE_SECURITY_V1_W :: struct { | |
| Version : _c.ulong, | |
| ServerPrincName : ^_c.ushort, | |
| AuthnLevel : _c.ulong, | |
| AuthnSvc : _c.ulong, | |
| AuthIdentity : ^SEC_WINNT_AUTH_IDENTITY_W, | |
| SecurityQos : ^RPC_SECURITY_QOS, | |
| }; | |
| PRPC_BINDING_HANDLE_SECURITY_V1_W :: ^RPC_BINDING_HANDLE_SECURITY_V1_W; | |
| RPC_BINDING_HANDLE_SECURITY_V1_A :: struct { | |
| Version : _c.ulong, | |
| ServerPrincName : ^_c.uchar, | |
| AuthnLevel : _c.ulong, | |
| AuthnSvc : _c.ulong, | |
| AuthIdentity : ^SEC_WINNT_AUTH_IDENTITY_A, | |
| SecurityQos : ^RPC_SECURITY_QOS, | |
| }; | |
| PRPC_BINDING_HANDLE_SECURITY_V1_A :: ^RPC_BINDING_HANDLE_SECURITY_V1_A; | |
| RPC_BINDING_HANDLE_OPTIONS_V1 :: struct { | |
| Version : _c.ulong, | |
| Flags : _c.ulong, | |
| ComTimeout : _c.ulong, | |
| CallTimeout : _c.ulong, | |
| }; | |
| PRPC_BINDING_HANDLE_OPTIONS_V1 :: ^RPC_BINDING_HANDLE_OPTIONS_V1; | |
| /* RPC_HTTP_REDIRECTOR_STAGE :: enum { */ | |
| RPC_HTTP_REDIRECTOR_STAGE :: _c.int; | |
| RPCHTTP_RS_REDIRECT :: 1; | |
| RPCHTTP_RS_ACCESS_1 :: RPCHTTP_RS_REDIRECT + 1; | |
| RPCHTTP_RS_SESSION :: RPCHTTP_RS_ACCESS_1 + 1; | |
| RPCHTTP_RS_ACCESS_2 :: RPCHTTP_RS_SESSION + 1; | |
| RPCHTTP_RS_INTERFACE :: RPCHTTP_RS_ACCESS_2 + 1; | |
| /* } */ | |
| ; | |
| RPC_NEW_HTTP_PROXY_CHANNEL :: (proc "stdcall" (RedirectorStage : RPC_HTTP_REDIRECTOR_STAGE, ServerName : RPC_WSTR, ServerPort : RPC_WSTR, RemoteUser : RPC_WSTR, AuthType : RPC_WSTR, ResourceUuid : rawptr, SessionId : rawptr, Interface : rawptr, Reserved : rawptr, Flags : _c.ulong, NewServerName : ^RPC_WSTR, NewServerPort : ^RPC_WSTR) -> RPC_STATUS); | |
| RPC_HTTP_PROXY_FREE_STRING :: proc "stdcall" (String : RPC_WSTR); | |
| RPC_AUTH_KEY_RETRIEVAL_FN :: proc "stdcall" (Arg : rawptr, ServerPrincName : RPC_WSTR, KeyVer : _c.ulong, Key : ^rawptr, Status : ^RPC_STATUS); | |
| RPC_CLIENT_INFORMATION1 :: struct { | |
| UserName : ^_c.uchar, | |
| ComputerName : ^_c.uchar, | |
| Privilege : _c.ushort, | |
| AuthFlags : _c.ulong, | |
| }; | |
| PRPC_CLIENT_INFORMATION1 :: ^RPC_CLIENT_INFORMATION1; | |
| RPC_EP_INQ_HANDLE :: ^I_RPC_HANDLE; | |
| RPC_MGMT_AUTHORIZATION_FN :: (proc "stdcall" (ClientBinding : RPC_BINDING_HANDLE, RequestedMgmtOperation : _c.ulong, Status : ^RPC_STATUS) -> _c.int); | |
| RPC_INTERFACE_GROUP :: rawptr; | |
| PRPC_INTERFACE_GROUP :: ^rawptr; | |
| RPC_ENDPOINT_TEMPLATEW :: struct { | |
| Version : _c.ulong, | |
| ProtSeq : RPC_WSTR, | |
| Endpoint : RPC_WSTR, | |
| SecurityDescriptor : rawptr, | |
| Backlog : _c.ulong, | |
| }; | |
| PRPC_ENDPOINT_TEMPLATEW :: ^RPC_ENDPOINT_TEMPLATEW; | |
| RPC_ENDPOINT_TEMPLATEA :: struct { | |
| Version : _c.ulong, | |
| ProtSeq : RPC_CSTR, | |
| Endpoint : RPC_CSTR, | |
| SecurityDescriptor : rawptr, | |
| Backlog : _c.ulong, | |
| }; | |
| PRPC_ENDPOINT_TEMPLATEA :: ^RPC_ENDPOINT_TEMPLATEA; | |
| RPC_INTERFACE_TEMPLATEA :: struct { | |
| Version : _c.ulong, | |
| IfSpec : RPC_IF_HANDLE, | |
| MgrTypeUuid : ^UUID, | |
| MgrEpv : rawptr, | |
| Flags : _c.uint, | |
| MaxCalls : _c.uint, | |
| MaxRpcSize : _c.uint, | |
| IfCallback : ^RPC_IF_CALLBACK_FN, | |
| UuidVector : ^UUID_VECTOR, | |
| Annotation : RPC_CSTR, | |
| SecurityDescriptor : rawptr, | |
| }; | |
| PRPC_INTERFACE_TEMPLATEA :: ^RPC_INTERFACE_TEMPLATEA; | |
| RPC_INTERFACE_TEMPLATEW :: struct { | |
| Version : _c.ulong, | |
| IfSpec : RPC_IF_HANDLE, | |
| MgrTypeUuid : ^UUID, | |
| MgrEpv : rawptr, | |
| Flags : _c.uint, | |
| MaxCalls : _c.uint, | |
| MaxRpcSize : _c.uint, | |
| IfCallback : ^RPC_IF_CALLBACK_FN, | |
| UuidVector : ^UUID_VECTOR, | |
| Annotation : RPC_WSTR, | |
| SecurityDescriptor : rawptr, | |
| }; | |
| PRPC_INTERFACE_TEMPLATEW :: ^RPC_INTERFACE_TEMPLATEW; | |
| RPC_INTERFACE_GROUP_IDLE_CALLBACK_FN :: #type proc "stdcall" (IfGroup : RPC_INTERFACE_GROUP, IdleCallbackContext : rawptr, IsGroupIdle : _c.ulong); | |
| RPC_VERSION :: struct { | |
| MajorVersion : _c.ushort, | |
| MinorVersion : _c.ushort, | |
| }; | |
| RPC_SYNTAX_IDENTIFIER :: struct { | |
| SyntaxGUID : GUID, | |
| SyntaxVersion : RPC_VERSION, | |
| }; | |
| PRPC_SYNTAX_IDENTIFIER :: ^RPC_SYNTAX_IDENTIFIER; | |
| RPC_MESSAGE :: struct { | |
| Handle : RPC_BINDING_HANDLE, | |
| DataRepresentation : _c.ulong, | |
| Buffer : rawptr, | |
| BufferLength : _c.uint, | |
| ProcNum : _c.uint, | |
| TransferSyntax : PRPC_SYNTAX_IDENTIFIER, | |
| RpcInterfaceInformation : rawptr, | |
| ReservedForRuntime : rawptr, | |
| ManagerEpv : rawptr, | |
| ImportContext : rawptr, | |
| RpcFlags : _c.ulong, | |
| }; | |
| PRPC_MESSAGE :: ^RPC_MESSAGE; | |
| RPC_FORWARD_FUNCTION :: #type (proc "stdcall" (InterfaceId : ^UUID, InterfaceVersion : ^RPC_VERSION, ObjectId : ^UUID, Rpcpro : ^_c.uchar, ppDestEndpoint : ^rawptr) -> RPC_STATUS); | |
| /* RPC_ADDRESS_CHANGE_TYPE :: enum { */ | |
| RPC_ADDRESS_CHANGE_TYPE :: _c.int; | |
| PROTOCOL_NOT_LOADED :: 1; | |
| PROTOCOL_LOADED :: PROTOCOL_NOT_LOADED + 1; | |
| PROTOCOL_ADDRESS_CHANGE :: PROTOCOL_LOADED + 1; | |
| /* } */ | |
| ; | |
| RPC_ADDRESS_CHANGE_FN :: #type proc "stdcall" (arg : rawptr); | |
| RPC_DISPATCH_FUNCTION :: proc "stdcall" (Message : PRPC_MESSAGE); | |
| RPC_DISPATCH_TABLE :: struct { | |
| DispatchTableCount : _c.uint, | |
| DispatchTable : ^RPC_DISPATCH_FUNCTION, | |
| Reserved : LONG_PTR, | |
| }; | |
| PRPC_DISPATCH_TABLE :: ^RPC_DISPATCH_TABLE; | |
| RPC_PROTSEQ_ENDPOINT :: struct { | |
| RpcProtocolSequence : ^_c.uchar, | |
| Endpoint : ^_c.uchar, | |
| }; | |
| PRPC_PROTSEQ_ENDPOINT :: ^RPC_PROTSEQ_ENDPOINT; | |
| RPC_SERVER_INTERFACE :: struct { | |
| Length : _c.uint, | |
| InterfaceId : RPC_SYNTAX_IDENTIFIER, | |
| TransferSyntax : RPC_SYNTAX_IDENTIFIER, | |
| DispatchTable : PRPC_DISPATCH_TABLE, | |
| RpcProtseqEndpointCount : _c.uint, | |
| RpcProtseqEndpoint : PRPC_PROTSEQ_ENDPOINT, | |
| DefaultManagerEpv : rawptr, | |
| InterpreterInfo : rawptr, | |
| Flags : _c.uint, | |
| }; | |
| PRPC_SERVER_INTERFACE :: ^RPC_SERVER_INTERFACE; | |
| RPC_CLIENT_INTERFACE :: struct { | |
| Length : _c.uint, | |
| InterfaceId : RPC_SYNTAX_IDENTIFIER, | |
| TransferSyntax : RPC_SYNTAX_IDENTIFIER, | |
| DispatchTable : PRPC_DISPATCH_TABLE, | |
| RpcProtseqEndpointCount : _c.uint, | |
| RpcProtseqEndpoint : PRPC_PROTSEQ_ENDPOINT, | |
| Reserved : ULONG_PTR, | |
| InterpreterInfo : rawptr, | |
| Flags : _c.uint, | |
| }; | |
| PRPC_CLIENT_INTERFACE :: ^RPC_CLIENT_INTERFACE; | |
| I_RPC_MUTEX :: rawptr; | |
| /* LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION :: enum { */ | |
| LRPC_SYSTEM_HANDLE_MARSHAL_DIRECTION :: _c.int; | |
| MarshalDirectionMarshal :: 0; | |
| MarshalDirectionUnmarshal :: MarshalDirectionMarshal + 1; | |
| /* } */ | |
| ; | |
| PRPC_RUNDOWN :: proc "stdcall" (AssociationContext : rawptr); | |
| RPC_SEC_CONTEXT_KEY_INFO :: struct { | |
| EncryptAlgorithm : _c.ulong, | |
| KeySize : _c.ulong, | |
| SignatureAlgorithm : _c.ulong, | |
| }; | |
| PRPC_SEC_CONTEXT_KEY_INFO :: ^RPC_SEC_CONTEXT_KEY_INFO; | |
| RPC_TRANSFER_SYNTAX :: struct { | |
| Uuid : UUID, | |
| VersMajor : _c.ushort, | |
| VersMinor : _c.ushort, | |
| }; | |
| RPCLT_PDU_FILTER_FUNC :: proc(Buffer : rawptr, BufferLength : _c.uint, fDatagram : _c.int); | |
| RPC_SETFILTER_FUNC :: proc(pfnFilter : RPCLT_PDU_FILTER_FUNC); | |
| RPC_BLOCKING_FN :: (proc(hWnd : rawptr, Context : rawptr, hSyncEvent : rawptr) -> RPC_STATUS); | |
| RPC_C_OPT_COOKIE_AUTH_DESCRIPTOR :: struct { | |
| BufferSize : _c.ulong, | |
| Buffer : ^_c.uchar, | |
| }; | |
| RDR_CALLOUT_STATE :: struct { | |
| LastError : RPC_STATUS, | |
| LastEEInfo : rawptr, | |
| LastCalledStage : RPC_HTTP_REDIRECTOR_STAGE, | |
| ServerName : ^_c.ushort, | |
| ServerPort : ^_c.ushort, | |
| RemoteUser : ^_c.ushort, | |
| AuthType : ^_c.ushort, | |
| ResourceTypePresent : _c.uchar, | |
| SessionIdPresent : _c.uchar, | |
| InterfacePresent : _c.uchar, | |
| ResourceType : UUID, | |
| SessionId : UUID, | |
| Interface : RPC_SYNTAX_IDENTIFIER, | |
| CertContext : rawptr, | |
| }; | |
| I_RpcProxyIsValidMachineFn :: (proc "stdcall" (Machine : RPC_WSTR, DotMachine : RPC_WSTR, PortNumber : _c.ulong) -> RPC_STATUS); | |
| I_RpcProxyGetClientAddressFn :: (proc "stdcall" (Context : rawptr, Buffer : ^_c.uchar, BufferLength : ^_c.ulong) -> RPC_STATUS); | |
| I_RpcProxyGetConnectionTimeoutFn :: (proc "stdcall" (ConnectionTimeout : ^_c.ulong) -> RPC_STATUS); | |
| I_RpcPerformCalloutFn :: (proc "stdcall" (Context : rawptr, CallOutState : ^RDR_CALLOUT_STATE, Stage : RPC_HTTP_REDIRECTOR_STAGE) -> RPC_STATUS); | |
| I_RpcFreeCalloutStateFn :: proc "stdcall" (CallOutState : ^RDR_CALLOUT_STATE); | |
| I_RpcProxyGetClientSessionAndResourceUUID :: (proc "stdcall" (Context : rawptr, SessionIdPresent : ^_c.int, SessionId : ^UUID, ResourceIdPresent : ^_c.int, ResourceId : ^UUID) -> RPC_STATUS); | |
| I_RpcProxyFilterIfFn :: (proc "stdcall" (Context : rawptr, IfUuid : ^UUID, IfMajorVersion : _c.ushort, fAllow : ^_c.int) -> RPC_STATUS); | |
| /* RpcPerfCounters :: enum { */ | |
| RpcPerfCounters :: _c.int; | |
| RpcCurrentUniqueUser :: 1; | |
| RpcBackEndConnectionAttempts :: RpcCurrentUniqueUser + 1; | |
| RpcBackEndConnectionFailed :: RpcBackEndConnectionAttempts + 1; | |
| RpcRequestsPerSecond :: RpcBackEndConnectionFailed + 1; | |
| RpcIncomingConnections :: RpcRequestsPerSecond + 1; | |
| RpcIncomingBandwidth :: RpcIncomingConnections + 1; | |
| RpcOutgoingBandwidth :: RpcIncomingBandwidth + 1; | |
| RpcAttemptedLbsDecisions :: RpcOutgoingBandwidth + 1; | |
| RpcFailedLbsDecisions :: RpcAttemptedLbsDecisions + 1; | |
| RpcAttemptedLbsMessages :: RpcFailedLbsDecisions + 1; | |
| RpcFailedLbsMessages :: RpcAttemptedLbsMessages + 1; | |
| RpcLastCounter :: RpcFailedLbsMessages + 1; | |
| /* } */ | |
| ; | |
| I_RpcProxyUpdatePerfCounterFn :: proc "stdcall" (Counter : RpcPerfCounters, ModifyTrend : _c.int, Size : _c.ulong); | |
| I_RpcProxyUpdatePerfCounterBackendServerFn :: proc "stdcall" (MachineName : ^_c.ushort, IsConnectEvent : _c.int); | |
| I_RpcProxyCallbackInterface :: struct { | |
| IsValidMachineFn : I_RpcProxyIsValidMachineFn, | |
| GetClientAddressFn : I_RpcProxyGetClientAddressFn, | |
| GetConnectionTimeoutFn : I_RpcProxyGetConnectionTimeoutFn, | |
| PerformCalloutFn : I_RpcPerformCalloutFn, | |
| FreeCalloutStateFn : I_RpcFreeCalloutStateFn, | |
| GetClientSessionAndResourceUUIDFn : I_RpcProxyGetClientSessionAndResourceUUID, | |
| ProxyFilterIfFn : I_RpcProxyFilterIfFn, | |
| RpcProxyUpdatePerfCounterFn : I_RpcProxyUpdatePerfCounterFn, | |
| RpcProxyUpdatePerfCounterBackendServerFn : I_RpcProxyUpdatePerfCounterBackendServerFn, | |
| }; | |
| RPC_NS_HANDLE :: rawptr; | |
| /* RPC_NOTIFICATION_TYPES :: enum { */ | |
| RPC_NOTIFICATION_TYPES :: _c.int; | |
| RpcNotificationTypeNone :: 0; | |
| RpcNotificationTypeEvent :: RpcNotificationTypeNone + 1; | |
| RpcNotificationTypeApc :: RpcNotificationTypeEvent + 1; | |
| RpcNotificationTypeIoc :: RpcNotificationTypeApc + 1; | |
| RpcNotificationTypeHwnd :: RpcNotificationTypeIoc + 1; | |
| RpcNotificationTypeCallback :: RpcNotificationTypeHwnd + 1; | |
| /* } */ | |
| ; | |
| /* RPC_ASYNC_EVENT :: enum { */ | |
| RPC_ASYNC_EVENT :: _c.int; | |
| RpcCallComplete :: 0; | |
| RpcSendComplete :: RpcCallComplete + 1; | |
| RpcReceiveComplete :: RpcSendComplete + 1; | |
| RpcClientDisconnect :: RpcReceiveComplete + 1; | |
| RpcClientCancel :: RpcClientDisconnect + 1; | |
| /* } */ | |
| ; | |
| RPCNOTIFICATION_ROUTINE :: #type proc "stdcall" (pAsync : ^RPC_ASYNC_STATE, Context : rawptr, Event : RPC_ASYNC_EVENT); | |
| PFN_RPCNOTIFICATION_ROUTINE :: ^RPCNOTIFICATION_ROUTINE; | |
| RPC_ASYNC_NOTIFICATION_INFO :: struct #raw_union { | |
| APC : struct { | |
| NotificationRoutine : PFN_RPCNOTIFICATION_ROUTINE, | |
| hThread : HANDLE, | |
| }, | |
| IOC : struct { | |
| hIOPort : HANDLE, | |
| dwNumberOfBytesTransferred : DWORD, | |
| dwCompletionKey : DWORD_PTR, | |
| lpOverlapped : LPOVERLAPPED, | |
| }, | |
| HWND : struct { | |
| hWnd : HWND, | |
| Msg : UINT, | |
| }, | |
| hEvent : HANDLE, | |
| NotificationRoutine : PFN_RPCNOTIFICATION_ROUTINE, | |
| }; | |
| PRPC_ASYNC_NOTIFICATION_INFO :: ^RPC_ASYNC_NOTIFICATION_INFO; | |
| RPC_ASYNC_STATE :: struct { | |
| Size : _c.uint, | |
| Signature : _c.ulong, | |
| Lock : _c.long, | |
| Flags : _c.ulong, | |
| StubInfo : rawptr, | |
| UserInfo : rawptr, | |
| RuntimeInfo : rawptr, | |
| Event : RPC_ASYNC_EVENT, | |
| NotificationType : RPC_NOTIFICATION_TYPES, | |
| u : RPC_ASYNC_NOTIFICATION_INFO, | |
| Reserved : [4]LONG_PTR, | |
| }; | |
| PRPC_ASYNC_STATE :: ^RPC_ASYNC_STATE; | |
| /* ExtendedErrorParamTypes :: enum { */ | |
| ExtendedErrorParamTypes :: _c.int; | |
| eeptAnsiString :: 1; | |
| eeptUnicodeString :: eeptAnsiString + 1; | |
| eeptLongVal :: eeptUnicodeString + 1; | |
| eeptShortVal :: eeptLongVal + 1; | |
| eeptPointerVal :: eeptShortVal + 1; | |
| eeptNone :: eeptPointerVal + 1; | |
| eeptBinary :: eeptNone + 1; | |
| /* } */ | |
| ; | |
| BinaryParam :: struct { | |
| Buffer : rawptr, | |
| Size : _c.short, | |
| }; | |
| RPC_EE_INFO_PARAM :: struct { | |
| ParameterType : ExtendedErrorParamTypes, | |
| u : struct #raw_union { | |
| AnsiString : LPSTR, | |
| UnicodeString : LPWSTR, | |
| LVal : _c.long, | |
| SVal : _c.short, | |
| PVal : ULONGLONG, | |
| BVal : BinaryParam, | |
| }, | |
| }; | |
| RPC_EXTENDED_ERROR_INFO :: struct { | |
| Version : ULONG, | |
| ComputerName : LPWSTR, | |
| ProcessID : ULONG, | |
| u : struct #raw_union { | |
| SystemTime : SYSTEMTIME, | |
| FileTime : FILETIME, | |
| }, | |
| GeneratingComponent : ULONG, | |
| Status : ULONG, | |
| DetectionLocation : USHORT, | |
| Flags : USHORT, | |
| NumberOfParameters : _c.int, | |
| Parameters : [4]RPC_EE_INFO_PARAM, | |
| }; | |
| RPC_ERROR_ENUM_HANDLE :: struct { | |
| Signature : ULONG, | |
| CurrentPos : rawptr, | |
| Head : rawptr, | |
| }; | |
| /* RpcLocalAddressFormat :: enum { */ | |
| RpcLocalAddressFormat :: _c.int; | |
| rlafInvalid :: 0; | |
| rlafIPv4 :: rlafInvalid + 1; | |
| rlafIPv6 :: rlafIPv4 + 1; | |
| /* } */ | |
| ; | |
| RPC_CALL_LOCAL_ADDRESS_V1 :: struct { | |
| Version : _c.uint, | |
| Buffer : rawptr, | |
| BufferSize : _c.ulong, | |
| AddressFormat : RpcLocalAddressFormat, | |
| }; | |
| PRPC_CALL_LOCAL_ADDRESS_V1 :: ^RPC_CALL_LOCAL_ADDRESS_V1; | |
| RPC_CALL_ATTRIBUTES_V1_W :: struct { | |
| Version : _c.uint, | |
| Flags : _c.ulong, | |
| ServerPrincipalNameBufferLength : _c.ulong, | |
| ServerPrincipalName : ^_c.ushort, | |
| ClientPrincipalNameBufferLength : _c.ulong, | |
| ClientPrincipalName : ^_c.ushort, | |
| AuthenticationLevel : _c.ulong, | |
| AuthenticationService : _c.ulong, | |
| NullSession : BOOL, | |
| }; | |
| RPC_CALL_ATTRIBUTES_V1_A :: struct { | |
| Version : _c.uint, | |
| Flags : _c.ulong, | |
| ServerPrincipalNameBufferLength : _c.ulong, | |
| ServerPrincipalName : ^_c.uchar, | |
| ClientPrincipalNameBufferLength : _c.ulong, | |
| ClientPrincipalName : ^_c.uchar, | |
| AuthenticationLevel : _c.ulong, | |
| AuthenticationService : _c.ulong, | |
| NullSession : BOOL, | |
| }; | |
| /* RpcCallType :: enum { */ | |
| RpcCallType :: _c.int; | |
| rctInvalid :: 0; | |
| rctNormal :: rctInvalid + 1; | |
| rctTraining :: rctNormal + 1; | |
| rctGuaranteed :: rctTraining + 1; | |
| /* } */ | |
| ; | |
| /* RpcCallClientLocality :: enum { */ | |
| RpcCallClientLocality :: _c.int; | |
| rcclInvalid :: 0; | |
| rcclLocal :: rcclInvalid + 1; | |
| rcclRemote :: rcclLocal + 1; | |
| rcclClientUnknownLocality :: rcclRemote + 1; | |
| /* } */ | |
| ; | |
| RPC_CALL_ATTRIBUTES_V2_W :: struct { | |
| Version : _c.uint, | |
| Flags : _c.ulong, | |
| ServerPrincipalNameBufferLength : _c.ulong, | |
| ServerPrincipalName : ^_c.ushort, | |
| ClientPrincipalNameBufferLength : _c.ulong, | |
| ClientPrincipalName : ^_c.ushort, | |
| AuthenticationLevel : _c.ulong, | |
| AuthenticationService : _c.ulong, | |
| NullSession : BOOL, | |
| KernelModeCaller : BOOL, | |
| ProtocolSequence : _c.ulong, | |
| IsClientLocal : RpcCallClientLocality, | |
| ClientPID : HANDLE, | |
| CallStatus : _c.ulong, | |
| CallType : RpcCallType, | |
| CallLocalAddress : ^RPC_CALL_LOCAL_ADDRESS_V1, | |
| OpNum : _c.ushort, | |
| InterfaceUuid : UUID, | |
| }; | |
| RPC_CALL_ATTRIBUTES_V2_A :: struct { | |
| Version : _c.uint, | |
| Flags : _c.ulong, | |
| ServerPrincipalNameBufferLength : _c.ulong, | |
| ServerPrincipalName : ^_c.uchar, | |
| ClientPrincipalNameBufferLength : _c.ulong, | |
| ClientPrincipalName : ^_c.uchar, | |
| AuthenticationLevel : _c.ulong, | |
| AuthenticationService : _c.ulong, | |
| NullSession : BOOL, | |
| KernelModeCaller : BOOL, | |
| ProtocolSequence : _c.ulong, | |
| IsClientLocal : _c.ulong, | |
| ClientPID : HANDLE, | |
| CallStatus : _c.ulong, | |
| CallType : RpcCallType, | |
| CallLocalAddress : ^RPC_CALL_LOCAL_ADDRESS_V1, | |
| OpNum : _c.ushort, | |
| InterfaceUuid : UUID, | |
| }; | |
| RPC_CALL_ATTRIBUTES_V3_W :: struct { | |
| Version : _c.uint, | |
| Flags : _c.ulong, | |
| ServerPrincipalNameBufferLength : _c.ulong, | |
| ServerPrincipalName : ^_c.ushort, | |
| ClientPrincipalNameBufferLength : _c.ulong, | |
| ClientPrincipalName : ^_c.ushort, | |
| AuthenticationLevel : _c.ulong, | |
| AuthenticationService : _c.ulong, | |
| NullSession : BOOL, | |
| KernelModeCaller : BOOL, | |
| ProtocolSequence : _c.ulong, | |
| IsClientLocal : RpcCallClientLocality, | |
| ClientPID : HANDLE, | |
| CallStatus : _c.ulong, | |
| CallType : RpcCallType, | |
| CallLocalAddress : ^RPC_CALL_LOCAL_ADDRESS_V1, | |
| OpNum : _c.ushort, | |
| InterfaceUuid : UUID, | |
| ClientIdentifierBufferLength : _c.ulong, | |
| ClientIdentifier : ^_c.uchar, | |
| }; | |
| RPC_CALL_ATTRIBUTES_V3_A :: struct { | |
| Version : _c.uint, | |
| Flags : _c.ulong, | |
| ServerPrincipalNameBufferLength : _c.ulong, | |
| ServerPrincipalName : ^_c.uchar, | |
| ClientPrincipalNameBufferLength : _c.ulong, | |
| ClientPrincipalName : ^_c.uchar, | |
| AuthenticationLevel : _c.ulong, | |
| AuthenticationService : _c.ulong, | |
| NullSession : BOOL, | |
| KernelModeCaller : BOOL, | |
| ProtocolSequence : _c.ulong, | |
| IsClientLocal : _c.ulong, | |
| ClientPID : HANDLE, | |
| CallStatus : _c.ulong, | |
| CallType : RpcCallType, | |
| CallLocalAddress : ^RPC_CALL_LOCAL_ADDRESS_V1, | |
| OpNum : _c.ushort, | |
| InterfaceUuid : UUID, | |
| ClientIdentifierBufferLength : _c.ulong, | |
| ClientIdentifier : ^_c.uchar, | |
| }; | |
| RPC_CALL_ATTRIBUTES :: RPC_CALL_ATTRIBUTES_V3_A; | |
| /* RPC_NOTIFICATIONS :: enum { */ | |
| RPC_NOTIFICATIONS :: _c.int; | |
| RpcNotificationCallNone :: 0; | |
| RpcNotificationClientDisconnect :: 1; | |
| RpcNotificationCallCancel :: 2; | |
| /* } */ | |
| ; | |
| HDROP__ :: struct { | |
| unused : _c.int, | |
| }; | |
| HDROP :: ^HDROP__; | |
| DRAGINFOA :: struct { | |
| uSize : UINT, | |
| pt : POINT, | |
| fNC : BOOL, | |
| lpFileList : PZZSTR, | |
| grfKeyState : DWORD, | |
| }; | |
| LPDRAGINFOA :: ^DRAGINFOA; | |
| DRAGINFOW :: struct { | |
| uSize : UINT, | |
| pt : POINT, | |
| fNC : BOOL, | |
| lpFileList : PZZWSTR, | |
| grfKeyState : DWORD, | |
| }; | |
| LPDRAGINFOW :: ^DRAGINFOW; | |
| DRAGINFO :: DRAGINFOA; | |
| LPDRAGINFO :: LPDRAGINFOA; | |
| APPBARDATA :: struct { | |
| cbSize : DWORD, | |
| hWnd : HWND, | |
| uCallbackMessage : UINT, | |
| uEdge : UINT, | |
| rc : RECT, | |
| lParam : LPARAM, | |
| }; | |
| PAPPBARDATA :: ^APPBARDATA; | |
| FILEOP_FLAGS :: WORD; | |
| PRINTEROP_FLAGS :: WORD; | |
| SHFILEOPSTRUCTA :: struct { | |
| hwnd : HWND, | |
| wFunc : UINT, | |
| pFrom : PCZZSTR, | |
| pTo : PCZZSTR, | |
| fFlags : FILEOP_FLAGS, | |
| fAnyOperationsAborted : BOOL, | |
| hNameMappings : LPVOID, | |
| lpszProgressTitle : PCSTR, | |
| }; | |
| LPSHFILEOPSTRUCTA :: ^SHFILEOPSTRUCTA; | |
| SHFILEOPSTRUCTW :: struct { | |
| hwnd : HWND, | |
| wFunc : UINT, | |
| pFrom : PCZZWSTR, | |
| pTo : PCZZWSTR, | |
| fFlags : FILEOP_FLAGS, | |
| fAnyOperationsAborted : BOOL, | |
| hNameMappings : LPVOID, | |
| lpszProgressTitle : PCWSTR, | |
| }; | |
| LPSHFILEOPSTRUCTW :: ^SHFILEOPSTRUCTW; | |
| SHFILEOPSTRUCT :: SHFILEOPSTRUCTA; | |
| LPSHFILEOPSTRUCT :: LPSHFILEOPSTRUCTA; | |
| SHNAMEMAPPINGA :: struct { | |
| pszOldPath : LPSTR, | |
| pszNewPath : LPSTR, | |
| cchOldPath : _c.int, | |
| cchNewPath : _c.int, | |
| }; | |
| LPSHNAMEMAPPINGA :: ^SHNAMEMAPPINGA; | |
| SHNAMEMAPPINGW :: struct { | |
| pszOldPath : LPWSTR, | |
| pszNewPath : LPWSTR, | |
| cchOldPath : _c.int, | |
| cchNewPath : _c.int, | |
| }; | |
| LPSHNAMEMAPPINGW :: ^SHNAMEMAPPINGW; | |
| SHNAMEMAPPING :: SHNAMEMAPPINGA; | |
| LPSHNAMEMAPPING :: LPSHNAMEMAPPINGA; | |
| SHELLEXECUTEINFOA :: struct { | |
| cbSize : DWORD, | |
| fMask : ULONG, | |
| hwnd : HWND, | |
| lpVerb : LPCSTR, | |
| lpFile : LPCSTR, | |
| lpParameters : LPCSTR, | |
| lpDirectory : LPCSTR, | |
| nShow : _c.int, | |
| hInstApp : HINSTANCE, | |
| lpIDList : rawptr, | |
| lpClass : LPCSTR, | |
| hkeyClass : HKEY, | |
| dwHotKey : DWORD, | |
| u : struct #raw_union { | |
| hIcon : HANDLE, | |
| hMonitor : HANDLE, | |
| }, | |
| hProcess : HANDLE, | |
| }; | |
| LPSHELLEXECUTEINFOA :: ^SHELLEXECUTEINFOA; | |
| SHELLEXECUTEINFOW :: struct { | |
| cbSize : DWORD, | |
| fMask : ULONG, | |
| hwnd : HWND, | |
| lpVerb : LPCWSTR, | |
| lpFile : LPCWSTR, | |
| lpParameters : LPCWSTR, | |
| lpDirectory : LPCWSTR, | |
| nShow : _c.int, | |
| hInstApp : HINSTANCE, | |
| lpIDList : rawptr, | |
| lpClass : LPCWSTR, | |
| hkeyClass : HKEY, | |
| dwHotKey : DWORD, | |
| u : struct #raw_union { | |
| hIcon : HANDLE, | |
| hMonitor : HANDLE, | |
| }, | |
| hProcess : HANDLE, | |
| }; | |
| LPSHELLEXECUTEINFOW :: ^SHELLEXECUTEINFOW; | |
| SHELLEXECUTEINFO :: SHELLEXECUTEINFOA; | |
| LPSHELLEXECUTEINFO :: LPSHELLEXECUTEINFOA; | |
| SHCREATEPROCESSINFOW :: struct { | |
| cbSize : DWORD, | |
| fMask : ULONG, | |
| hwnd : HWND, | |
| pszFile : LPCWSTR, | |
| pszParameters : LPCWSTR, | |
| pszCurrentDirectory : LPCWSTR, | |
| hUserToken : HANDLE, | |
| lpProcessAttributes : LPSECURITY_ATTRIBUTES, | |
| lpThreadAttributes : LPSECURITY_ATTRIBUTES, | |
| bInheritHandles : BOOL, | |
| dwCreationFlags : DWORD, | |
| lpStartupInfo : LPSTARTUPINFOW, | |
| lpProcessInformation : LPPROCESS_INFORMATION, | |
| }; | |
| PSHCREATEPROCESSINFOW :: ^SHCREATEPROCESSINFOW; | |
| /* ASSOCCLASS :: enum { */ | |
| ASSOCCLASS :: _c.int; | |
| ASSOCCLASS_SHELL_KEY :: 0; | |
| ASSOCCLASS_PROGID_KEY :: ASSOCCLASS_SHELL_KEY + 1; | |
| ASSOCCLASS_PROGID_STR :: ASSOCCLASS_PROGID_KEY + 1; | |
| ASSOCCLASS_CLSID_KEY :: ASSOCCLASS_PROGID_STR + 1; | |
| ASSOCCLASS_CLSID_STR :: ASSOCCLASS_CLSID_KEY + 1; | |
| ASSOCCLASS_APP_KEY :: ASSOCCLASS_CLSID_STR + 1; | |
| ASSOCCLASS_APP_STR :: ASSOCCLASS_APP_KEY + 1; | |
| ASSOCCLASS_SYSTEM_STR :: ASSOCCLASS_APP_STR + 1; | |
| ASSOCCLASS_FOLDER :: ASSOCCLASS_SYSTEM_STR + 1; | |
| ASSOCCLASS_STAR :: ASSOCCLASS_FOLDER + 1; | |
| ASSOCCLASS_FIXED_PROGID_STR :: ASSOCCLASS_STAR + 1; | |
| ASSOCCLASS_PROTOCOL_STR :: ASSOCCLASS_FIXED_PROGID_STR + 1; | |
| /* } */ | |
| ; | |
| ASSOCIATIONELEMENT :: struct { | |
| ac : ASSOCCLASS, | |
| hkClass : HKEY, | |
| pszClass : PCWSTR, | |
| }; | |
| SHQUERYRBINFO :: struct { | |
| cbSize : DWORD, | |
| i64Size : i64, | |
| i64NumItems : i64, | |
| }; | |
| LPSHQUERYRBINFO :: ^SHQUERYRBINFO; | |
| /* QUERY_USER_NOTIFICATION_STATE :: enum { */ | |
| QUERY_USER_NOTIFICATION_STATE :: _c.int; | |
| QUNS_NOT_PRESENT :: 1; | |
| QUNS_BUSY :: 2; | |
| QUNS_RUNNING_D3D_FULL_SCREEN :: 3; | |
| QUNS_PRESENTATION_MODE :: 4; | |
| QUNS_ACCEPTS_NOTIFICATIONS :: 5; | |
| QUNS_QUIET_TIME :: 6; | |
| QUNS_APP :: 7; | |
| /* } */ | |
| ; | |
| NOTIFYICONDATAA :: struct { | |
| cbSize : DWORD, | |
| hWnd : HWND, | |
| uID : UINT, | |
| uFlags : UINT, | |
| uCallbackMessage : UINT, | |
| hIcon : HICON, | |
| szTip : [128]CHAR, | |
| dwState : DWORD, | |
| dwStateMask : DWORD, | |
| szInfo : [256]CHAR, | |
| u : struct #raw_union { | |
| uTimeout : UINT, | |
| uVersion : UINT, | |
| }, | |
| szInfoTitle : [64]CHAR, | |
| dwInfoFlags : DWORD, | |
| guidItem : GUID, | |
| hBalloonIcon : HICON, | |
| }; | |
| PNOTIFYICONDATAA :: ^NOTIFYICONDATAA; | |
| NOTIFYICONDATAW :: struct { | |
| cbSize : DWORD, | |
| hWnd : HWND, | |
| uID : UINT, | |
| uFlags : UINT, | |
| uCallbackMessage : UINT, | |
| hIcon : HICON, | |
| szTip : [128]WCHAR, | |
| dwState : DWORD, | |
| dwStateMask : DWORD, | |
| szInfo : [256]WCHAR, | |
| u : struct #raw_union { | |
| uTimeout : UINT, | |
| uVersion : UINT, | |
| }, | |
| szInfoTitle : [64]WCHAR, | |
| dwInfoFlags : DWORD, | |
| guidItem : GUID, | |
| hBalloonIcon : HICON, | |
| }; | |
| PNOTIFYICONDATAW :: ^NOTIFYICONDATAW; | |
| NOTIFYICONDATA :: NOTIFYICONDATAA; | |
| PNOTIFYICONDATA :: PNOTIFYICONDATAA; | |
| NOTIFYICONIDENTIFIER :: struct { | |
| cbSize : DWORD, | |
| hWnd : HWND, | |
| uID : UINT, | |
| guidItem : GUID, | |
| }; | |
| PNOTIFYICONIDENTIFIER :: ^NOTIFYICONIDENTIFIER; | |
| SHFILEINFOA :: struct { | |
| hIcon : HICON, | |
| iIcon : _c.int, | |
| dwAttributes : DWORD, | |
| szDisplayName : [260]CHAR, | |
| szTypeName : [80]CHAR, | |
| }; | |
| SHFILEINFOW :: struct { | |
| hIcon : HICON, | |
| iIcon : _c.int, | |
| dwAttributes : DWORD, | |
| szDisplayName : [260]WCHAR, | |
| szTypeName : [80]WCHAR, | |
| }; | |
| SHFILEINFO :: SHFILEINFOA; | |
| SHSTOCKICONINFO :: struct { | |
| cbSize : DWORD, | |
| hIcon : HICON, | |
| iSysImageIndex : _c.int, | |
| iIcon : _c.int, | |
| szPath : [260]WCHAR, | |
| }; | |
| /* SHSTOCKICONID :: enum { */ | |
| SHSTOCKICONID :: _c.int; | |
| SIID_DOCNOASSOC :: 0; | |
| SIID_DOCASSOC :: 1; | |
| SIID_APPLICATION :: 2; | |
| SIID_FOLDER :: 3; | |
| SIID_FOLDEROPEN :: 4; | |
| SIID_DRIVE525 :: 5; | |
| SIID_DRIVE35 :: 6; | |
| SIID_DRIVEREMOVE :: 7; | |
| SIID_DRIVEFIXED :: 8; | |
| SIID_DRIVENET :: 9; | |
| SIID_DRIVENETDISABLED :: 10; | |
| SIID_DRIVECD :: 11; | |
| SIID_DRIVERAM :: 12; | |
| SIID_WORLD :: 13; | |
| SIID_SERVER :: 15; | |
| SIID_PRINTER :: 16; | |
| SIID_MYNETWORK :: 17; | |
| SIID_FIND :: 22; | |
| SIID_HELP :: 23; | |
| SIID_SHARE :: 28; | |
| SIID_LINK :: 29; | |
| SIID_SLOWFILE :: 30; | |
| SIID_RECYCLER :: 31; | |
| SIID_RECYCLERFULL :: 32; | |
| SIID_MEDIACDAUDIO :: 40; | |
| SIID_LOCK :: 47; | |
| SIID_AUTOLIST :: 49; | |
| SIID_PRINTERNET :: 50; | |
| SIID_SERVERSHARE :: 51; | |
| SIID_PRINTERFAX :: 52; | |
| SIID_PRINTERFAXNET :: 53; | |
| SIID_PRINTERFILE :: 54; | |
| SIID_STACK :: 55; | |
| SIID_MEDIASVCD :: 56; | |
| SIID_STUFFEDFOLDER :: 57; | |
| SIID_DRIVEUNKNOWN :: 58; | |
| SIID_DRIVEDVD :: 59; | |
| SIID_MEDIADVD :: 60; | |
| SIID_MEDIADVDRAM :: 61; | |
| SIID_MEDIADVDRW :: 62; | |
| SIID_MEDIADVDR :: 63; | |
| SIID_MEDIADVDROM :: 64; | |
| SIID_MEDIACDAUDIOPLUS :: 65; | |
| SIID_MEDIACDRW :: 66; | |
| SIID_MEDIACDR :: 67; | |
| SIID_MEDIACDBURN :: 68; | |
| SIID_MEDIABLANKCD :: 69; | |
| SIID_MEDIACDROM :: 70; | |
| SIID_AUDIOFILES :: 71; | |
| SIID_IMAGEFILES :: 72; | |
| SIID_VIDEOFILES :: 73; | |
| SIID_MIXEDFILES :: 74; | |
| SIID_FOLDERBACK :: 75; | |
| SIID_FOLDERFRONT :: 76; | |
| SIID_SHIELD :: 77; | |
| SIID_WARNING :: 78; | |
| SIID_INFO :: 79; | |
| SIID_ERROR :: 80; | |
| SIID_KEY :: 81; | |
| SIID_SOFTWARE :: 82; | |
| SIID_RENAME :: 83; | |
| SIID_DELETE :: 84; | |
| SIID_MEDIAAUDIODVD :: 85; | |
| SIID_MEDIAMOVIEDVD :: 86; | |
| SIID_MEDIAENHANCEDCD :: 87; | |
| SIID_MEDIAENHANCEDDVD :: 88; | |
| SIID_MEDIAHDDVD :: 89; | |
| SIID_MEDIABLURAY :: 90; | |
| SIID_MEDIAVCD :: 91; | |
| SIID_MEDIADVDPLUSR :: 92; | |
| SIID_MEDIADVDPLUSRW :: 93; | |
| SIID_DESKTOPPC :: 94; | |
| SIID_MOBILEPC :: 95; | |
| SIID_USERS :: 96; | |
| SIID_MEDIASMARTMEDIA :: 97; | |
| SIID_MEDIACOMPACTFLASH :: 98; | |
| SIID_DEVICECELLPHONE :: 99; | |
| SIID_DEVICECAMERA :: 100; | |
| SIID_DEVICEVIDEOCAMERA :: 101; | |
| SIID_DEVICEAUDIOPLAYER :: 102; | |
| SIID_NETWORKCONNECT :: 103; | |
| SIID_INTERNET :: 104; | |
| SIID_ZIPFILE :: 105; | |
| SIID_SETTINGS :: 106; | |
| SIID_DRIVEHDDVD :: 132; | |
| SIID_DRIVEBD :: 133; | |
| SIID_MEDIAHDDVDROM :: 134; | |
| SIID_MEDIAHDDVDR :: 135; | |
| SIID_MEDIAHDDVDRAM :: 136; | |
| SIID_MEDIABDROM :: 137; | |
| SIID_MEDIABDR :: 138; | |
| SIID_MEDIABDRE :: 139; | |
| SIID_CLUSTEREDDRIVE :: 140; | |
| SIID_MAX_ICONS :: 181; | |
| /* } */ | |
| ; | |
| OPEN_PRINTER_PROPS_INFOA :: struct { | |
| dwSize : DWORD, | |
| pszSheetName : LPSTR, | |
| uSheetIndex : UINT, | |
| dwFlags : DWORD, | |
| bModal : BOOL, | |
| }; | |
| POPEN_PRINTER_PROPS_INFOA :: ^OPEN_PRINTER_PROPS_INFOA; | |
| OPEN_PRINTER_PROPS_INFOW :: struct { | |
| dwSize : DWORD, | |
| pszSheetName : LPWSTR, | |
| uSheetIndex : UINT, | |
| dwFlags : DWORD, | |
| bModal : BOOL, | |
| }; | |
| POPEN_PRINTER_PROPS_INFOW :: ^OPEN_PRINTER_PROPS_INFOW; | |
| OPEN_PRINTER_PROPS_INFO :: OPEN_PRINTER_PROPS_INFOA; | |
| POPEN_PRINTER_PROPS_INFO :: POPEN_PRINTER_PROPS_INFOA; | |
| PFNCANSHAREFOLDERW :: (proc "stdcall" (pszPath : PCWSTR) -> HRESULT); | |
| PFNSHOWSHAREFOLDERUIW :: (proc "stdcall" (hwndParent : HWND, pszPath : PCWSTR) -> HRESULT); | |
| NC_ADDRESS :: struct { | |
| pAddrInfo : ^NET_ADDRESS_INFO_, | |
| PortNumber : USHORT, | |
| PrefixLength : BYTE, | |
| }; | |
| PNC_ADDRESS :: ^NC_ADDRESS; | |
| PERF_DATA_BLOCK :: struct { | |
| Signature : [4]WCHAR, | |
| LittleEndian : DWORD, | |
| Version : DWORD, | |
| Revision : DWORD, | |
| TotalByteLength : DWORD, | |
| HeaderLength : DWORD, | |
| NumObjectTypes : DWORD, | |
| DefaultObject : LONG, | |
| SystemTime : SYSTEMTIME, | |
| PerfTime : LARGE_INTEGER, | |
| PerfFreq : LARGE_INTEGER, | |
| PerfTime100nSec : LARGE_INTEGER, | |
| SystemNameLength : DWORD, | |
| SystemNameOffset : DWORD, | |
| }; | |
| PPERF_DATA_BLOCK :: ^PERF_DATA_BLOCK; | |
| PERF_OBJECT_TYPE :: struct { | |
| TotalByteLength : DWORD, | |
| DefinitionLength : DWORD, | |
| HeaderLength : DWORD, | |
| ObjectNameTitleIndex : DWORD, | |
| ObjectNameTitle : DWORD, | |
| ObjectHelpTitleIndex : DWORD, | |
| ObjectHelpTitle : DWORD, | |
| DetailLevel : DWORD, | |
| NumCounters : DWORD, | |
| DefaultCounter : LONG, | |
| NumInstances : LONG, | |
| CodePage : DWORD, | |
| PerfTime : LARGE_INTEGER, | |
| PerfFreq : LARGE_INTEGER, | |
| }; | |
| PPERF_OBJECT_TYPE :: ^PERF_OBJECT_TYPE; | |
| PERF_COUNTER_DEFINITION :: struct { | |
| ByteLength : DWORD, | |
| CounterNameTitleIndex : DWORD, | |
| CounterNameTitle : DWORD, | |
| CounterHelpTitleIndex : DWORD, | |
| CounterHelpTitle : DWORD, | |
| DefaultScale : LONG, | |
| DetailLevel : DWORD, | |
| CounterType : DWORD, | |
| CounterSize : DWORD, | |
| CounterOffset : DWORD, | |
| }; | |
| PPERF_COUNTER_DEFINITION :: ^PERF_COUNTER_DEFINITION; | |
| PERF_INSTANCE_DEFINITION :: struct { | |
| ByteLength : DWORD, | |
| ParentObjectTitleIndex : DWORD, | |
| ParentObjectInstance : DWORD, | |
| UniqueID : LONG, | |
| NameOffset : DWORD, | |
| NameLength : DWORD, | |
| }; | |
| PPERF_INSTANCE_DEFINITION :: ^PERF_INSTANCE_DEFINITION; | |
| PERF_COUNTER_BLOCK :: struct { | |
| ByteLength : DWORD, | |
| }; | |
| PPERF_COUNTER_BLOCK :: ^PERF_COUNTER_BLOCK; | |
| PM_OPEN_PROC :: #type (proc "stdcall" (LPWSTR) -> DWORD); | |
| PM_COLLECT_PROC :: #type (proc "stdcall" (lpValueName : LPWSTR, lppData : ^LPVOID, lpcbTotalBytes : LPDWORD, lpNumObjectTypes : LPDWORD) -> DWORD); | |
| PM_CLOSE_PROC :: #type (proc "stdcall" () -> DWORD); | |
| PM_QUERY_PROC :: #type (proc "stdcall" (LPDWORD, ^LPVOID, LPDWORD, LPDWORD) -> DWORD); | |
| u_char :: _c.uchar; | |
| u_short :: _c.ushort; | |
| u_int :: _c.uint; | |
| u_long :: _c.ulong; | |
| SOCKET :: UINT_PTR; | |
| fd_set :: struct { | |
| fd_count : u_int, | |
| fd_array : [64]SOCKET, | |
| }; | |
| TIMEVAL :: struct { | |
| tv_sec : _c.long, | |
| tv_usec : _c.long, | |
| }; | |
| HOSTENT :: struct { | |
| h_name : ^_c.uchar, | |
| h_aliases : ^^_c.uchar, | |
| h_addrtype : _c.short, | |
| h_length : _c.short, | |
| h_addr_list : ^^_c.uchar, | |
| }; | |
| netent :: struct { | |
| n_name : ^_c.uchar, | |
| n_aliases : ^^_c.uchar, | |
| n_addrtype : _c.short, | |
| n_net : u_long, | |
| }; | |
| SERVENT :: struct { | |
| s_name : ^_c.uchar, | |
| s_aliases : ^^_c.uchar, | |
| s_proto : ^_c.uchar, | |
| s_port : _c.short, | |
| }; | |
| PROTOENT :: struct { | |
| p_name : ^_c.uchar, | |
| p_aliases : ^^_c.uchar, | |
| p_proto : _c.short, | |
| }; | |
| IN_ADDR :: struct { | |
| S_un : struct #raw_union { | |
| S_un_b : struct { | |
| s_b1 : UCHAR, | |
| s_b2 : UCHAR, | |
| s_b3 : UCHAR, | |
| s_b4 : UCHAR, | |
| }, | |
| S_un_w : struct { | |
| s_w1 : USHORT, | |
| s_w2 : USHORT, | |
| }, | |
| S_addr : ULONG, | |
| }, | |
| }; | |
| PIN_ADDR :: ^IN_ADDR; | |
| LPIN_ADDR :: ^IN_ADDR; | |
| SOCKADDR_IN :: struct { | |
| sin_family : _c.short, | |
| sin_port : u_short, | |
| sin_addr : IN_ADDR, | |
| sin_zero : [8]_c.uchar, | |
| }; | |
| WSADATA :: struct { | |
| wVersion : WORD, | |
| wHighVersion : WORD, | |
| iMaxSockets : _c.ushort, | |
| iMaxUdpDg : _c.ushort, | |
| lpVendorInfo : ^_c.uchar, | |
| szDescription : [256 + 1]_c.uchar, | |
| szSystemStatus : [128 + 1]_c.uchar, | |
| }; | |
| LPWSADATA :: ^WSADATA; | |
| ip_mreq :: struct { | |
| imr_multiaddr : IN_ADDR, | |
| imr_interface : IN_ADDR, | |
| }; | |
| SOCKADDR :: struct { | |
| sa_family : u_short, | |
| sa_data : [14]_c.uchar, | |
| }; | |
| sockproto :: struct { | |
| sp_family : u_short, | |
| sp_protocol : u_short, | |
| }; | |
| LINGER :: struct { | |
| l_onoff : u_short, | |
| l_linger : u_short, | |
| }; | |
| TRANSMIT_FILE_BUFFERS :: struct { | |
| Head : PVOID, | |
| HeadLength : DWORD, | |
| Tail : PVOID, | |
| TailLength : DWORD, | |
| }; | |
| PTRANSMIT_FILE_BUFFERS :: ^TRANSMIT_FILE_BUFFERS; | |
| LPTRANSMIT_FILE_BUFFERS :: ^TRANSMIT_FILE_BUFFERS; | |
| ; | |
| PSOCKADDR :: ^SOCKADDR; | |
| LPSOCKADDR :: ^SOCKADDR; | |
| ; | |
| PSOCKADDR_IN :: ^SOCKADDR_IN; | |
| LPSOCKADDR_IN :: ^SOCKADDR_IN; | |
| ; | |
| PLINGER :: ^LINGER; | |
| LPLINGER :: ^LINGER; | |
| FD_SET :: fd_set; | |
| PFD_SET :: ^fd_set; | |
| LPFD_SET :: ^fd_set; | |
| ; | |
| PHOSTENT :: ^HOSTENT; | |
| LPHOSTENT :: ^HOSTENT; | |
| ; | |
| PSERVENT :: ^SERVENT; | |
| LPSERVENT :: ^SERVENT; | |
| ; | |
| PPROTOENT :: ^PROTOENT; | |
| LPPROTOENT :: ^PROTOENT; | |
| ; | |
| PTIMEVAL :: ^TIMEVAL; | |
| LPTIMEVAL :: ^TIMEVAL; | |
| ALG_ID :: _c.uint; | |
| HCRYPTPROV :: ULONG_PTR; | |
| HCRYPTKEY :: ULONG_PTR; | |
| HCRYPTHASH :: ULONG_PTR; | |
| CMS_KEY_INFO :: struct { | |
| dwVersion : DWORD, | |
| Algid : ALG_ID, | |
| pbOID : ^BYTE, | |
| cbOID : DWORD, | |
| }; | |
| PCMS_KEY_INFO :: ^CMS_KEY_INFO; | |
| HMAC_INFO :: struct { | |
| HashAlgid : ALG_ID, | |
| pbInnerString : ^BYTE, | |
| cbInnerString : DWORD, | |
| pbOuterString : ^BYTE, | |
| cbOuterString : DWORD, | |
| }; | |
| PHMAC_INFO :: ^HMAC_INFO; | |
| SCHANNEL_ALG :: struct { | |
| dwUse : DWORD, | |
| Algid : ALG_ID, | |
| cBits : DWORD, | |
| dwFlags : DWORD, | |
| dwReserved : DWORD, | |
| }; | |
| PSCHANNEL_ALG :: ^SCHANNEL_ALG; | |
| PROV_ENUMALGS :: struct { | |
| aiAlgid : ALG_ID, | |
| dwBitLen : DWORD, | |
| dwNameLen : DWORD, | |
| szName : [20]CHAR, | |
| }; | |
| PROV_ENUMALGS_EX :: struct { | |
| aiAlgid : ALG_ID, | |
| dwDefaultLen : DWORD, | |
| dwMinLen : DWORD, | |
| dwMaxLen : DWORD, | |
| dwProtocols : DWORD, | |
| dwNameLen : DWORD, | |
| szName : [20]CHAR, | |
| dwLongNameLen : DWORD, | |
| szLongName : [40]CHAR, | |
| }; | |
| BLOBHEADER :: struct { | |
| bType : BYTE, | |
| bVersion : BYTE, | |
| reserved : WORD, | |
| aiKeyAlg : ALG_ID, | |
| }; | |
| PUBLICKEYSTRUC :: struct { | |
| bType : BYTE, | |
| bVersion : BYTE, | |
| reserved : WORD, | |
| aiKeyAlg : ALG_ID, | |
| }; | |
| RSAPUBKEY :: struct { | |
| magic : DWORD, | |
| bitlen : DWORD, | |
| pubexp : DWORD, | |
| }; | |
| DHPUBKEY :: struct { | |
| magic : DWORD, | |
| bitlen : DWORD, | |
| }; | |
| DSSPUBKEY :: struct { | |
| magic : DWORD, | |
| bitlen : DWORD, | |
| }; | |
| KEAPUBKEY :: struct { | |
| magic : DWORD, | |
| bitlen : DWORD, | |
| }; | |
| TEKPUBKEY :: struct { | |
| magic : DWORD, | |
| bitlen : DWORD, | |
| }; | |
| DSSSEED :: struct { | |
| counter : DWORD, | |
| seed : [20]BYTE, | |
| }; | |
| DHPUBKEY_VER3 :: struct { | |
| magic : DWORD, | |
| bitlenP : DWORD, | |
| bitlenQ : DWORD, | |
| bitlenJ : DWORD, | |
| DSSSeed : DSSSEED, | |
| }; | |
| DSSPUBKEY_VER3 :: struct { | |
| magic : DWORD, | |
| bitlenP : DWORD, | |
| bitlenQ : DWORD, | |
| bitlenJ : DWORD, | |
| DSSSeed : DSSSEED, | |
| }; | |
| DHPRIVKEY_VER3 :: struct { | |
| magic : DWORD, | |
| bitlenP : DWORD, | |
| bitlenQ : DWORD, | |
| bitlenJ : DWORD, | |
| bitlenX : DWORD, | |
| DSSSeed : DSSSEED, | |
| }; | |
| DSSPRIVKEY_VER3 :: struct { | |
| magic : DWORD, | |
| bitlenP : DWORD, | |
| bitlenQ : DWORD, | |
| bitlenJ : DWORD, | |
| bitlenX : DWORD, | |
| DSSSeed : DSSSEED, | |
| }; | |
| KEY_TYPE_SUBTYPE :: struct { | |
| dwKeySpec : DWORD, | |
| Type : GUID, | |
| Subtype : GUID, | |
| }; | |
| PKEY_TYPE_SUBTYPE :: ^KEY_TYPE_SUBTYPE; | |
| CERT_FORTEZZA_DATA_PROP :: struct { | |
| SerialNumber : [8]_c.uchar, | |
| CertIndex : _c.int, | |
| CertLabel : [36]_c.uchar, | |
| }; | |
| CRYPT_RC4_KEY_STATE :: struct { | |
| Key : [16]_c.uchar, | |
| SBox : [256]_c.uchar, | |
| i : _c.uchar, | |
| j : _c.uchar, | |
| }; | |
| PCRYPT_RC4_KEY_STATE :: ^CRYPT_RC4_KEY_STATE; | |
| CRYPT_DES_KEY_STATE :: struct { | |
| Key : [8]_c.uchar, | |
| IV : [8]_c.uchar, | |
| Feedback : [8]_c.uchar, | |
| }; | |
| PCRYPT_DES_KEY_STATE :: ^CRYPT_DES_KEY_STATE; | |
| CRYPT_3DES_KEY_STATE :: struct { | |
| Key : [24]_c.uchar, | |
| IV : [8]_c.uchar, | |
| Feedback : [8]_c.uchar, | |
| }; | |
| PCRYPT_3DES_KEY_STATE :: ^CRYPT_3DES_KEY_STATE; | |
| CRYPT_AES_128_KEY_STATE :: struct { | |
| Key : [16]_c.uchar, | |
| IV : [16]_c.uchar, | |
| EncryptionState : [11][16]_c.uchar, | |
| DecryptionState : [11][16]_c.uchar, | |
| Feedback : [16]_c.uchar, | |
| }; | |
| PCRYPT_AES_128_KEY_STATE :: ^CRYPT_AES_128_KEY_STATE; | |
| CRYPT_AES_256_KEY_STATE :: struct { | |
| Key : [32]_c.uchar, | |
| IV : [16]_c.uchar, | |
| EncryptionState : [15][16]_c.uchar, | |
| DecryptionState : [15][16]_c.uchar, | |
| Feedback : [16]_c.uchar, | |
| }; | |
| PCRYPT_AES_256_KEY_STATE :: ^CRYPT_AES_256_KEY_STATE; | |
| CRYPT_INTEGER_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCRYPT_INTEGER_BLOB :: ^CRYPT_INTEGER_BLOB; | |
| CRYPT_UINT_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCRYPT_UINT_BLOB :: ^CRYPT_UINT_BLOB; | |
| CRYPT_OBJID_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCRYPT_OBJID_BLOB :: ^CRYPT_OBJID_BLOB; | |
| CERT_NAME_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCERT_NAME_BLOB :: ^CERT_NAME_BLOB; | |
| CERT_RDN_VALUE_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCERT_RDN_VALUE_BLOB :: ^CERT_RDN_VALUE_BLOB; | |
| CERT_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCERT_BLOB :: ^CERT_BLOB; | |
| CRL_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCRL_BLOB :: ^CRL_BLOB; | |
| DATA_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PDATA_BLOB :: ^DATA_BLOB; | |
| CRYPT_DATA_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCRYPT_DATA_BLOB :: ^CRYPT_DATA_BLOB; | |
| CRYPT_HASH_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCRYPT_HASH_BLOB :: ^CRYPT_HASH_BLOB; | |
| CRYPT_DIGEST_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCRYPT_DIGEST_BLOB :: ^CRYPT_DIGEST_BLOB; | |
| CRYPT_DER_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCRYPT_DER_BLOB :: ^CRYPT_DER_BLOB; | |
| CRYPT_ATTR_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| }; | |
| PCRYPT_ATTR_BLOB :: ^CRYPT_ATTR_BLOB; | |
| CMS_DH_KEY_INFO :: struct { | |
| dwVersion : DWORD, | |
| Algid : ALG_ID, | |
| pszContentEncObjId : LPSTR, | |
| PubInfo : CRYPT_DATA_BLOB, | |
| pReserved : rawptr, | |
| }; | |
| PCMS_DH_KEY_INFO :: ^CMS_DH_KEY_INFO; | |
| NTSTATUS :: LONG; | |
| PNTSTATUS :: ^NTSTATUS; | |
| BCRYPT_KEY_LENGTHS_STRUCT :: struct { | |
| dwMinLength : ULONG, | |
| dwMaxLength : ULONG, | |
| dwIncrement : ULONG, | |
| }; | |
| BCRYPT_AUTH_TAG_LENGTHS_STRUCT :: BCRYPT_KEY_LENGTHS_STRUCT; | |
| BCRYPT_OID :: struct { | |
| cbOID : ULONG, | |
| pbOID : PUCHAR, | |
| }; | |
| BCRYPT_OID_LIST :: struct { | |
| dwOIDCount : ULONG, | |
| pOIDs : ^BCRYPT_OID, | |
| }; | |
| BCRYPT_PKCS1_PADDING_INFO :: struct { | |
| pszAlgId : LPCWSTR, | |
| }; | |
| BCRYPT_PSS_PADDING_INFO :: struct { | |
| pszAlgId : LPCWSTR, | |
| cbSalt : ULONG, | |
| }; | |
| BCRYPT_OAEP_PADDING_INFO :: struct { | |
| pszAlgId : LPCWSTR, | |
| pbLabel : PUCHAR, | |
| cbLabel : ULONG, | |
| }; | |
| BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO :: struct { | |
| cbSize : ULONG, | |
| dwInfoVersion : ULONG, | |
| pbNonce : PUCHAR, | |
| cbNonce : ULONG, | |
| pbAuthData : PUCHAR, | |
| cbAuthData : ULONG, | |
| pbTag : PUCHAR, | |
| cbTag : ULONG, | |
| pbMacContext : PUCHAR, | |
| cbMacContext : ULONG, | |
| cbAAD : ULONG, | |
| cbData : ULONGLONG, | |
| dwFlags : ULONG, | |
| }; | |
| PBCRYPT_AUTHENTICATED_CIPHER_MODE_INFO :: ^BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO; | |
| BCryptBuffer :: struct { | |
| cbBuffer : ULONG, | |
| BufferType : ULONG, | |
| pvBuffer : PVOID, | |
| }; | |
| PBCryptBuffer :: ^BCryptBuffer; | |
| BCryptBufferDesc :: struct { | |
| ulVersion : ULONG, | |
| cBuffers : ULONG, | |
| pBuffers : PBCryptBuffer, | |
| }; | |
| PBCryptBufferDesc :: ^BCryptBufferDesc; | |
| BCRYPT_HANDLE :: PVOID; | |
| BCRYPT_ALG_HANDLE :: PVOID; | |
| BCRYPT_KEY_HANDLE :: PVOID; | |
| BCRYPT_HASH_HANDLE :: PVOID; | |
| BCRYPT_SECRET_HANDLE :: PVOID; | |
| BCRYPT_KEY_BLOB :: struct { | |
| Magic : ULONG, | |
| }; | |
| BCRYPT_RSAKEY_BLOB :: struct { | |
| Magic : ULONG, | |
| BitLength : ULONG, | |
| cbPublicExp : ULONG, | |
| cbModulus : ULONG, | |
| cbPrime1 : ULONG, | |
| cbPrime2 : ULONG, | |
| }; | |
| BCRYPT_ECCKEY_BLOB :: struct { | |
| dwMagic : ULONG, | |
| cbKey : ULONG, | |
| }; | |
| PBCRYPT_ECCKEY_BLOB :: ^BCRYPT_ECCKEY_BLOB; | |
| SSL_ECCKEY_BLOB :: struct { | |
| dwCurveType : ULONG, | |
| cbKey : ULONG, | |
| }; | |
| PSSL_ECCKEY_BLOB :: ^SSL_ECCKEY_BLOB; | |
| /* ECC_CURVE_TYPE_ENUM :: enum { */ | |
| ECC_CURVE_TYPE_ENUM :: _c.int; | |
| BCRYPT_ECC_PRIME_SHORT_WEIERSTRASS_CURVE :: 0x1; | |
| BCRYPT_ECC_PRIME_TWISTED_EDWARDS_CURVE :: 0x2; | |
| BCRYPT_ECC_PRIME_MONTGOMERY_CURVE :: 0x3; | |
| /* } */ | |
| ; | |
| /* ECC_CURVE_ALG_ID_ENUM :: enum { */ | |
| ECC_CURVE_ALG_ID_ENUM :: _c.int; | |
| BCRYPT_NO_CURVE_GENERATION_ALG_ID :: 0x0; | |
| /* } */ | |
| ; | |
| BCRYPT_ECCFULLKEY_BLOB :: struct { | |
| dwMagic : ULONG, | |
| dwVersion : ULONG, | |
| dwCurveType : ECC_CURVE_TYPE_ENUM, | |
| dwCurveGenerationAlgId : ECC_CURVE_ALG_ID_ENUM, | |
| cbFieldLength : ULONG, | |
| cbSubgroupOrder : ULONG, | |
| cbCofactor : ULONG, | |
| cbSeed : ULONG, | |
| }; | |
| PBCRYPT_ECCFULLKEY_BLOB :: ^BCRYPT_ECCFULLKEY_BLOB; | |
| BCRYPT_DH_KEY_BLOB :: struct { | |
| dwMagic : ULONG, | |
| cbKey : ULONG, | |
| }; | |
| PBCRYPT_DH_KEY_BLOB :: ^BCRYPT_DH_KEY_BLOB; | |
| BCRYPT_DH_PARAMETER_HEADER :: struct { | |
| cbLength : ULONG, | |
| dwMagic : ULONG, | |
| cbKeyLength : ULONG, | |
| }; | |
| BCRYPT_DSA_KEY_BLOB :: struct { | |
| dwMagic : ULONG, | |
| cbKey : ULONG, | |
| Count : [4]UCHAR, | |
| Seed : [20]UCHAR, | |
| q : [20]UCHAR, | |
| }; | |
| PBCRYPT_DSA_KEY_BLOB :: ^BCRYPT_DSA_KEY_BLOB; | |
| /* HASHALGORITHM_ENUM :: enum { */ | |
| HASHALGORITHM_ENUM :: _c.int; | |
| DSA_HASH_ALGORITHM_SHA1 :: 0; | |
| DSA_HASH_ALGORITHM_SHA256 :: DSA_HASH_ALGORITHM_SHA1 + 1; | |
| DSA_HASH_ALGORITHM_SHA512 :: DSA_HASH_ALGORITHM_SHA256 + 1; | |
| /* } */ | |
| ; | |
| /* DSAFIPSVERSION_ENUM :: enum { */ | |
| DSAFIPSVERSION_ENUM :: _c.int; | |
| DSA_FIPS186_2 :: 0; | |
| DSA_FIPS186_3 :: DSA_FIPS186_2 + 1; | |
| /* } */ | |
| ; | |
| BCRYPT_DSA_KEY_BLOB_V2 :: struct { | |
| dwMagic : ULONG, | |
| cbKey : ULONG, | |
| hashAlgorithm : HASHALGORITHM_ENUM, | |
| standardVersion : DSAFIPSVERSION_ENUM, | |
| cbSeedLength : ULONG, | |
| cbGroupSize : ULONG, | |
| Count : [4]UCHAR, | |
| }; | |
| PBCRYPT_DSA_KEY_BLOB_V2 :: ^BCRYPT_DSA_KEY_BLOB_V2; | |
| BCRYPT_KEY_DATA_BLOB_HEADER :: struct { | |
| dwMagic : ULONG, | |
| dwVersion : ULONG, | |
| cbKeyData : ULONG, | |
| }; | |
| PBCRYPT_KEY_DATA_BLOB_HEADER :: ^BCRYPT_KEY_DATA_BLOB_HEADER; | |
| BCRYPT_DSA_PARAMETER_HEADER :: struct { | |
| cbLength : ULONG, | |
| dwMagic : ULONG, | |
| cbKeyLength : ULONG, | |
| Count : [4]UCHAR, | |
| Seed : [20]UCHAR, | |
| q : [20]UCHAR, | |
| }; | |
| BCRYPT_DSA_PARAMETER_HEADER_V2 :: struct { | |
| cbLength : ULONG, | |
| dwMagic : ULONG, | |
| cbKeyLength : ULONG, | |
| hashAlgorithm : HASHALGORITHM_ENUM, | |
| standardVersion : DSAFIPSVERSION_ENUM, | |
| cbSeedLength : ULONG, | |
| cbGroupSize : ULONG, | |
| Count : [4]UCHAR, | |
| }; | |
| BCRYPT_ECC_CURVE_NAMES :: struct { | |
| dwEccCurveNames : ULONG, | |
| pEccCurveNames : ^LPWSTR, | |
| }; | |
| /* BCRYPT_HASH_OPERATION_TYPE :: enum { */ | |
| BCRYPT_HASH_OPERATION_TYPE :: _c.int; | |
| BCRYPT_HASH_OPERATION_HASH_DATA :: 1; | |
| BCRYPT_HASH_OPERATION_FINISH_HASH :: 2; | |
| /* } */ | |
| ; | |
| BCRYPT_MULTI_HASH_OPERATION :: struct { | |
| iHash : ULONG, | |
| hashOperation : BCRYPT_HASH_OPERATION_TYPE, | |
| pbBuffer : PUCHAR, | |
| cbBuffer : ULONG, | |
| }; | |
| /* BCRYPT_MULTI_OPERATION_TYPE :: enum { */ | |
| BCRYPT_MULTI_OPERATION_TYPE :: _c.int; | |
| BCRYPT_OPERATION_TYPE_HASH :: 1; | |
| /* } */ | |
| ; | |
| BCRYPT_MULTI_OBJECT_LENGTH_STRUCT :: struct { | |
| cbPerObject : ULONG, | |
| cbPerElement : ULONG, | |
| }; | |
| BCRYPT_ALGORITHM_IDENTIFIER :: struct { | |
| pszName : LPWSTR, | |
| dwClass : ULONG, | |
| dwFlags : ULONG, | |
| }; | |
| BCRYPT_PROVIDER_NAME :: struct { | |
| pszProviderName : LPWSTR, | |
| }; | |
| BCRYPT_INTERFACE_VERSION :: struct { | |
| MajorVersion : USHORT, | |
| MinorVersion : USHORT, | |
| }; | |
| PBCRYPT_INTERFACE_VERSION :: ^BCRYPT_INTERFACE_VERSION; | |
| CRYPT_INTERFACE_REG :: struct { | |
| dwInterface : ULONG, | |
| dwFlags : ULONG, | |
| cFunctions : ULONG, | |
| rgpszFunctions : ^PWSTR, | |
| }; | |
| PCRYPT_INTERFACE_REG :: ^CRYPT_INTERFACE_REG; | |
| CRYPT_IMAGE_REG :: struct { | |
| pszImage : PWSTR, | |
| cInterfaces : ULONG, | |
| rgpInterfaces : ^PCRYPT_INTERFACE_REG, | |
| }; | |
| PCRYPT_IMAGE_REG :: ^CRYPT_IMAGE_REG; | |
| CRYPT_PROVIDER_REG :: struct { | |
| cAliases : ULONG, | |
| rgpszAliases : ^PWSTR, | |
| pUM : PCRYPT_IMAGE_REG, | |
| pKM : PCRYPT_IMAGE_REG, | |
| }; | |
| PCRYPT_PROVIDER_REG :: ^CRYPT_PROVIDER_REG; | |
| CRYPT_PROVIDERS :: struct { | |
| cProviders : ULONG, | |
| rgpszProviders : ^PWSTR, | |
| }; | |
| PCRYPT_PROVIDERS :: ^CRYPT_PROVIDERS; | |
| CRYPT_CONTEXT_CONFIG :: struct { | |
| dwFlags : ULONG, | |
| dwReserved : ULONG, | |
| }; | |
| PCRYPT_CONTEXT_CONFIG :: ^CRYPT_CONTEXT_CONFIG; | |
| CRYPT_CONTEXT_FUNCTION_CONFIG :: struct { | |
| dwFlags : ULONG, | |
| dwReserved : ULONG, | |
| }; | |
| PCRYPT_CONTEXT_FUNCTION_CONFIG :: ^CRYPT_CONTEXT_FUNCTION_CONFIG; | |
| CRYPT_CONTEXTS :: struct { | |
| cContexts : ULONG, | |
| rgpszContexts : ^PWSTR, | |
| }; | |
| PCRYPT_CONTEXTS :: ^CRYPT_CONTEXTS; | |
| CRYPT_CONTEXT_FUNCTIONS :: struct { | |
| cFunctions : ULONG, | |
| rgpszFunctions : ^PWSTR, | |
| }; | |
| PCRYPT_CONTEXT_FUNCTIONS :: ^CRYPT_CONTEXT_FUNCTIONS; | |
| CRYPT_CONTEXT_FUNCTION_PROVIDERS :: struct { | |
| cProviders : ULONG, | |
| rgpszProviders : ^PWSTR, | |
| }; | |
| PCRYPT_CONTEXT_FUNCTION_PROVIDERS :: ^CRYPT_CONTEXT_FUNCTION_PROVIDERS; | |
| CRYPT_PROPERTY_REF :: struct { | |
| pszProperty : PWSTR, | |
| cbValue : ULONG, | |
| pbValue : PUCHAR, | |
| }; | |
| PCRYPT_PROPERTY_REF :: ^CRYPT_PROPERTY_REF; | |
| CRYPT_IMAGE_REF :: struct { | |
| pszImage : PWSTR, | |
| dwFlags : ULONG, | |
| }; | |
| PCRYPT_IMAGE_REF :: ^CRYPT_IMAGE_REF; | |
| CRYPT_PROVIDER_REF :: struct { | |
| dwInterface : ULONG, | |
| pszFunction : PWSTR, | |
| pszProvider : PWSTR, | |
| cProperties : ULONG, | |
| rgpProperties : ^PCRYPT_PROPERTY_REF, | |
| pUM : PCRYPT_IMAGE_REF, | |
| pKM : PCRYPT_IMAGE_REF, | |
| }; | |
| PCRYPT_PROVIDER_REF :: ^CRYPT_PROVIDER_REF; | |
| CRYPT_PROVIDER_REFS :: struct { | |
| cProviders : ULONG, | |
| rgpProviders : ^PCRYPT_PROVIDER_REF, | |
| }; | |
| PCRYPT_PROVIDER_REFS :: ^CRYPT_PROVIDER_REFS; | |
| SECURITY_STATUS :: LONG; | |
| PFN_NCRYPT_ALLOC :: (proc "stdcall" (cbSize : SIZE_T) -> LPVOID); | |
| PFN_NCRYPT_FREE :: proc "stdcall" (pv : LPVOID); | |
| NCRYPT_ALLOC_PARA :: struct { | |
| cbSize : DWORD, | |
| pfnAlloc : PFN_NCRYPT_ALLOC, | |
| pfnFree : PFN_NCRYPT_FREE, | |
| }; | |
| NCryptBuffer :: BCryptBuffer; | |
| PNCryptBuffer :: ^BCryptBuffer; | |
| NCryptBufferDesc :: BCryptBufferDesc; | |
| PNCryptBufferDesc :: ^BCryptBufferDesc; | |
| NCRYPT_HANDLE :: ULONG_PTR; | |
| NCRYPT_PROV_HANDLE :: ULONG_PTR; | |
| NCRYPT_KEY_HANDLE :: ULONG_PTR; | |
| NCRYPT_HASH_HANDLE :: ULONG_PTR; | |
| NCRYPT_SECRET_HANDLE :: ULONG_PTR; | |
| NCRYPT_CIPHER_PADDING_INFO :: struct { | |
| cbSize : ULONG, | |
| dwFlags : DWORD, | |
| pbIV : PUCHAR, | |
| cbIV : ULONG, | |
| pbOtherInfo : PUCHAR, | |
| cbOtherInfo : ULONG, | |
| }; | |
| PNCRYPT_CIPHER_PADDING_INFO :: ^NCRYPT_CIPHER_PADDING_INFO; | |
| NCRYPT_PLATFORM_ATTEST_PADDING_INFO :: struct { | |
| magic : ULONG, | |
| pcrMask : ULONG, | |
| }; | |
| NCRYPT_KEY_ATTEST_PADDING_INFO :: struct { | |
| magic : ULONG, | |
| pbKeyBlob : PUCHAR, | |
| cbKeyBlob : ULONG, | |
| pbKeyAuth : PUCHAR, | |
| cbKeyAuth : ULONG, | |
| }; | |
| NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES :: struct { | |
| Version : ULONG, | |
| Flags : ULONG, | |
| cbPublicKeyBlob : ULONG, | |
| }; | |
| PNCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES :: ^NCRYPT_ISOLATED_KEY_ATTESTED_ATTRIBUTES; | |
| NCRYPT_VSM_KEY_ATTESTATION_STATEMENT :: struct { | |
| Magic : ULONG, | |
| Version : ULONG, | |
| cbSignature : ULONG, | |
| cbReport : ULONG, | |
| cbAttributes : ULONG, | |
| }; | |
| PNCRYPT_VSM_KEY_ATTESTATION_STATEMENT :: ^NCRYPT_VSM_KEY_ATTESTATION_STATEMENT; | |
| NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS :: struct { | |
| Version : ULONG, | |
| TrustletId : ULONGLONG, | |
| MinSvn : ULONG, | |
| FlagsMask : ULONG, | |
| FlagsExpected : ULONG, | |
| using _ : bit_field { | |
| AllowDebugging : 1, | |
| Reserved : 31, | |
| }, | |
| }; | |
| PNCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS :: ^NCRYPT_VSM_KEY_ATTESTATION_CLAIM_RESTRICTIONS; | |
| NCRYPT_EXPORTED_ISOLATED_KEY_HEADER :: struct { | |
| Version : ULONG, | |
| KeyUsage : ULONG, | |
| using _ : bit_field { | |
| PerBootKey : 1, | |
| Reserved : 31, | |
| }, | |
| cbAlgName : ULONG, | |
| cbNonce : ULONG, | |
| cbAuthTag : ULONG, | |
| cbWrappingKey : ULONG, | |
| cbIsolatedKey : ULONG, | |
| }; | |
| PNCRYPT_EXPORTED_ISOLATED_KEY_HEADER :: ^NCRYPT_EXPORTED_ISOLATED_KEY_HEADER; | |
| NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE :: struct { | |
| Header : NCRYPT_EXPORTED_ISOLATED_KEY_HEADER, | |
| }; | |
| PNCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE :: ^NCRYPT_EXPORTED_ISOLATED_KEY_ENVELOPE; | |
| NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT :: struct { | |
| Magic : UINT32, | |
| Version : UINT32, | |
| HeaderSize : UINT32, | |
| cbCertifyInfo : UINT32, | |
| cbSignature : UINT32, | |
| cbTpmPublic : UINT32, | |
| }; | |
| PNCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT :: ^NCRYPT_PCP_TPM_WEB_AUTHN_ATTESTATION_STATEMENT; | |
| NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT :: struct { | |
| Magic : ULONG, | |
| Version : ULONG, | |
| pcrAlg : ULONG, | |
| cbSignature : ULONG, | |
| cbQuote : ULONG, | |
| cbPcrs : ULONG, | |
| }; | |
| PNCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT :: ^NCRYPT_TPM_PLATFORM_ATTESTATION_STATEMENT; | |
| NCryptAlgorithmName :: struct { | |
| pszName : LPWSTR, | |
| dwClass : DWORD, | |
| dwAlgOperations : DWORD, | |
| dwFlags : DWORD, | |
| }; | |
| NCryptKeyName :: struct { | |
| pszName : LPWSTR, | |
| pszAlgid : LPWSTR, | |
| dwLegacyKeySpec : DWORD, | |
| dwFlags : DWORD, | |
| }; | |
| NCryptProviderName :: struct { | |
| pszName : LPWSTR, | |
| pszComment : LPWSTR, | |
| }; | |
| NCRYPT_UI_POLICY :: struct { | |
| dwVersion : DWORD, | |
| dwFlags : DWORD, | |
| pszCreationTitle : LPCWSTR, | |
| pszFriendlyName : LPCWSTR, | |
| pszDescription : LPCWSTR, | |
| }; | |
| NCRYPT_KEY_ACCESS_POLICY_BLOB :: struct { | |
| dwVersion : DWORD, | |
| dwPolicyFlags : DWORD, | |
| cbUserSid : DWORD, | |
| cbApplicationSid : DWORD, | |
| }; | |
| NCRYPT_SUPPORTED_LENGTHS :: struct { | |
| dwMinLength : DWORD, | |
| dwMaxLength : DWORD, | |
| dwIncrement : DWORD, | |
| dwDefaultLength : DWORD, | |
| }; | |
| NCRYPT_PCP_HMAC_AUTH_SIGNATURE_INFO :: struct { | |
| dwVersion : DWORD, | |
| iExpiration : INT32, | |
| pabNonce : [32]BYTE, | |
| pabPolicyRef : [32]BYTE, | |
| pabHMAC : [32]BYTE, | |
| }; | |
| NCRYPT_PCP_TPM_FW_VERSION_INFO :: struct { | |
| major1 : UINT16, | |
| major2 : UINT16, | |
| minor1 : UINT16, | |
| minor2 : UINT16, | |
| }; | |
| NCRYPT_PCP_RAW_POLICYDIGEST_INFO :: struct { | |
| dwVersion : DWORD, | |
| cbDigest : DWORD, | |
| }; | |
| NCRYPT_KEY_BLOB_HEADER :: struct { | |
| cbSize : ULONG, | |
| dwMagic : ULONG, | |
| cbAlgName : ULONG, | |
| cbKeyData : ULONG, | |
| }; | |
| PNCRYPT_KEY_BLOB_HEADER :: ^NCRYPT_KEY_BLOB_HEADER; | |
| NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER :: struct { | |
| magic : DWORD, | |
| cbHeader : DWORD, | |
| cbPublic : DWORD, | |
| cbPrivate : DWORD, | |
| cbName : DWORD, | |
| }; | |
| PNCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER :: ^NCRYPT_TPM_LOADABLE_KEY_BLOB_HEADER; | |
| HCRYPTPROV_OR_NCRYPT_KEY_HANDLE :: ULONG_PTR; | |
| HCRYPTPROV_LEGACY :: ULONG_PTR; | |
| CRYPT_BIT_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : ^BYTE, | |
| cUnusedBits : DWORD, | |
| }; | |
| PCRYPT_BIT_BLOB :: ^CRYPT_BIT_BLOB; | |
| CRYPT_ALGORITHM_IDENTIFIER :: struct { | |
| pszObjId : LPSTR, | |
| Parameters : CRYPT_OBJID_BLOB, | |
| }; | |
| PCRYPT_ALGORITHM_IDENTIFIER :: ^CRYPT_ALGORITHM_IDENTIFIER; | |
| CRYPT_OBJID_TABLE :: struct { | |
| dwAlgId : DWORD, | |
| pszObjId : LPCSTR, | |
| }; | |
| PCRYPT_OBJID_TABLE :: ^CRYPT_OBJID_TABLE; | |
| CRYPT_HASH_INFO :: struct { | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| Hash : CRYPT_HASH_BLOB, | |
| }; | |
| PCRYPT_HASH_INFO :: ^CRYPT_HASH_INFO; | |
| CERT_EXTENSION :: struct { | |
| pszObjId : LPSTR, | |
| fCritical : BOOL, | |
| Value : CRYPT_OBJID_BLOB, | |
| }; | |
| PCERT_EXTENSION :: ^CERT_EXTENSION; | |
| PCCERT_EXTENSION :: ^CERT_EXTENSION; | |
| CRYPT_ATTRIBUTE_TYPE_VALUE :: struct { | |
| pszObjId : LPSTR, | |
| Value : CRYPT_OBJID_BLOB, | |
| }; | |
| PCRYPT_ATTRIBUTE_TYPE_VALUE :: ^CRYPT_ATTRIBUTE_TYPE_VALUE; | |
| CRYPT_ATTRIBUTE :: struct { | |
| pszObjId : LPSTR, | |
| cValue : DWORD, | |
| rgValue : PCRYPT_ATTR_BLOB, | |
| }; | |
| PCRYPT_ATTRIBUTE :: ^CRYPT_ATTRIBUTE; | |
| CRYPT_ATTRIBUTES :: struct { | |
| cAttr : DWORD, | |
| rgAttr : PCRYPT_ATTRIBUTE, | |
| }; | |
| PCRYPT_ATTRIBUTES :: ^CRYPT_ATTRIBUTES; | |
| CERT_RDN_ATTR :: struct { | |
| pszObjId : LPSTR, | |
| dwValueType : DWORD, | |
| Value : CERT_RDN_VALUE_BLOB, | |
| }; | |
| PCERT_RDN_ATTR :: ^CERT_RDN_ATTR; | |
| CERT_RDN :: struct { | |
| cRDNAttr : DWORD, | |
| rgRDNAttr : PCERT_RDN_ATTR, | |
| }; | |
| PCERT_RDN :: ^CERT_RDN; | |
| CERT_NAME_INFO :: struct { | |
| cRDN : DWORD, | |
| rgRDN : PCERT_RDN, | |
| }; | |
| PCERT_NAME_INFO :: ^CERT_NAME_INFO; | |
| CERT_NAME_VALUE :: struct { | |
| dwValueType : DWORD, | |
| Value : CERT_RDN_VALUE_BLOB, | |
| }; | |
| PCERT_NAME_VALUE :: ^CERT_NAME_VALUE; | |
| CERT_PUBLIC_KEY_INFO :: struct { | |
| Algorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| PublicKey : CRYPT_BIT_BLOB, | |
| }; | |
| PCERT_PUBLIC_KEY_INFO :: ^CERT_PUBLIC_KEY_INFO; | |
| CRYPT_ECC_PRIVATE_KEY_INFO :: struct { | |
| dwVersion : DWORD, | |
| PrivateKey : CRYPT_DER_BLOB, | |
| szCurveOid : LPSTR, | |
| PublicKey : CRYPT_BIT_BLOB, | |
| }; | |
| PCRYPT_ECC_PRIVATE_KEY_INFO :: ^CRYPT_ECC_PRIVATE_KEY_INFO; | |
| CRYPT_PRIVATE_KEY_INFO :: struct { | |
| Version : DWORD, | |
| Algorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| PrivateKey : CRYPT_DER_BLOB, | |
| pAttributes : PCRYPT_ATTRIBUTES, | |
| }; | |
| PCRYPT_PRIVATE_KEY_INFO :: ^CRYPT_PRIVATE_KEY_INFO; | |
| CRYPT_ENCRYPTED_PRIVATE_KEY_INFO :: struct { | |
| EncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| EncryptedPrivateKey : CRYPT_DATA_BLOB, | |
| }; | |
| PCRYPT_ENCRYPTED_PRIVATE_KEY_INFO :: ^CRYPT_ENCRYPTED_PRIVATE_KEY_INFO; | |
| PCRYPT_DECRYPT_PRIVATE_KEY_FUNC :: (proc "stdcall" (Algorithm : CRYPT_ALGORITHM_IDENTIFIER, EncryptedPrivateKey : CRYPT_DATA_BLOB, pbClearTextKey : ^BYTE, pcbClearTextKey : ^DWORD, pVoidDecryptFunc : LPVOID) -> BOOL); | |
| PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC :: (proc "stdcall" (pAlgorithm : ^CRYPT_ALGORITHM_IDENTIFIER, pClearTextPrivateKey : ^CRYPT_DATA_BLOB, pbEncryptedKey : ^BYTE, pcbEncryptedKey : ^DWORD, pVoidEncryptFunc : LPVOID) -> BOOL); | |
| PCRYPT_RESOLVE_HCRYPTPROV_FUNC :: (proc "stdcall" (pPrivateKeyInfo : ^CRYPT_PRIVATE_KEY_INFO, phCryptProv : ^HCRYPTPROV, pVoidResolveFunc : LPVOID) -> BOOL); | |
| CRYPT_PKCS8_IMPORT_PARAMS :: struct { | |
| PrivateKey : CRYPT_DIGEST_BLOB, | |
| pResolvehCryptProvFunc : PCRYPT_RESOLVE_HCRYPTPROV_FUNC, | |
| pVoidResolveFunc : LPVOID, | |
| pDecryptPrivateKeyFunc : PCRYPT_DECRYPT_PRIVATE_KEY_FUNC, | |
| pVoidDecryptFunc : LPVOID, | |
| }; | |
| PCRYPT_PKCS8_IMPORT_PARAMS :: ^CRYPT_PKCS8_IMPORT_PARAMS; | |
| CRYPT_PRIVATE_KEY_BLOB_AND_PARAMS :: struct { | |
| PrivateKey : CRYPT_DIGEST_BLOB, | |
| pResolvehCryptProvFunc : PCRYPT_RESOLVE_HCRYPTPROV_FUNC, | |
| pVoidResolveFunc : LPVOID, | |
| pDecryptPrivateKeyFunc : PCRYPT_DECRYPT_PRIVATE_KEY_FUNC, | |
| pVoidDecryptFunc : LPVOID, | |
| }; | |
| PCRYPT_PRIVATE_KEY_BLOB_AND_PARAMS :: ^CRYPT_PRIVATE_KEY_BLOB_AND_PARAMS; | |
| CRYPT_PKCS8_EXPORT_PARAMS :: struct { | |
| hCryptProv : HCRYPTPROV, | |
| dwKeySpec : DWORD, | |
| pszPrivateKeyObjId : LPSTR, | |
| pEncryptPrivateKeyFunc : PCRYPT_ENCRYPT_PRIVATE_KEY_FUNC, | |
| pVoidEncryptFunc : LPVOID, | |
| }; | |
| PCRYPT_PKCS8_EXPORT_PARAMS :: ^CRYPT_PKCS8_EXPORT_PARAMS; | |
| CERT_INFO :: struct { | |
| 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, | |
| }; | |
| PCERT_INFO :: ^CERT_INFO; | |
| CRL_ENTRY :: struct { | |
| SerialNumber : CRYPT_INTEGER_BLOB, | |
| RevocationDate : FILETIME, | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| PCRL_ENTRY :: ^CRL_ENTRY; | |
| CRL_INFO :: struct { | |
| dwVersion : DWORD, | |
| SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| Issuer : CERT_NAME_BLOB, | |
| ThisUpdate : FILETIME, | |
| NextUpdate : FILETIME, | |
| cCRLEntry : DWORD, | |
| rgCRLEntry : PCRL_ENTRY, | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| PCRL_INFO :: ^CRL_INFO; | |
| CERT_OR_CRL_BLOB :: struct { | |
| dwChoice : DWORD, | |
| cbEncoded : DWORD, | |
| pbEncoded : ^BYTE, | |
| }; | |
| PCERT_OR_CRL_BLOB :: ^CERT_OR_CRL_BLOB; | |
| CERT_OR_CRL_BUNDLE :: struct { | |
| cItem : DWORD, | |
| rgItem : PCERT_OR_CRL_BLOB, | |
| }; | |
| PCERT_OR_CRL_BUNDLE :: ^CERT_OR_CRL_BUNDLE; | |
| CERT_REQUEST_INFO :: struct { | |
| dwVersion : DWORD, | |
| Subject : CERT_NAME_BLOB, | |
| SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO, | |
| cAttribute : DWORD, | |
| rgAttribute : PCRYPT_ATTRIBUTE, | |
| }; | |
| PCERT_REQUEST_INFO :: ^CERT_REQUEST_INFO; | |
| CERT_KEYGEN_REQUEST_INFO :: struct { | |
| dwVersion : DWORD, | |
| SubjectPublicKeyInfo : CERT_PUBLIC_KEY_INFO, | |
| pwszChallengeString : LPWSTR, | |
| }; | |
| PCERT_KEYGEN_REQUEST_INFO :: ^CERT_KEYGEN_REQUEST_INFO; | |
| CERT_SIGNED_CONTENT_INFO :: struct { | |
| ToBeSigned : CRYPT_DER_BLOB, | |
| SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| Signature : CRYPT_BIT_BLOB, | |
| }; | |
| PCERT_SIGNED_CONTENT_INFO :: ^CERT_SIGNED_CONTENT_INFO; | |
| CTL_USAGE :: struct { | |
| cUsageIdentifier : DWORD, | |
| rgpszUsageIdentifier : ^LPSTR, | |
| }; | |
| PCTL_USAGE :: ^CTL_USAGE; | |
| CERT_ENHKEY_USAGE :: struct { | |
| cUsageIdentifier : DWORD, | |
| rgpszUsageIdentifier : ^LPSTR, | |
| }; | |
| PCERT_ENHKEY_USAGE :: ^CERT_ENHKEY_USAGE; | |
| PCCTL_USAGE :: ^CTL_USAGE; | |
| PCCERT_ENHKEY_USAGE :: ^CERT_ENHKEY_USAGE; | |
| CTL_ENTRY :: struct { | |
| SubjectIdentifier : CRYPT_DATA_BLOB, | |
| cAttribute : DWORD, | |
| rgAttribute : PCRYPT_ATTRIBUTE, | |
| }; | |
| PCTL_ENTRY :: ^CTL_ENTRY; | |
| CTL_INFO :: struct { | |
| 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, | |
| }; | |
| PCTL_INFO :: ^CTL_INFO; | |
| CRYPT_TIME_STAMP_REQUEST_INFO :: struct { | |
| pszTimeStampAlgorithm : LPSTR, | |
| pszContentType : LPSTR, | |
| Content : CRYPT_OBJID_BLOB, | |
| cAttribute : DWORD, | |
| rgAttribute : PCRYPT_ATTRIBUTE, | |
| }; | |
| PCRYPT_TIME_STAMP_REQUEST_INFO :: ^CRYPT_TIME_STAMP_REQUEST_INFO; | |
| CRYPT_ENROLLMENT_NAME_VALUE_PAIR :: struct { | |
| pwszName : LPWSTR, | |
| pwszValue : LPWSTR, | |
| }; | |
| PCRYPT_ENROLLMENT_NAME_VALUE_PAIR :: ^CRYPT_ENROLLMENT_NAME_VALUE_PAIR; | |
| CRYPT_CSP_PROVIDER :: struct { | |
| dwKeySpec : DWORD, | |
| pwszProviderName : LPWSTR, | |
| Signature : CRYPT_BIT_BLOB, | |
| }; | |
| PCRYPT_CSP_PROVIDER :: ^CRYPT_CSP_PROVIDER; | |
| PFN_CRYPT_ALLOC :: (proc "stdcall" (cbSize : _c.size_t) -> LPVOID); | |
| PFN_CRYPT_FREE :: proc "stdcall" (pv : LPVOID); | |
| CRYPT_ENCODE_PARA :: struct { | |
| cbSize : DWORD, | |
| pfnAlloc : PFN_CRYPT_ALLOC, | |
| pfnFree : PFN_CRYPT_FREE, | |
| }; | |
| PCRYPT_ENCODE_PARA :: ^CRYPT_ENCODE_PARA; | |
| CRYPT_DECODE_PARA :: struct { | |
| cbSize : DWORD, | |
| pfnAlloc : PFN_CRYPT_ALLOC, | |
| pfnFree : PFN_CRYPT_FREE, | |
| }; | |
| PCRYPT_DECODE_PARA :: ^CRYPT_DECODE_PARA; | |
| CERT_EXTENSIONS :: struct { | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| PCERT_EXTENSIONS :: ^CERT_EXTENSIONS; | |
| CERT_AUTHORITY_KEY_ID_INFO :: struct { | |
| KeyId : CRYPT_DATA_BLOB, | |
| CertIssuer : CERT_NAME_BLOB, | |
| CertSerialNumber : CRYPT_INTEGER_BLOB, | |
| }; | |
| PCERT_AUTHORITY_KEY_ID_INFO :: ^CERT_AUTHORITY_KEY_ID_INFO; | |
| CERT_PRIVATE_KEY_VALIDITY :: struct { | |
| NotBefore : FILETIME, | |
| NotAfter : FILETIME, | |
| }; | |
| PCERT_PRIVATE_KEY_VALIDITY :: ^CERT_PRIVATE_KEY_VALIDITY; | |
| CERT_KEY_ATTRIBUTES_INFO :: struct { | |
| KeyId : CRYPT_DATA_BLOB, | |
| IntendedKeyUsage : CRYPT_BIT_BLOB, | |
| pPrivateKeyUsagePeriod : PCERT_PRIVATE_KEY_VALIDITY, | |
| }; | |
| PCERT_KEY_ATTRIBUTES_INFO :: ^CERT_KEY_ATTRIBUTES_INFO; | |
| CERT_POLICY_ID :: struct { | |
| cCertPolicyElementId : DWORD, | |
| rgpszCertPolicyElementId : ^LPSTR, | |
| }; | |
| PCERT_POLICY_ID :: ^CERT_POLICY_ID; | |
| CERT_KEY_USAGE_RESTRICTION_INFO :: struct { | |
| cCertPolicyId : DWORD, | |
| rgCertPolicyId : PCERT_POLICY_ID, | |
| RestrictedKeyUsage : CRYPT_BIT_BLOB, | |
| }; | |
| PCERT_KEY_USAGE_RESTRICTION_INFO :: ^CERT_KEY_USAGE_RESTRICTION_INFO; | |
| CERT_OTHER_NAME :: struct { | |
| pszObjId : LPSTR, | |
| Value : CRYPT_OBJID_BLOB, | |
| }; | |
| PCERT_OTHER_NAME :: ^CERT_OTHER_NAME; | |
| CERT_ALT_NAME_ENTRY :: struct { | |
| dwAltNameChoice : DWORD, | |
| u : struct #raw_union { | |
| pOtherName : PCERT_OTHER_NAME, | |
| pwszRfc822Name : LPWSTR, | |
| pwszDNSName : LPWSTR, | |
| DirectoryName : CERT_NAME_BLOB, | |
| pwszURL : LPWSTR, | |
| IPAddress : CRYPT_DATA_BLOB, | |
| pszRegisteredID : LPSTR, | |
| }, | |
| }; | |
| PCERT_ALT_NAME_ENTRY :: ^CERT_ALT_NAME_ENTRY; | |
| CERT_ALT_NAME_INFO :: struct { | |
| cAltEntry : DWORD, | |
| rgAltEntry : PCERT_ALT_NAME_ENTRY, | |
| }; | |
| PCERT_ALT_NAME_INFO :: ^CERT_ALT_NAME_INFO; | |
| CERT_BASIC_CONSTRAINTS_INFO :: struct { | |
| SubjectType : CRYPT_BIT_BLOB, | |
| fPathLenConstraint : BOOL, | |
| dwPathLenConstraint : DWORD, | |
| cSubtreesConstraint : DWORD, | |
| rgSubtreesConstraint : ^CERT_NAME_BLOB, | |
| }; | |
| PCERT_BASIC_CONSTRAINTS_INFO :: ^CERT_BASIC_CONSTRAINTS_INFO; | |
| CERT_BASIC_CONSTRAINTS2_INFO :: struct { | |
| fCA : BOOL, | |
| fPathLenConstraint : BOOL, | |
| dwPathLenConstraint : DWORD, | |
| }; | |
| PCERT_BASIC_CONSTRAINTS2_INFO :: ^CERT_BASIC_CONSTRAINTS2_INFO; | |
| CERT_POLICY_QUALIFIER_INFO :: struct { | |
| pszPolicyQualifierId : LPSTR, | |
| Qualifier : CRYPT_OBJID_BLOB, | |
| }; | |
| PCERT_POLICY_QUALIFIER_INFO :: ^CERT_POLICY_QUALIFIER_INFO; | |
| CERT_POLICY_INFO :: struct { | |
| pszPolicyIdentifier : LPSTR, | |
| cPolicyQualifier : DWORD, | |
| rgPolicyQualifier : ^CERT_POLICY_QUALIFIER_INFO, | |
| }; | |
| PCERT_POLICY_INFO :: ^CERT_POLICY_INFO; | |
| CERT_POLICIES_INFO :: struct { | |
| cPolicyInfo : DWORD, | |
| rgPolicyInfo : ^CERT_POLICY_INFO, | |
| }; | |
| PCERT_POLICIES_INFO :: ^CERT_POLICIES_INFO; | |
| CERT_POLICY_QUALIFIER_NOTICE_REFERENCE :: struct { | |
| pszOrganization : LPSTR, | |
| cNoticeNumbers : DWORD, | |
| rgNoticeNumbers : ^_c.int, | |
| }; | |
| PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE :: ^CERT_POLICY_QUALIFIER_NOTICE_REFERENCE; | |
| CERT_POLICY_QUALIFIER_USER_NOTICE :: struct { | |
| pNoticeReference : ^CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, | |
| pszDisplayText : LPWSTR, | |
| }; | |
| PCERT_POLICY_QUALIFIER_USER_NOTICE :: ^CERT_POLICY_QUALIFIER_USER_NOTICE; | |
| CPS_URLS :: struct { | |
| pszURL : LPWSTR, | |
| pAlgorithm : ^CRYPT_ALGORITHM_IDENTIFIER, | |
| pDigest : ^CRYPT_DATA_BLOB, | |
| }; | |
| PCPS_URLS :: ^CPS_URLS; | |
| CERT_POLICY95_QUALIFIER1 :: struct { | |
| pszPracticesReference : LPWSTR, | |
| pszNoticeIdentifier : LPSTR, | |
| pszNSINoticeIdentifier : LPSTR, | |
| cCPSURLs : DWORD, | |
| rgCPSURLs : ^CPS_URLS, | |
| }; | |
| PCERT_POLICY95_QUALIFIER1 :: ^CERT_POLICY95_QUALIFIER1; | |
| CERT_POLICY_MAPPING :: struct { | |
| pszIssuerDomainPolicy : LPSTR, | |
| pszSubjectDomainPolicy : LPSTR, | |
| }; | |
| PCERT_POLICY_MAPPING :: ^CERT_POLICY_MAPPING; | |
| CERT_POLICY_MAPPINGS_INFO :: struct { | |
| cPolicyMapping : DWORD, | |
| rgPolicyMapping : PCERT_POLICY_MAPPING, | |
| }; | |
| PCERT_POLICY_MAPPINGS_INFO :: ^CERT_POLICY_MAPPINGS_INFO; | |
| CERT_POLICY_CONSTRAINTS_INFO :: struct { | |
| fRequireExplicitPolicy : BOOL, | |
| dwRequireExplicitPolicySkipCerts : DWORD, | |
| fInhibitPolicyMapping : BOOL, | |
| dwInhibitPolicyMappingSkipCerts : DWORD, | |
| }; | |
| PCERT_POLICY_CONSTRAINTS_INFO :: ^CERT_POLICY_CONSTRAINTS_INFO; | |
| CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY :: struct { | |
| pszObjId : LPSTR, | |
| cValue : DWORD, | |
| rgValue : PCRYPT_DER_BLOB, | |
| }; | |
| PCRYPT_CONTENT_INFO_SEQUENCE_OF_ANY :: ^CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY; | |
| CRYPT_CONTENT_INFO :: struct { | |
| pszObjId : LPSTR, | |
| Content : CRYPT_DER_BLOB, | |
| }; | |
| PCRYPT_CONTENT_INFO :: ^CRYPT_CONTENT_INFO; | |
| CRYPT_SEQUENCE_OF_ANY :: struct { | |
| cValue : DWORD, | |
| rgValue : PCRYPT_DER_BLOB, | |
| }; | |
| PCRYPT_SEQUENCE_OF_ANY :: ^CRYPT_SEQUENCE_OF_ANY; | |
| CERT_AUTHORITY_KEY_ID2_INFO :: struct { | |
| KeyId : CRYPT_DATA_BLOB, | |
| AuthorityCertIssuer : CERT_ALT_NAME_INFO, | |
| AuthorityCertSerialNumber : CRYPT_INTEGER_BLOB, | |
| }; | |
| PCERT_AUTHORITY_KEY_ID2_INFO :: ^CERT_AUTHORITY_KEY_ID2_INFO; | |
| CERT_ACCESS_DESCRIPTION :: struct { | |
| pszAccessMethod : LPSTR, | |
| AccessLocation : CERT_ALT_NAME_ENTRY, | |
| }; | |
| PCERT_ACCESS_DESCRIPTION :: ^CERT_ACCESS_DESCRIPTION; | |
| CERT_AUTHORITY_INFO_ACCESS :: struct { | |
| cAccDescr : DWORD, | |
| rgAccDescr : PCERT_ACCESS_DESCRIPTION, | |
| }; | |
| PCERT_AUTHORITY_INFO_ACCESS :: ^CERT_AUTHORITY_INFO_ACCESS; | |
| CERT_SUBJECT_INFO_ACCESS :: struct { | |
| cAccDescr : DWORD, | |
| rgAccDescr : PCERT_ACCESS_DESCRIPTION, | |
| }; | |
| PCERT_SUBJECT_INFO_ACCESS :: ^CERT_SUBJECT_INFO_ACCESS; | |
| CRL_DIST_POINT_NAME :: struct { | |
| dwDistPointNameChoice : DWORD, | |
| u : struct #raw_union { | |
| FullName : CERT_ALT_NAME_INFO, | |
| }, | |
| }; | |
| PCRL_DIST_POINT_NAME :: ^CRL_DIST_POINT_NAME; | |
| CRL_DIST_POINT :: struct { | |
| DistPointName : CRL_DIST_POINT_NAME, | |
| ReasonFlags : CRYPT_BIT_BLOB, | |
| CRLIssuer : CERT_ALT_NAME_INFO, | |
| }; | |
| PCRL_DIST_POINT :: ^CRL_DIST_POINT; | |
| CRL_DIST_POINTS_INFO :: struct { | |
| cDistPoint : DWORD, | |
| rgDistPoint : PCRL_DIST_POINT, | |
| }; | |
| PCRL_DIST_POINTS_INFO :: ^CRL_DIST_POINTS_INFO; | |
| CROSS_CERT_DIST_POINTS_INFO :: struct { | |
| dwSyncDeltaTime : DWORD, | |
| cDistPoint : DWORD, | |
| rgDistPoint : PCERT_ALT_NAME_INFO, | |
| }; | |
| PCROSS_CERT_DIST_POINTS_INFO :: ^CROSS_CERT_DIST_POINTS_INFO; | |
| CERT_PAIR :: struct { | |
| Forward : CERT_BLOB, | |
| Reverse : CERT_BLOB, | |
| }; | |
| PCERT_PAIR :: ^CERT_PAIR; | |
| CRL_ISSUING_DIST_POINT :: struct { | |
| DistPointName : CRL_DIST_POINT_NAME, | |
| fOnlyContainsUserCerts : BOOL, | |
| fOnlyContainsCACerts : BOOL, | |
| OnlySomeReasonFlags : CRYPT_BIT_BLOB, | |
| fIndirectCRL : BOOL, | |
| }; | |
| PCRL_ISSUING_DIST_POINT :: ^CRL_ISSUING_DIST_POINT; | |
| CERT_GENERAL_SUBTREE :: struct { | |
| Base : CERT_ALT_NAME_ENTRY, | |
| dwMinimum : DWORD, | |
| fMaximum : BOOL, | |
| dwMaximum : DWORD, | |
| }; | |
| PCERT_GENERAL_SUBTREE :: ^CERT_GENERAL_SUBTREE; | |
| CERT_NAME_CONSTRAINTS_INFO :: struct { | |
| cPermittedSubtree : DWORD, | |
| rgPermittedSubtree : PCERT_GENERAL_SUBTREE, | |
| cExcludedSubtree : DWORD, | |
| rgExcludedSubtree : PCERT_GENERAL_SUBTREE, | |
| }; | |
| PCERT_NAME_CONSTRAINTS_INFO :: ^CERT_NAME_CONSTRAINTS_INFO; | |
| CERT_DSS_PARAMETERS :: struct { | |
| p : CRYPT_UINT_BLOB, | |
| q : CRYPT_UINT_BLOB, | |
| g : CRYPT_UINT_BLOB, | |
| }; | |
| PCERT_DSS_PARAMETERS :: ^CERT_DSS_PARAMETERS; | |
| CERT_DH_PARAMETERS :: struct { | |
| p : CRYPT_UINT_BLOB, | |
| g : CRYPT_UINT_BLOB, | |
| }; | |
| PCERT_DH_PARAMETERS :: ^CERT_DH_PARAMETERS; | |
| CERT_ECC_SIGNATURE :: struct { | |
| r : CRYPT_UINT_BLOB, | |
| s : CRYPT_UINT_BLOB, | |
| }; | |
| PCERT_ECC_SIGNATURE :: ^CERT_ECC_SIGNATURE; | |
| CERT_X942_DH_VALIDATION_PARAMS :: struct { | |
| seed : CRYPT_BIT_BLOB, | |
| pgenCounter : DWORD, | |
| }; | |
| PCERT_X942_DH_VALIDATION_PARAMS :: ^CERT_X942_DH_VALIDATION_PARAMS; | |
| CERT_X942_DH_PARAMETERS :: struct { | |
| p : CRYPT_UINT_BLOB, | |
| g : CRYPT_UINT_BLOB, | |
| q : CRYPT_UINT_BLOB, | |
| j : CRYPT_UINT_BLOB, | |
| pValidationParams : PCERT_X942_DH_VALIDATION_PARAMS, | |
| }; | |
| PCERT_X942_DH_PARAMETERS :: ^CERT_X942_DH_PARAMETERS; | |
| CRYPT_X942_OTHER_INFO :: struct { | |
| pszContentEncryptionObjId : LPSTR, | |
| rgbCounter : [4]BYTE, | |
| rgbKeyLength : [4]BYTE, | |
| PubInfo : CRYPT_DATA_BLOB, | |
| }; | |
| PCRYPT_X942_OTHER_INFO :: ^CRYPT_X942_OTHER_INFO; | |
| CRYPT_ECC_CMS_SHARED_INFO :: struct { | |
| Algorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| EntityUInfo : CRYPT_DATA_BLOB, | |
| rgbSuppPubInfo : [4]BYTE, | |
| }; | |
| PCRYPT_ECC_CMS_SHARED_INFO :: ^CRYPT_ECC_CMS_SHARED_INFO; | |
| CRYPT_RC2_CBC_PARAMETERS :: struct { | |
| dwVersion : DWORD, | |
| fIV : BOOL, | |
| rgbIV : [8]BYTE, | |
| }; | |
| PCRYPT_RC2_CBC_PARAMETERS :: ^CRYPT_RC2_CBC_PARAMETERS; | |
| CRYPT_SMIME_CAPABILITY :: struct { | |
| pszObjId : LPSTR, | |
| Parameters : CRYPT_OBJID_BLOB, | |
| }; | |
| PCRYPT_SMIME_CAPABILITY :: ^CRYPT_SMIME_CAPABILITY; | |
| CRYPT_SMIME_CAPABILITIES :: struct { | |
| cCapability : DWORD, | |
| rgCapability : PCRYPT_SMIME_CAPABILITY, | |
| }; | |
| PCRYPT_SMIME_CAPABILITIES :: ^CRYPT_SMIME_CAPABILITIES; | |
| CERT_QC_STATEMENT :: struct { | |
| pszStatementId : LPSTR, | |
| StatementInfo : CRYPT_OBJID_BLOB, | |
| }; | |
| PCERT_QC_STATEMENT :: ^CERT_QC_STATEMENT; | |
| CERT_QC_STATEMENTS_EXT_INFO :: struct { | |
| cStatement : DWORD, | |
| rgStatement : PCERT_QC_STATEMENT, | |
| }; | |
| PCERT_QC_STATEMENTS_EXT_INFO :: ^CERT_QC_STATEMENTS_EXT_INFO; | |
| CRYPT_MASK_GEN_ALGORITHM :: struct { | |
| pszObjId : LPSTR, | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| }; | |
| PCRYPT_MASK_GEN_ALGORITHM :: ^CRYPT_MASK_GEN_ALGORITHM; | |
| CRYPT_RSA_SSA_PSS_PARAMETERS :: struct { | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| MaskGenAlgorithm : CRYPT_MASK_GEN_ALGORITHM, | |
| dwSaltLength : DWORD, | |
| dwTrailerField : DWORD, | |
| }; | |
| PCRYPT_RSA_SSA_PSS_PARAMETERS :: ^CRYPT_RSA_SSA_PSS_PARAMETERS; | |
| CRYPT_PSOURCE_ALGORITHM :: struct { | |
| pszObjId : LPSTR, | |
| EncodingParameters : CRYPT_DATA_BLOB, | |
| }; | |
| PCRYPT_PSOURCE_ALGORITHM :: ^CRYPT_PSOURCE_ALGORITHM; | |
| CRYPT_RSAES_OAEP_PARAMETERS :: struct { | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| MaskGenAlgorithm : CRYPT_MASK_GEN_ALGORITHM, | |
| PSourceAlgorithm : CRYPT_PSOURCE_ALGORITHM, | |
| }; | |
| PCRYPT_RSAES_OAEP_PARAMETERS :: ^CRYPT_RSAES_OAEP_PARAMETERS; | |
| CMC_TAGGED_ATTRIBUTE :: struct { | |
| dwBodyPartID : DWORD, | |
| Attribute : CRYPT_ATTRIBUTE, | |
| }; | |
| PCMC_TAGGED_ATTRIBUTE :: ^CMC_TAGGED_ATTRIBUTE; | |
| CMC_TAGGED_CERT_REQUEST :: struct { | |
| dwBodyPartID : DWORD, | |
| SignedCertRequest : CRYPT_DER_BLOB, | |
| }; | |
| PCMC_TAGGED_CERT_REQUEST :: ^CMC_TAGGED_CERT_REQUEST; | |
| CMC_TAGGED_REQUEST :: struct { | |
| dwTaggedRequestChoice : DWORD, | |
| u : struct #raw_union { | |
| pTaggedCertRequest : PCMC_TAGGED_CERT_REQUEST, | |
| }, | |
| }; | |
| PCMC_TAGGED_REQUEST :: ^CMC_TAGGED_REQUEST; | |
| CMC_TAGGED_CONTENT_INFO :: struct { | |
| dwBodyPartID : DWORD, | |
| EncodedContentInfo : CRYPT_DER_BLOB, | |
| }; | |
| PCMC_TAGGED_CONTENT_INFO :: ^CMC_TAGGED_CONTENT_INFO; | |
| CMC_TAGGED_OTHER_MSG :: struct { | |
| dwBodyPartID : DWORD, | |
| pszObjId : LPSTR, | |
| Value : CRYPT_OBJID_BLOB, | |
| }; | |
| PCMC_TAGGED_OTHER_MSG :: ^CMC_TAGGED_OTHER_MSG; | |
| CMC_DATA_INFO :: struct { | |
| cTaggedAttribute : DWORD, | |
| rgTaggedAttribute : PCMC_TAGGED_ATTRIBUTE, | |
| cTaggedRequest : DWORD, | |
| rgTaggedRequest : PCMC_TAGGED_REQUEST, | |
| cTaggedContentInfo : DWORD, | |
| rgTaggedContentInfo : PCMC_TAGGED_CONTENT_INFO, | |
| cTaggedOtherMsg : DWORD, | |
| rgTaggedOtherMsg : PCMC_TAGGED_OTHER_MSG, | |
| }; | |
| PCMC_DATA_INFO :: ^CMC_DATA_INFO; | |
| CMC_RESPONSE_INFO :: struct { | |
| cTaggedAttribute : DWORD, | |
| rgTaggedAttribute : PCMC_TAGGED_ATTRIBUTE, | |
| cTaggedContentInfo : DWORD, | |
| rgTaggedContentInfo : PCMC_TAGGED_CONTENT_INFO, | |
| cTaggedOtherMsg : DWORD, | |
| rgTaggedOtherMsg : PCMC_TAGGED_OTHER_MSG, | |
| }; | |
| PCMC_RESPONSE_INFO :: ^CMC_RESPONSE_INFO; | |
| CMC_PEND_INFO :: struct { | |
| PendToken : CRYPT_DATA_BLOB, | |
| PendTime : FILETIME, | |
| }; | |
| PCMC_PEND_INFO :: ^CMC_PEND_INFO; | |
| CMC_STATUS_INFO :: struct { | |
| dwStatus : DWORD, | |
| cBodyList : DWORD, | |
| rgdwBodyList : ^DWORD, | |
| pwszStatusString : LPWSTR, | |
| dwOtherInfoChoice : DWORD, | |
| u : struct #raw_union { | |
| dwFailInfo : DWORD, | |
| pPendInfo : PCMC_PEND_INFO, | |
| }, | |
| }; | |
| PCMC_STATUS_INFO :: ^CMC_STATUS_INFO; | |
| CMC_ADD_EXTENSIONS_INFO :: struct { | |
| dwCmcDataReference : DWORD, | |
| cCertReference : DWORD, | |
| rgdwCertReference : ^DWORD, | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| PCMC_ADD_EXTENSIONS_INFO :: ^CMC_ADD_EXTENSIONS_INFO; | |
| CMC_ADD_ATTRIBUTES_INFO :: struct { | |
| dwCmcDataReference : DWORD, | |
| cCertReference : DWORD, | |
| rgdwCertReference : ^DWORD, | |
| cAttribute : DWORD, | |
| rgAttribute : PCRYPT_ATTRIBUTE, | |
| }; | |
| PCMC_ADD_ATTRIBUTES_INFO :: ^CMC_ADD_ATTRIBUTES_INFO; | |
| CERT_TEMPLATE_EXT :: struct { | |
| pszObjId : LPSTR, | |
| dwMajorVersion : DWORD, | |
| fMinorVersion : BOOL, | |
| dwMinorVersion : DWORD, | |
| }; | |
| PCERT_TEMPLATE_EXT :: ^CERT_TEMPLATE_EXT; | |
| CERT_HASHED_URL :: struct { | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| Hash : CRYPT_HASH_BLOB, | |
| pwszUrl : LPWSTR, | |
| }; | |
| PCERT_HASHED_URL :: ^CERT_HASHED_URL; | |
| CERT_LOGOTYPE_DETAILS :: struct { | |
| pwszMimeType : LPWSTR, | |
| cHashedUrl : DWORD, | |
| rgHashedUrl : PCERT_HASHED_URL, | |
| }; | |
| PCERT_LOGOTYPE_DETAILS :: ^CERT_LOGOTYPE_DETAILS; | |
| CERT_LOGOTYPE_REFERENCE :: struct { | |
| cHashedUrl : DWORD, | |
| rgHashedUrl : PCERT_HASHED_URL, | |
| }; | |
| PCERT_LOGOTYPE_REFERENCE :: ^CERT_LOGOTYPE_REFERENCE; | |
| CERT_LOGOTYPE_IMAGE_INFO :: struct { | |
| dwLogotypeImageInfoChoice : DWORD, | |
| dwFileSize : DWORD, | |
| dwXSize : DWORD, | |
| dwYSize : DWORD, | |
| dwLogotypeImageResolutionChoice : DWORD, | |
| u : struct #raw_union { | |
| dwNumBits : DWORD, | |
| dwTableSize : DWORD, | |
| }, | |
| pwszLanguage : LPWSTR, | |
| }; | |
| PCERT_LOGOTYPE_IMAGE_INFO :: ^CERT_LOGOTYPE_IMAGE_INFO; | |
| CERT_LOGOTYPE_IMAGE :: struct { | |
| LogotypeDetails : CERT_LOGOTYPE_DETAILS, | |
| pLogotypeImageInfo : PCERT_LOGOTYPE_IMAGE_INFO, | |
| }; | |
| PCERT_LOGOTYPE_IMAGE :: ^CERT_LOGOTYPE_IMAGE; | |
| CERT_LOGOTYPE_AUDIO_INFO :: struct { | |
| dwFileSize : DWORD, | |
| dwPlayTime : DWORD, | |
| dwChannels : DWORD, | |
| dwSampleRate : DWORD, | |
| pwszLanguage : LPWSTR, | |
| }; | |
| PCERT_LOGOTYPE_AUDIO_INFO :: ^CERT_LOGOTYPE_AUDIO_INFO; | |
| CERT_LOGOTYPE_AUDIO :: struct { | |
| LogotypeDetails : CERT_LOGOTYPE_DETAILS, | |
| pLogotypeAudioInfo : PCERT_LOGOTYPE_AUDIO_INFO, | |
| }; | |
| PCERT_LOGOTYPE_AUDIO :: ^CERT_LOGOTYPE_AUDIO; | |
| CERT_LOGOTYPE_DATA :: struct { | |
| cLogotypeImage : DWORD, | |
| rgLogotypeImage : PCERT_LOGOTYPE_IMAGE, | |
| cLogotypeAudio : DWORD, | |
| rgLogotypeAudio : PCERT_LOGOTYPE_AUDIO, | |
| }; | |
| PCERT_LOGOTYPE_DATA :: ^CERT_LOGOTYPE_DATA; | |
| CERT_LOGOTYPE_INFO :: struct { | |
| dwLogotypeInfoChoice : DWORD, | |
| u : struct #raw_union { | |
| pLogotypeDirectInfo : PCERT_LOGOTYPE_DATA, | |
| pLogotypeIndirectInfo : PCERT_LOGOTYPE_REFERENCE, | |
| }, | |
| }; | |
| PCERT_LOGOTYPE_INFO :: ^CERT_LOGOTYPE_INFO; | |
| CERT_OTHER_LOGOTYPE_INFO :: struct { | |
| pszObjId : LPSTR, | |
| LogotypeInfo : CERT_LOGOTYPE_INFO, | |
| }; | |
| PCERT_OTHER_LOGOTYPE_INFO :: ^CERT_OTHER_LOGOTYPE_INFO; | |
| CERT_LOGOTYPE_EXT_INFO :: struct { | |
| cCommunityLogo : DWORD, | |
| rgCommunityLogo : PCERT_LOGOTYPE_INFO, | |
| pIssuerLogo : PCERT_LOGOTYPE_INFO, | |
| pSubjectLogo : PCERT_LOGOTYPE_INFO, | |
| cOtherLogo : DWORD, | |
| rgOtherLogo : PCERT_OTHER_LOGOTYPE_INFO, | |
| }; | |
| PCERT_LOGOTYPE_EXT_INFO :: ^CERT_LOGOTYPE_EXT_INFO; | |
| CERT_BIOMETRIC_DATA :: struct { | |
| dwTypeOfBiometricDataChoice : DWORD, | |
| u : struct #raw_union { | |
| dwPredefined : DWORD, | |
| pszObjId : LPSTR, | |
| }, | |
| HashedUrl : CERT_HASHED_URL, | |
| }; | |
| PCERT_BIOMETRIC_DATA :: ^CERT_BIOMETRIC_DATA; | |
| CERT_BIOMETRIC_EXT_INFO :: struct { | |
| cBiometricData : DWORD, | |
| rgBiometricData : PCERT_BIOMETRIC_DATA, | |
| }; | |
| PCERT_BIOMETRIC_EXT_INFO :: ^CERT_BIOMETRIC_EXT_INFO; | |
| OCSP_SIGNATURE_INFO :: struct { | |
| SignatureAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| Signature : CRYPT_BIT_BLOB, | |
| cCertEncoded : DWORD, | |
| rgCertEncoded : PCERT_BLOB, | |
| }; | |
| POCSP_SIGNATURE_INFO :: ^OCSP_SIGNATURE_INFO; | |
| OCSP_SIGNED_REQUEST_INFO :: struct { | |
| ToBeSigned : CRYPT_DER_BLOB, | |
| pOptionalSignatureInfo : POCSP_SIGNATURE_INFO, | |
| }; | |
| POCSP_SIGNED_REQUEST_INFO :: ^OCSP_SIGNED_REQUEST_INFO; | |
| OCSP_CERT_ID :: struct { | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| IssuerNameHash : CRYPT_HASH_BLOB, | |
| IssuerKeyHash : CRYPT_HASH_BLOB, | |
| SerialNumber : CRYPT_INTEGER_BLOB, | |
| }; | |
| POCSP_CERT_ID :: ^OCSP_CERT_ID; | |
| OCSP_REQUEST_ENTRY :: struct { | |
| CertId : OCSP_CERT_ID, | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| POCSP_REQUEST_ENTRY :: ^OCSP_REQUEST_ENTRY; | |
| OCSP_REQUEST_INFO :: struct { | |
| dwVersion : DWORD, | |
| pRequestorName : PCERT_ALT_NAME_ENTRY, | |
| cRequestEntry : DWORD, | |
| rgRequestEntry : POCSP_REQUEST_ENTRY, | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| POCSP_REQUEST_INFO :: ^OCSP_REQUEST_INFO; | |
| OCSP_RESPONSE_INFO :: struct { | |
| dwStatus : DWORD, | |
| pszObjId : LPSTR, | |
| Value : CRYPT_OBJID_BLOB, | |
| }; | |
| POCSP_RESPONSE_INFO :: ^OCSP_RESPONSE_INFO; | |
| OCSP_BASIC_SIGNED_RESPONSE_INFO :: struct { | |
| ToBeSigned : CRYPT_DER_BLOB, | |
| SignatureInfo : OCSP_SIGNATURE_INFO, | |
| }; | |
| POCSP_BASIC_SIGNED_RESPONSE_INFO :: ^OCSP_BASIC_SIGNED_RESPONSE_INFO; | |
| OCSP_BASIC_REVOKED_INFO :: struct { | |
| RevocationDate : FILETIME, | |
| dwCrlReasonCode : DWORD, | |
| }; | |
| POCSP_BASIC_REVOKED_INFO :: ^OCSP_BASIC_REVOKED_INFO; | |
| OCSP_BASIC_RESPONSE_ENTRY :: struct { | |
| CertId : OCSP_CERT_ID, | |
| dwCertStatus : DWORD, | |
| u : struct #raw_union { | |
| pRevokedInfo : POCSP_BASIC_REVOKED_INFO, | |
| }, | |
| ThisUpdate : FILETIME, | |
| NextUpdate : FILETIME, | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| POCSP_BASIC_RESPONSE_ENTRY :: ^OCSP_BASIC_RESPONSE_ENTRY; | |
| OCSP_BASIC_RESPONSE_INFO :: struct { | |
| dwVersion : DWORD, | |
| dwResponderIdChoice : DWORD, | |
| u : struct #raw_union { | |
| ByNameResponderId : CERT_NAME_BLOB, | |
| ByKeyResponderId : CRYPT_HASH_BLOB, | |
| }, | |
| ProducedAt : FILETIME, | |
| cResponseEntry : DWORD, | |
| rgResponseEntry : POCSP_BASIC_RESPONSE_ENTRY, | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| POCSP_BASIC_RESPONSE_INFO :: ^OCSP_BASIC_RESPONSE_INFO; | |
| CERT_SUPPORTED_ALGORITHM_INFO :: struct { | |
| Algorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| IntendedKeyUsage : CRYPT_BIT_BLOB, | |
| IntendedCertPolicies : CERT_POLICIES_INFO, | |
| }; | |
| PCERT_SUPPORTED_ALGORITHM_INFO :: ^CERT_SUPPORTED_ALGORITHM_INFO; | |
| CERT_TPM_SPECIFICATION_INFO :: struct { | |
| pwszFamily : LPWSTR, | |
| dwLevel : DWORD, | |
| dwRevision : DWORD, | |
| }; | |
| PCERT_TPM_SPECIFICATION_INFO :: ^CERT_TPM_SPECIFICATION_INFO; | |
| HCRYPTOIDFUNCSET :: rawptr; | |
| HCRYPTOIDFUNCADDR :: rawptr; | |
| CRYPT_OID_FUNC_ENTRY :: struct { | |
| pszOID : LPCSTR, | |
| pvFuncAddr : rawptr, | |
| }; | |
| PCRYPT_OID_FUNC_ENTRY :: ^CRYPT_OID_FUNC_ENTRY; | |
| PFN_CRYPT_ENUM_OID_FUNC :: (proc "stdcall" (dwEncodingType : DWORD, pszFuncName : LPCSTR, pszOID : LPCSTR, cValue : DWORD, rgdwValueType : []DWORD, rgpwszValueName : []LPCWSTR, rgpbValueData : []^BYTE, rgcbValueData : []DWORD, pvArg : rawptr) -> BOOL); | |
| CRYPT_OID_INFO :: struct { | |
| cbSize : DWORD, | |
| pszOID : LPCSTR, | |
| pwszName : LPCWSTR, | |
| dwGroupId : DWORD, | |
| u : struct #raw_union { | |
| dwValue : DWORD, | |
| Algid : ALG_ID, | |
| dwLength : DWORD, | |
| }, | |
| ExtraInfo : CRYPT_DATA_BLOB, | |
| }; | |
| PCRYPT_OID_INFO :: ^CRYPT_OID_INFO; | |
| CCRYPT_OID_INFO :: CRYPT_OID_INFO; | |
| PCCRYPT_OID_INFO :: ^CRYPT_OID_INFO; | |
| PFN_CRYPT_ENUM_OID_INFO :: (proc "stdcall" (pInfo : PCCRYPT_OID_INFO, pvArg : rawptr) -> BOOL); | |
| CERT_STRONG_SIGN_SERIALIZED_INFO :: struct { | |
| dwFlags : DWORD, | |
| pwszCNGSignHashAlgids : LPWSTR, | |
| pwszCNGPubKeyMinBitLengths : LPWSTR, | |
| }; | |
| PCERT_STRONG_SIGN_SERIALIZED_INFO :: ^CERT_STRONG_SIGN_SERIALIZED_INFO; | |
| CERT_STRONG_SIGN_PARA :: struct { | |
| cbSize : DWORD, | |
| dwInfoChoice : DWORD, | |
| u : struct #raw_union { | |
| pvInfo : rawptr, | |
| pSerializedInfo : PCERT_STRONG_SIGN_SERIALIZED_INFO, | |
| pszOID : LPSTR, | |
| }, | |
| }; | |
| PCERT_STRONG_SIGN_PARA :: ^CERT_STRONG_SIGN_PARA; | |
| PCCERT_STRONG_SIGN_PARA :: ^CERT_STRONG_SIGN_PARA; | |
| HCRYPTMSG :: rawptr; | |
| CERT_ISSUER_SERIAL_NUMBER :: struct { | |
| Issuer : CERT_NAME_BLOB, | |
| SerialNumber : CRYPT_INTEGER_BLOB, | |
| }; | |
| PCERT_ISSUER_SERIAL_NUMBER :: ^CERT_ISSUER_SERIAL_NUMBER; | |
| CERT_ID :: struct { | |
| dwIdChoice : DWORD, | |
| u : struct #raw_union { | |
| IssuerSerialNumber : CERT_ISSUER_SERIAL_NUMBER, | |
| KeyId : CRYPT_HASH_BLOB, | |
| HashId : CRYPT_HASH_BLOB, | |
| }, | |
| }; | |
| PCERT_ID :: ^CERT_ID; | |
| CMSG_SIGNER_ENCODE_INFO :: struct { | |
| cbSize : DWORD, | |
| pCertInfo : PCERT_INFO, | |
| u : struct #raw_union { | |
| hCryptProv : HCRYPTPROV, | |
| hNCryptKey : NCRYPT_KEY_HANDLE, | |
| }, | |
| dwKeySpec : DWORD, | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvHashAuxInfo : rawptr, | |
| cAuthAttr : DWORD, | |
| rgAuthAttr : PCRYPT_ATTRIBUTE, | |
| cUnauthAttr : DWORD, | |
| rgUnauthAttr : PCRYPT_ATTRIBUTE, | |
| }; | |
| PCMSG_SIGNER_ENCODE_INFO :: ^CMSG_SIGNER_ENCODE_INFO; | |
| CMSG_SIGNED_ENCODE_INFO :: struct { | |
| cbSize : DWORD, | |
| cSigners : DWORD, | |
| rgSigners : PCMSG_SIGNER_ENCODE_INFO, | |
| cCertEncoded : DWORD, | |
| rgCertEncoded : PCERT_BLOB, | |
| cCrlEncoded : DWORD, | |
| rgCrlEncoded : PCRL_BLOB, | |
| }; | |
| PCMSG_SIGNED_ENCODE_INFO :: ^CMSG_SIGNED_ENCODE_INFO; | |
| PCMSG_RECIPIENT_ENCODE_INFO :: ^CMSG_RECIPIENT_ENCODE_INFO; | |
| CMSG_ENVELOPED_ENCODE_INFO :: struct { | |
| cbSize : DWORD, | |
| hCryptProv : HCRYPTPROV_LEGACY, | |
| ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvEncryptionAuxInfo : rawptr, | |
| cRecipients : DWORD, | |
| rgpRecipients : ^PCERT_INFO, | |
| }; | |
| PCMSG_ENVELOPED_ENCODE_INFO :: ^CMSG_ENVELOPED_ENCODE_INFO; | |
| CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO :: struct { | |
| cbSize : DWORD, | |
| KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvKeyEncryptionAuxInfo : rawptr, | |
| hCryptProv : HCRYPTPROV_LEGACY, | |
| RecipientPublicKey : CRYPT_BIT_BLOB, | |
| RecipientId : CERT_ID, | |
| }; | |
| PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO :: ^CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO; | |
| CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO :: struct { | |
| cbSize : DWORD, | |
| RecipientPublicKey : CRYPT_BIT_BLOB, | |
| RecipientId : CERT_ID, | |
| Date : FILETIME, | |
| pOtherAttr : PCRYPT_ATTRIBUTE_TYPE_VALUE, | |
| }; | |
| PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO :: ^CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO; | |
| CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO :: struct { | |
| cbSize : DWORD, | |
| KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvKeyEncryptionAuxInfo : rawptr, | |
| KeyWrapAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvKeyWrapAuxInfo : rawptr, | |
| hCryptProv : HCRYPTPROV_LEGACY, | |
| dwKeySpec : DWORD, | |
| dwKeyChoice : DWORD, | |
| u : struct #raw_union { | |
| pEphemeralAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, | |
| pSenderId : PCERT_ID, | |
| }, | |
| UserKeyingMaterial : CRYPT_DATA_BLOB, | |
| cRecipientEncryptedKeys : DWORD, | |
| rgpRecipientEncryptedKeys : ^PCMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO, | |
| }; | |
| PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO :: ^CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO; | |
| CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO :: struct { | |
| cbSize : DWORD, | |
| KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvKeyEncryptionAuxInfo : rawptr, | |
| hCryptProv : HCRYPTPROV, | |
| dwKeyChoice : DWORD, | |
| u : struct #raw_union { | |
| hKeyEncryptionKey : HCRYPTKEY, | |
| pvKeyEncryptionKey : rawptr, | |
| }, | |
| KeyId : CRYPT_DATA_BLOB, | |
| Date : FILETIME, | |
| pOtherAttr : PCRYPT_ATTRIBUTE_TYPE_VALUE, | |
| }; | |
| PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO :: ^CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO; | |
| CMSG_RECIPIENT_ENCODE_INFO :: struct { | |
| dwRecipientChoice : DWORD, | |
| u : struct #raw_union { | |
| pKeyTrans : PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO, | |
| pKeyAgree : PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO, | |
| pMailList : PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO, | |
| }, | |
| }; | |
| CMSG_RC2_AUX_INFO :: struct { | |
| cbSize : DWORD, | |
| dwBitLen : DWORD, | |
| }; | |
| PCMSG_RC2_AUX_INFO :: ^CMSG_RC2_AUX_INFO; | |
| CMSG_SP3_COMPATIBLE_AUX_INFO :: struct { | |
| cbSize : DWORD, | |
| dwFlags : DWORD, | |
| }; | |
| PCMSG_SP3_COMPATIBLE_AUX_INFO :: ^CMSG_SP3_COMPATIBLE_AUX_INFO; | |
| CMSG_RC4_AUX_INFO :: struct { | |
| cbSize : DWORD, | |
| dwBitLen : DWORD, | |
| }; | |
| PCMSG_RC4_AUX_INFO :: ^CMSG_RC4_AUX_INFO; | |
| CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO :: struct { | |
| cbSize : DWORD, | |
| SignedInfo : CMSG_SIGNED_ENCODE_INFO, | |
| EnvelopedInfo : CMSG_ENVELOPED_ENCODE_INFO, | |
| }; | |
| PCMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO :: ^CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO; | |
| CMSG_HASHED_ENCODE_INFO :: struct { | |
| cbSize : DWORD, | |
| hCryptProv : HCRYPTPROV_LEGACY, | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvHashAuxInfo : rawptr, | |
| }; | |
| PCMSG_HASHED_ENCODE_INFO :: ^CMSG_HASHED_ENCODE_INFO; | |
| CMSG_ENCRYPTED_ENCODE_INFO :: struct { | |
| cbSize : DWORD, | |
| ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvEncryptionAuxInfo : rawptr, | |
| }; | |
| PCMSG_ENCRYPTED_ENCODE_INFO :: ^CMSG_ENCRYPTED_ENCODE_INFO; | |
| PFN_CMSG_STREAM_OUTPUT :: (proc "stdcall" (pvArg : rawptr, pbData : ^BYTE, cbData : DWORD, fFinal : BOOL) -> BOOL); | |
| CMSG_STREAM_INFO :: struct { | |
| cbContent : DWORD, | |
| pfnStreamOutput : PFN_CMSG_STREAM_OUTPUT, | |
| pvArg : rawptr, | |
| }; | |
| PCMSG_STREAM_INFO :: ^CMSG_STREAM_INFO; | |
| CMSG_SIGNER_INFO :: struct { | |
| 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, | |
| }; | |
| PCMSG_SIGNER_INFO :: ^CMSG_SIGNER_INFO; | |
| CMSG_CMS_SIGNER_INFO :: struct { | |
| dwVersion : DWORD, | |
| SignerId : CERT_ID, | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| HashEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| EncryptedHash : CRYPT_DATA_BLOB, | |
| AuthAttrs : CRYPT_ATTRIBUTES, | |
| UnauthAttrs : CRYPT_ATTRIBUTES, | |
| }; | |
| PCMSG_CMS_SIGNER_INFO :: ^CMSG_CMS_SIGNER_INFO; | |
| CMSG_ATTR :: CRYPT_ATTRIBUTES; | |
| PCMSG_ATTR :: ^CRYPT_ATTRIBUTES; | |
| CMSG_KEY_TRANS_RECIPIENT_INFO :: struct { | |
| dwVersion : DWORD, | |
| RecipientId : CERT_ID, | |
| KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| EncryptedKey : CRYPT_DATA_BLOB, | |
| }; | |
| PCMSG_KEY_TRANS_RECIPIENT_INFO :: ^CMSG_KEY_TRANS_RECIPIENT_INFO; | |
| CMSG_RECIPIENT_ENCRYPTED_KEY_INFO :: struct { | |
| RecipientId : CERT_ID, | |
| EncryptedKey : CRYPT_DATA_BLOB, | |
| Date : FILETIME, | |
| pOtherAttr : PCRYPT_ATTRIBUTE_TYPE_VALUE, | |
| }; | |
| PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO :: ^CMSG_RECIPIENT_ENCRYPTED_KEY_INFO; | |
| CMSG_KEY_AGREE_RECIPIENT_INFO :: struct { | |
| dwVersion : DWORD, | |
| dwOriginatorChoice : DWORD, | |
| u : struct #raw_union { | |
| OriginatorCertId : CERT_ID, | |
| OriginatorPublicKeyInfo : CERT_PUBLIC_KEY_INFO, | |
| }, | |
| UserKeyingMaterial : CRYPT_DATA_BLOB, | |
| KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| cRecipientEncryptedKeys : DWORD, | |
| rgpRecipientEncryptedKeys : ^PCMSG_RECIPIENT_ENCRYPTED_KEY_INFO, | |
| }; | |
| PCMSG_KEY_AGREE_RECIPIENT_INFO :: ^CMSG_KEY_AGREE_RECIPIENT_INFO; | |
| CMSG_MAIL_LIST_RECIPIENT_INFO :: struct { | |
| dwVersion : DWORD, | |
| KeyId : CRYPT_DATA_BLOB, | |
| KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| EncryptedKey : CRYPT_DATA_BLOB, | |
| Date : FILETIME, | |
| pOtherAttr : PCRYPT_ATTRIBUTE_TYPE_VALUE, | |
| }; | |
| PCMSG_MAIL_LIST_RECIPIENT_INFO :: ^CMSG_MAIL_LIST_RECIPIENT_INFO; | |
| CMSG_CMS_RECIPIENT_INFO :: struct { | |
| dwRecipientChoice : DWORD, | |
| u : struct #raw_union { | |
| pKeyTrans : PCMSG_KEY_TRANS_RECIPIENT_INFO, | |
| pKeyAgree : PCMSG_KEY_AGREE_RECIPIENT_INFO, | |
| pMailList : PCMSG_MAIL_LIST_RECIPIENT_INFO, | |
| }, | |
| }; | |
| PCMSG_CMS_RECIPIENT_INFO :: ^CMSG_CMS_RECIPIENT_INFO; | |
| CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA :: struct { | |
| cbSize : DWORD, | |
| hCryptProv : HCRYPTPROV_LEGACY, | |
| dwSignerIndex : DWORD, | |
| dwSignerType : DWORD, | |
| pvSigner : rawptr, | |
| }; | |
| PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA :: ^CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA; | |
| CMSG_CTRL_DECRYPT_PARA :: struct { | |
| cbSize : DWORD, | |
| u : struct #raw_union { | |
| hCryptProv : HCRYPTPROV, | |
| hNCryptKey : NCRYPT_KEY_HANDLE, | |
| }, | |
| dwKeySpec : DWORD, | |
| dwRecipientIndex : DWORD, | |
| }; | |
| PCMSG_CTRL_DECRYPT_PARA :: ^CMSG_CTRL_DECRYPT_PARA; | |
| CMSG_CTRL_KEY_TRANS_DECRYPT_PARA :: struct { | |
| cbSize : DWORD, | |
| u : struct #raw_union { | |
| hCryptProv : HCRYPTPROV, | |
| hNCryptKey : NCRYPT_KEY_HANDLE, | |
| }, | |
| dwKeySpec : DWORD, | |
| pKeyTrans : PCMSG_KEY_TRANS_RECIPIENT_INFO, | |
| dwRecipientIndex : DWORD, | |
| }; | |
| PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA :: ^CMSG_CTRL_KEY_TRANS_DECRYPT_PARA; | |
| CMSG_CTRL_KEY_AGREE_DECRYPT_PARA :: struct { | |
| cbSize : DWORD, | |
| u : struct #raw_union { | |
| hCryptProv : HCRYPTPROV, | |
| hNCryptKey : NCRYPT_KEY_HANDLE, | |
| }, | |
| dwKeySpec : DWORD, | |
| pKeyAgree : PCMSG_KEY_AGREE_RECIPIENT_INFO, | |
| dwRecipientIndex : DWORD, | |
| dwRecipientEncryptedKeyIndex : DWORD, | |
| OriginatorPublicKey : CRYPT_BIT_BLOB, | |
| }; | |
| PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA :: ^CMSG_CTRL_KEY_AGREE_DECRYPT_PARA; | |
| CMSG_CTRL_MAIL_LIST_DECRYPT_PARA :: struct { | |
| cbSize : DWORD, | |
| hCryptProv : HCRYPTPROV, | |
| pMailList : PCMSG_MAIL_LIST_RECIPIENT_INFO, | |
| dwRecipientIndex : DWORD, | |
| dwKeyChoice : DWORD, | |
| u : struct #raw_union { | |
| hKeyEncryptionKey : HCRYPTKEY, | |
| pvKeyEncryptionKey : rawptr, | |
| }, | |
| }; | |
| PCMSG_CTRL_MAIL_LIST_DECRYPT_PARA :: ^CMSG_CTRL_MAIL_LIST_DECRYPT_PARA; | |
| CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA :: struct { | |
| cbSize : DWORD, | |
| dwSignerIndex : DWORD, | |
| blob : CRYPT_DATA_BLOB, | |
| }; | |
| PCMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA :: ^CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA; | |
| CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA :: struct { | |
| cbSize : DWORD, | |
| dwSignerIndex : DWORD, | |
| dwUnauthAttrIndex : DWORD, | |
| }; | |
| PCMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA :: ^CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA; | |
| PFN_CMSG_ALLOC :: (proc "stdcall" (cb : _c.size_t) -> rawptr); | |
| PFN_CMSG_FREE :: proc "stdcall" (pv : rawptr); | |
| PFN_CMSG_GEN_ENCRYPT_KEY :: (proc "stdcall" (phCryptProv : ^HCRYPTPROV, paiEncrypt : PCRYPT_ALGORITHM_IDENTIFIER, pvEncryptAuxInfo : PVOID, pPublicKeyInfo : PCERT_PUBLIC_KEY_INFO, pfnAlloc : PFN_CMSG_ALLOC, phEncryptKey : ^HCRYPTKEY, ppbEncryptParameters : ^PBYTE, pcbEncryptParameters : PDWORD) -> BOOL); | |
| PFN_CMSG_EXPORT_ENCRYPT_KEY :: (proc "stdcall" (hCryptProv : HCRYPTPROV, hEncryptKey : HCRYPTKEY, pPublicKeyInfo : PCERT_PUBLIC_KEY_INFO, pbData : PBYTE, pcbData : PDWORD) -> BOOL); | |
| PFN_CMSG_IMPORT_ENCRYPT_KEY :: (proc "stdcall" (hCryptProv : HCRYPTPROV, dwKeySpec : DWORD, paiEncrypt : PCRYPT_ALGORITHM_IDENTIFIER, paiPubKey : PCRYPT_ALGORITHM_IDENTIFIER, pbEncodedKey : PBYTE, cbEncodedKey : DWORD, phEncryptKey : ^HCRYPTKEY) -> BOOL); | |
| CMSG_CONTENT_ENCRYPT_INFO :: struct { | |
| cbSize : DWORD, | |
| hCryptProv : HCRYPTPROV_LEGACY, | |
| ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvEncryptionAuxInfo : rawptr, | |
| cRecipients : DWORD, | |
| rgCmsRecipients : PCMSG_RECIPIENT_ENCODE_INFO, | |
| pfnAlloc : PFN_CMSG_ALLOC, | |
| pfnFree : PFN_CMSG_FREE, | |
| dwEncryptFlags : DWORD, | |
| u : struct #raw_union { | |
| hContentEncryptKey : HCRYPTKEY, | |
| hCNGContentEncryptKey : BCRYPT_KEY_HANDLE, | |
| }, | |
| dwFlags : DWORD, | |
| fCNG : BOOL, | |
| pbCNGContentEncryptKeyObject : ^BYTE, | |
| pbContentEncryptKey : ^BYTE, | |
| cbContentEncryptKey : DWORD, | |
| }; | |
| PCMSG_CONTENT_ENCRYPT_INFO :: ^CMSG_CONTENT_ENCRYPT_INFO; | |
| PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY :: (proc "stdcall" (pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, dwFlags : DWORD, pvReserved : rawptr) -> BOOL); | |
| CMSG_KEY_TRANS_ENCRYPT_INFO :: struct { | |
| cbSize : DWORD, | |
| dwRecipientIndex : DWORD, | |
| KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| EncryptedKey : CRYPT_DATA_BLOB, | |
| dwFlags : DWORD, | |
| }; | |
| PCMSG_KEY_TRANS_ENCRYPT_INFO :: ^CMSG_KEY_TRANS_ENCRYPT_INFO; | |
| PFN_CMSG_EXPORT_KEY_TRANS :: (proc "stdcall" (pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, pKeyTransEncodeInfo : PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO, pKeyTransEncryptInfo : PCMSG_KEY_TRANS_ENCRYPT_INFO, dwFlags : DWORD, pvReserved : rawptr) -> BOOL); | |
| CMSG_KEY_AGREE_KEY_ENCRYPT_INFO :: struct { | |
| cbSize : DWORD, | |
| EncryptedKey : CRYPT_DATA_BLOB, | |
| }; | |
| PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO :: ^CMSG_KEY_AGREE_KEY_ENCRYPT_INFO; | |
| CMSG_KEY_AGREE_ENCRYPT_INFO :: struct { | |
| cbSize : DWORD, | |
| dwRecipientIndex : DWORD, | |
| KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| UserKeyingMaterial : CRYPT_DATA_BLOB, | |
| dwOriginatorChoice : DWORD, | |
| u : struct #raw_union { | |
| OriginatorCertId : CERT_ID, | |
| OriginatorPublicKeyInfo : CERT_PUBLIC_KEY_INFO, | |
| }, | |
| cKeyAgreeKeyEncryptInfo : DWORD, | |
| rgpKeyAgreeKeyEncryptInfo : ^PCMSG_KEY_AGREE_KEY_ENCRYPT_INFO, | |
| dwFlags : DWORD, | |
| }; | |
| PCMSG_KEY_AGREE_ENCRYPT_INFO :: ^CMSG_KEY_AGREE_ENCRYPT_INFO; | |
| PFN_CMSG_EXPORT_KEY_AGREE :: (proc "stdcall" (pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, pKeyAgreeEncodeInfo : PCMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO, pKeyAgreeEncryptInfo : PCMSG_KEY_AGREE_ENCRYPT_INFO, dwFlags : DWORD, pvReserved : rawptr) -> BOOL); | |
| CMSG_MAIL_LIST_ENCRYPT_INFO :: struct { | |
| cbSize : DWORD, | |
| dwRecipientIndex : DWORD, | |
| KeyEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| EncryptedKey : CRYPT_DATA_BLOB, | |
| dwFlags : DWORD, | |
| }; | |
| PCMSG_MAIL_LIST_ENCRYPT_INFO :: ^CMSG_MAIL_LIST_ENCRYPT_INFO; | |
| PFN_CMSG_EXPORT_MAIL_LIST :: (proc "stdcall" (pContentEncryptInfo : PCMSG_CONTENT_ENCRYPT_INFO, pMailListEncodeInfo : PCMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO, pMailListEncryptInfo : PCMSG_MAIL_LIST_ENCRYPT_INFO, dwFlags : DWORD, pvReserved : rawptr) -> BOOL); | |
| PFN_CMSG_IMPORT_KEY_TRANS :: (proc "stdcall" (pContentEncryptionAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pKeyTransDecryptPara : PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA, dwFlags : DWORD, pvReserved : rawptr, phContentEncryptKey : ^HCRYPTKEY) -> BOOL); | |
| PFN_CMSG_IMPORT_KEY_AGREE :: (proc "stdcall" (pContentEncryptionAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pKeyAgreeDecryptPara : PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA, dwFlags : DWORD, pvReserved : rawptr, phContentEncryptKey : ^HCRYPTKEY) -> BOOL); | |
| PFN_CMSG_IMPORT_MAIL_LIST :: (proc "stdcall" (pContentEncryptionAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pMailListDecryptPara : PCMSG_CTRL_MAIL_LIST_DECRYPT_PARA, dwFlags : DWORD, pvReserved : rawptr, phContentEncryptKey : ^HCRYPTKEY) -> BOOL); | |
| CMSG_CNG_CONTENT_DECRYPT_INFO :: struct { | |
| cbSize : DWORD, | |
| ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pfnAlloc : PFN_CMSG_ALLOC, | |
| pfnFree : PFN_CMSG_FREE, | |
| hNCryptKey : NCRYPT_KEY_HANDLE, | |
| pbContentEncryptKey : ^BYTE, | |
| cbContentEncryptKey : DWORD, | |
| hCNGContentEncryptKey : BCRYPT_KEY_HANDLE, | |
| pbCNGContentEncryptKeyObject : ^BYTE, | |
| }; | |
| PCMSG_CNG_CONTENT_DECRYPT_INFO :: ^CMSG_CNG_CONTENT_DECRYPT_INFO; | |
| PFN_CMSG_CNG_IMPORT_KEY_TRANS :: (proc "stdcall" (pCNGContentDecryptInfo : PCMSG_CNG_CONTENT_DECRYPT_INFO, pKeyTransDecryptPara : PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA, dwFlags : DWORD, pvReserved : rawptr) -> BOOL); | |
| PFN_CMSG_CNG_IMPORT_KEY_AGREE :: (proc "stdcall" (pCNGContentDecryptInfo : PCMSG_CNG_CONTENT_DECRYPT_INFO, pKeyAgreeDecryptPara : PCMSG_CTRL_KEY_AGREE_DECRYPT_PARA, dwFlags : DWORD, pvReserved : rawptr) -> BOOL); | |
| PFN_CMSG_CNG_IMPORT_CONTENT_ENCRYPT_KEY :: (proc "stdcall" (pCNGContentDecryptInfo : PCMSG_CNG_CONTENT_DECRYPT_INFO, dwFlags : DWORD, pvReserved : rawptr) -> BOOL); | |
| HCERTSTORE :: rawptr; | |
| CERT_CONTEXT :: struct { | |
| dwCertEncodingType : DWORD, | |
| pbCertEncoded : ^BYTE, | |
| cbCertEncoded : DWORD, | |
| pCertInfo : PCERT_INFO, | |
| hCertStore : HCERTSTORE, | |
| }; | |
| PCERT_CONTEXT :: ^CERT_CONTEXT; | |
| PCCERT_CONTEXT :: ^CERT_CONTEXT; | |
| CRL_CONTEXT :: struct { | |
| dwCertEncodingType : DWORD, | |
| pbCrlEncoded : ^BYTE, | |
| cbCrlEncoded : DWORD, | |
| pCrlInfo : PCRL_INFO, | |
| hCertStore : HCERTSTORE, | |
| }; | |
| PCRL_CONTEXT :: ^CRL_CONTEXT; | |
| PCCRL_CONTEXT :: ^CRL_CONTEXT; | |
| CTL_CONTEXT :: struct { | |
| dwMsgAndCertEncodingType : DWORD, | |
| pbCtlEncoded : ^BYTE, | |
| cbCtlEncoded : DWORD, | |
| pCtlInfo : PCTL_INFO, | |
| hCertStore : HCERTSTORE, | |
| hCryptMsg : HCRYPTMSG, | |
| pbCtlContent : ^BYTE, | |
| cbCtlContent : DWORD, | |
| }; | |
| PCTL_CONTEXT :: ^CTL_CONTEXT; | |
| PCCTL_CONTEXT :: ^CTL_CONTEXT; | |
| /* CertKeyType :: enum { */ | |
| CertKeyType :: _c.int; | |
| KeyTypeOther :: 0; | |
| KeyTypeVirtualSmartCard :: 1; | |
| KeyTypePhysicalSmartCard :: 2; | |
| KeyTypePassport :: 3; | |
| KeyTypePassportRemote :: 4; | |
| KeyTypePassportSmartCard :: 5; | |
| KeyTypeHardware :: 6; | |
| KeyTypeSoftware :: 7; | |
| KeyTypeSelfSigned :: 8; | |
| /* } */ | |
| ; | |
| CRYPT_KEY_PROV_PARAM :: struct { | |
| dwParam : DWORD, | |
| pbData : ^BYTE, | |
| cbData : DWORD, | |
| dwFlags : DWORD, | |
| }; | |
| PCRYPT_KEY_PROV_PARAM :: ^CRYPT_KEY_PROV_PARAM; | |
| CRYPT_KEY_PROV_INFO :: struct { | |
| pwszContainerName : LPWSTR, | |
| pwszProvName : LPWSTR, | |
| dwProvType : DWORD, | |
| dwFlags : DWORD, | |
| cProvParam : DWORD, | |
| rgProvParam : PCRYPT_KEY_PROV_PARAM, | |
| dwKeySpec : DWORD, | |
| }; | |
| PCRYPT_KEY_PROV_INFO :: ^CRYPT_KEY_PROV_INFO; | |
| CERT_KEY_CONTEXT :: struct { | |
| cbSize : DWORD, | |
| u : struct #raw_union { | |
| hCryptProv : HCRYPTPROV, | |
| hNCryptKey : NCRYPT_KEY_HANDLE, | |
| }, | |
| dwKeySpec : DWORD, | |
| }; | |
| PCERT_KEY_CONTEXT :: ^CERT_KEY_CONTEXT; | |
| ROOT_INFO_LUID :: struct { | |
| LowPart : DWORD, | |
| HighPart : LONG, | |
| }; | |
| PROOT_INFO_LUID :: ^ROOT_INFO_LUID; | |
| CRYPT_SMART_CARD_ROOT_INFO :: struct { | |
| rgbCardID : [16]BYTE, | |
| luid : ROOT_INFO_LUID, | |
| }; | |
| PCRYPT_SMART_CARD_ROOT_INFO :: ^CRYPT_SMART_CARD_ROOT_INFO; | |
| CERT_SYSTEM_STORE_RELOCATE_PARA :: struct { | |
| u : struct #raw_union { | |
| hKeyBase : HKEY, | |
| pvBase : rawptr, | |
| }, | |
| u2 : struct #raw_union { | |
| pvSystemStore : rawptr, | |
| pszSystemStore : LPCSTR, | |
| pwszSystemStore : LPCWSTR, | |
| }, | |
| }; | |
| PCERT_SYSTEM_STORE_RELOCATE_PARA :: ^CERT_SYSTEM_STORE_RELOCATE_PARA; | |
| CERT_REGISTRY_STORE_CLIENT_GPT_PARA :: struct { | |
| hKeyBase : HKEY, | |
| pwszRegPath : LPWSTR, | |
| }; | |
| PCERT_REGISTRY_STORE_CLIENT_GPT_PARA :: ^CERT_REGISTRY_STORE_CLIENT_GPT_PARA; | |
| CERT_REGISTRY_STORE_ROAMING_PARA :: struct { | |
| hKey : HKEY, | |
| pwszStoreDirectory : LPWSTR, | |
| }; | |
| PCERT_REGISTRY_STORE_ROAMING_PARA :: ^CERT_REGISTRY_STORE_ROAMING_PARA; | |
| CERT_LDAP_STORE_OPENED_PARA :: struct { | |
| pvLdapSessionHandle : rawptr, | |
| pwszLdapUrl : LPCWSTR, | |
| }; | |
| PCERT_LDAP_STORE_OPENED_PARA :: ^CERT_LDAP_STORE_OPENED_PARA; | |
| HCERTSTOREPROV :: rawptr; | |
| CERT_STORE_PROV_INFO :: struct { | |
| cbSize : DWORD, | |
| cStoreProvFunc : DWORD, | |
| rgpvStoreProvFunc : ^rawptr, | |
| hStoreProv : HCERTSTOREPROV, | |
| dwStoreProvFlags : DWORD, | |
| hStoreProvFuncAddr2 : HCRYPTOIDFUNCADDR, | |
| }; | |
| PCERT_STORE_PROV_INFO :: ^CERT_STORE_PROV_INFO; | |
| PFN_CERT_DLL_OPEN_STORE_PROV_FUNC :: (proc "stdcall" (lpszStoreProvider : LPCSTR, dwEncodingType : DWORD, hCryptProv : HCRYPTPROV_LEGACY, dwFlags : DWORD, pvPara : rawptr, hCertStore : HCERTSTORE, pStoreProvInfo : PCERT_STORE_PROV_INFO) -> BOOL); | |
| PFN_CERT_STORE_PROV_CLOSE :: proc "stdcall" (hStoreProv : HCERTSTOREPROV, dwFlags : DWORD); | |
| PFN_CERT_STORE_PROV_READ_CERT :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pStoreCertContext : PCCERT_CONTEXT, dwFlags : DWORD, ppProvCertContext : ^PCCERT_CONTEXT) -> BOOL); | |
| PFN_CERT_STORE_PROV_WRITE_CERT :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwFlags : DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_DELETE_CERT :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwFlags : DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_SET_CERT_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr) -> BOOL); | |
| PFN_CERT_STORE_PROV_READ_CRL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pStoreCrlContext : PCCRL_CONTEXT, dwFlags : DWORD, ppProvCrlContext : ^PCCRL_CONTEXT) -> BOOL); | |
| PFN_CERT_STORE_PROV_WRITE_CRL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwFlags : DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_DELETE_CRL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwFlags : DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_SET_CRL_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr) -> BOOL); | |
| PFN_CERT_STORE_PROV_READ_CTL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pStoreCtlContext : PCCTL_CONTEXT, dwFlags : DWORD, ppProvCtlContext : ^PCCTL_CONTEXT) -> BOOL); | |
| PFN_CERT_STORE_PROV_WRITE_CTL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwFlags : DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_DELETE_CTL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwFlags : DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_SET_CTL_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr) -> BOOL); | |
| PFN_CERT_STORE_PROV_CONTROL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, dwFlags : DWORD, dwCtrlType : DWORD, pvCtrlPara : rawptr) -> BOOL); | |
| CERT_STORE_PROV_FIND_INFO :: struct { | |
| cbSize : DWORD, | |
| dwMsgAndCertEncodingType : DWORD, | |
| dwFindFlags : DWORD, | |
| dwFindType : DWORD, | |
| pvFindPara : rawptr, | |
| }; | |
| PCERT_STORE_PROV_FIND_INFO :: ^CERT_STORE_PROV_FIND_INFO; | |
| CCERT_STORE_PROV_FIND_INFO :: CERT_STORE_PROV_FIND_INFO; | |
| PCCERT_STORE_PROV_FIND_INFO :: ^CERT_STORE_PROV_FIND_INFO; | |
| PFN_CERT_STORE_PROV_FIND_CERT :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pFindInfo : PCCERT_STORE_PROV_FIND_INFO, pPrevCertContext : PCCERT_CONTEXT, dwFlags : DWORD, ppvStoreProvFindInfo : ^rawptr, ppProvCertContext : ^PCCERT_CONTEXT) -> BOOL); | |
| PFN_CERT_STORE_PROV_FREE_FIND_CERT :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, pvStoreProvFindInfo : rawptr, dwFlags : DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_GET_CERT_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCertContext : PCCERT_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr, pcbData : ^DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_FIND_CRL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pFindInfo : PCCERT_STORE_PROV_FIND_INFO, pPrevCrlContext : PCCRL_CONTEXT, dwFlags : DWORD, ppvStoreProvFindInfo : ^rawptr, ppProvCrlContext : ^PCCRL_CONTEXT) -> BOOL); | |
| PFN_CERT_STORE_PROV_FREE_FIND_CRL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, pvStoreProvFindInfo : rawptr, dwFlags : DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_GET_CRL_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCrlContext : PCCRL_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr, pcbData : ^DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_FIND_CTL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pFindInfo : PCCERT_STORE_PROV_FIND_INFO, pPrevCtlContext : PCCTL_CONTEXT, dwFlags : DWORD, ppvStoreProvFindInfo : ^rawptr, ppProvCtlContext : ^PCCTL_CONTEXT) -> BOOL); | |
| PFN_CERT_STORE_PROV_FREE_FIND_CTL :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, pvStoreProvFindInfo : rawptr, dwFlags : DWORD) -> BOOL); | |
| PFN_CERT_STORE_PROV_GET_CTL_PROPERTY :: (proc "stdcall" (hStoreProv : HCERTSTOREPROV, pCtlContext : PCCTL_CONTEXT, dwPropId : DWORD, dwFlags : DWORD, pvData : rawptr, pcbData : ^DWORD) -> BOOL); | |
| CRL_FIND_ISSUED_FOR_PARA :: struct { | |
| pSubjectCert : PCCERT_CONTEXT, | |
| pIssuerCert : PCCERT_CONTEXT, | |
| }; | |
| PCRL_FIND_ISSUED_FOR_PARA :: ^CRL_FIND_ISSUED_FOR_PARA; | |
| CTL_ANY_SUBJECT_INFO :: struct { | |
| SubjectAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| SubjectIdentifier : CRYPT_DATA_BLOB, | |
| }; | |
| PCTL_ANY_SUBJECT_INFO :: ^CTL_ANY_SUBJECT_INFO; | |
| CTL_FIND_USAGE_PARA :: struct { | |
| cbSize : DWORD, | |
| SubjectUsage : CTL_USAGE, | |
| ListIdentifier : CRYPT_DATA_BLOB, | |
| pSigner : PCERT_INFO, | |
| }; | |
| PCTL_FIND_USAGE_PARA :: ^CTL_FIND_USAGE_PARA; | |
| CTL_FIND_SUBJECT_PARA :: struct { | |
| cbSize : DWORD, | |
| pUsagePara : PCTL_FIND_USAGE_PARA, | |
| dwSubjectType : DWORD, | |
| pvSubject : rawptr, | |
| }; | |
| PCTL_FIND_SUBJECT_PARA :: ^CTL_FIND_SUBJECT_PARA; | |
| PFN_CERT_CREATE_CONTEXT_SORT_FUNC :: (proc "stdcall" (cbTotalEncoded : DWORD, cbRemainEncoded : DWORD, cEntry : DWORD, pvSort : rawptr) -> BOOL); | |
| CERT_CREATE_CONTEXT_PARA :: struct { | |
| cbSize : DWORD, | |
| pfnFree : PFN_CRYPT_FREE, | |
| pvFree : rawptr, | |
| pfnSort : PFN_CERT_CREATE_CONTEXT_SORT_FUNC, | |
| pvSort : rawptr, | |
| }; | |
| PCERT_CREATE_CONTEXT_PARA :: ^CERT_CREATE_CONTEXT_PARA; | |
| CERT_SYSTEM_STORE_INFO :: struct { | |
| cbSize : DWORD, | |
| }; | |
| PCERT_SYSTEM_STORE_INFO :: ^CERT_SYSTEM_STORE_INFO; | |
| CERT_PHYSICAL_STORE_INFO :: struct { | |
| cbSize : DWORD, | |
| pszOpenStoreProvider : LPSTR, | |
| dwOpenEncodingType : DWORD, | |
| dwOpenFlags : DWORD, | |
| OpenParameters : CRYPT_DATA_BLOB, | |
| dwFlags : DWORD, | |
| dwPriority : DWORD, | |
| }; | |
| PCERT_PHYSICAL_STORE_INFO :: ^CERT_PHYSICAL_STORE_INFO; | |
| PFN_CERT_ENUM_SYSTEM_STORE_LOCATION :: (proc "stdcall" (pwszStoreLocation : LPCWSTR, dwFlags : DWORD, pvReserved : rawptr, pvArg : rawptr) -> BOOL); | |
| PFN_CERT_ENUM_SYSTEM_STORE :: (proc "stdcall" (pvSystemStore : rawptr, dwFlags : DWORD, pStoreInfo : PCERT_SYSTEM_STORE_INFO, pvReserved : rawptr, pvArg : rawptr) -> BOOL); | |
| PFN_CERT_ENUM_PHYSICAL_STORE :: (proc "stdcall" (pvSystemStore : rawptr, dwFlags : DWORD, pwszStoreName : LPCWSTR, pStoreInfo : PCERT_PHYSICAL_STORE_INFO, pvReserved : rawptr, pvArg : rawptr) -> BOOL); | |
| CTL_VERIFY_USAGE_PARA :: struct { | |
| cbSize : DWORD, | |
| ListIdentifier : CRYPT_DATA_BLOB, | |
| cCtlStore : DWORD, | |
| rghCtlStore : ^HCERTSTORE, | |
| cSignerStore : DWORD, | |
| rghSignerStore : ^HCERTSTORE, | |
| }; | |
| PCTL_VERIFY_USAGE_PARA :: ^CTL_VERIFY_USAGE_PARA; | |
| CTL_VERIFY_USAGE_STATUS :: struct { | |
| cbSize : DWORD, | |
| dwError : DWORD, | |
| dwFlags : DWORD, | |
| ppCtl : ^PCCTL_CONTEXT, | |
| dwCtlEntryIndex : DWORD, | |
| ppSigner : ^PCCERT_CONTEXT, | |
| dwSignerIndex : DWORD, | |
| }; | |
| PCTL_VERIFY_USAGE_STATUS :: ^CTL_VERIFY_USAGE_STATUS; | |
| CERT_REVOCATION_CRL_INFO :: struct { | |
| cbSize : DWORD, | |
| pBaseCrlContext : PCCRL_CONTEXT, | |
| pDeltaCrlContext : PCCRL_CONTEXT, | |
| pCrlEntry : PCRL_ENTRY, | |
| fDeltaCrlEntry : BOOL, | |
| }; | |
| PCERT_REVOCATION_CRL_INFO :: ^CERT_REVOCATION_CRL_INFO; | |
| PCERT_REVOCATION_CHAIN_PARA :: ^CERT_REVOCATION_CHAIN_PARA; | |
| CERT_REVOCATION_PARA :: struct { | |
| cbSize : DWORD, | |
| pIssuerCert : PCCERT_CONTEXT, | |
| cCertStore : DWORD, | |
| rgCertStore : ^HCERTSTORE, | |
| hCrlStore : HCERTSTORE, | |
| pftTimeToUse : LPFILETIME, | |
| }; | |
| PCERT_REVOCATION_PARA :: ^CERT_REVOCATION_PARA; | |
| CERT_REVOCATION_STATUS :: struct { | |
| cbSize : DWORD, | |
| dwIndex : DWORD, | |
| dwError : DWORD, | |
| dwReason : DWORD, | |
| fHasFreshnessTime : BOOL, | |
| dwFreshnessTime : DWORD, | |
| }; | |
| PCERT_REVOCATION_STATUS :: ^CERT_REVOCATION_STATUS; | |
| CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO :: struct { | |
| CertSignHashCNGAlgPropData : CRYPT_DATA_BLOB, | |
| CertIssuerPubKeyBitLengthPropData : CRYPT_DATA_BLOB, | |
| }; | |
| PCRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO :: ^CRYPT_VERIFY_CERT_SIGN_STRONG_PROPERTIES_INFO; | |
| CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO :: struct { | |
| cCNGHashAlgid : DWORD, | |
| rgpwszCNGHashAlgid : ^PCWSTR, | |
| dwWeakIndex : DWORD, | |
| }; | |
| PCRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO :: ^CRYPT_VERIFY_CERT_SIGN_WEAK_HASH_INFO; | |
| PFN_CRYPT_EXTRACT_ENCODED_SIGNATURE_PARAMETERS_FUNC :: (proc "stdcall" (dwCertEncodingType : DWORD, pSignatureAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, ppvDecodedSignPara : ^rawptr, ppwszCNGHashAlgid : ^LPWSTR) -> BOOL); | |
| PFN_CRYPT_SIGN_AND_ENCODE_HASH_FUNC :: (proc "stdcall" (hKey : NCRYPT_KEY_HANDLE, dwCertEncodingType : DWORD, pSignatureAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pvDecodedSignPara : rawptr, pwszCNGPubKeyAlgid : LPCWSTR, pwszCNGHashAlgid : LPCWSTR, pbComputedHash : ^BYTE, cbComputedHash : DWORD, pbSignature : ^BYTE, pcbSignature : ^DWORD) -> BOOL); | |
| PFN_CRYPT_VERIFY_ENCODED_SIGNATURE_FUNC :: (proc "stdcall" (dwCertEncodingType : DWORD, pPubKeyInfo : PCERT_PUBLIC_KEY_INFO, pSignatureAlgorithm : PCRYPT_ALGORITHM_IDENTIFIER, pvDecodedSignPara : rawptr, pwszCNGPubKeyAlgid : LPCWSTR, pwszCNGHashAlgid : LPCWSTR, pbComputedHash : ^BYTE, cbComputedHash : DWORD, pbSignature : ^BYTE, cbSignature : DWORD) -> BOOL); | |
| HCRYPTDEFAULTCONTEXT :: rawptr; | |
| CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA :: struct { | |
| cOID : DWORD, | |
| rgpszOID : ^LPSTR, | |
| }; | |
| PCRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA :: ^CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA; | |
| PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_EX2_FUNC :: (proc "stdcall" (hNCryptKey : NCRYPT_KEY_HANDLE, dwCertEncodingType : DWORD, pszPublicKeyObjId : LPSTR, dwFlags : DWORD, pvAuxInfo : rawptr, pInfo : PCERT_PUBLIC_KEY_INFO, pcbInfo : ^DWORD) -> BOOL); | |
| PFN_CRYPT_EXPORT_PUBLIC_KEY_INFO_FROM_BCRYPT_HANDLE_FUNC :: (proc "stdcall" (hBCryptKey : BCRYPT_KEY_HANDLE, dwCertEncodingType : DWORD, pszPublicKeyObjId : LPSTR, dwFlags : DWORD, pvAuxInfo : rawptr, pInfo : PCERT_PUBLIC_KEY_INFO, pcbInfo : ^DWORD) -> BOOL); | |
| PFN_IMPORT_PUBLIC_KEY_INFO_EX2_FUNC :: (proc "stdcall" (dwCertEncodingType : DWORD, pInfo : PCERT_PUBLIC_KEY_INFO, dwFlags : DWORD, pvAuxInfo : rawptr, phKey : ^BCRYPT_KEY_HANDLE) -> BOOL); | |
| PFN_IMPORT_PRIV_KEY_FUNC :: (proc "stdcall" (hCryptProv : HCRYPTPROV, pPrivateKeyInfo : ^CRYPT_PRIVATE_KEY_INFO, dwFlags : DWORD, pvAuxInfo : rawptr) -> BOOL); | |
| PFN_EXPORT_PRIV_KEY_FUNC :: (proc "stdcall" (hCryptProv : HCRYPTPROV, dwKeySpec : DWORD, pszPrivateKeyObjId : LPSTR, dwFlags : DWORD, pvAuxInfo : rawptr, pPrivateKeyInfo : ^CRYPT_PRIVATE_KEY_INFO, pcbPrivateKeyInfo : ^DWORD) -> BOOL); | |
| PFN_CRYPT_GET_SIGNER_CERTIFICATE :: (proc "stdcall" (pvGetArg : rawptr, dwCertEncodingType : DWORD, pSignerId : PCERT_INFO, hMsgCertStore : HCERTSTORE) -> PCCERT_CONTEXT); | |
| CRYPT_SIGN_MESSAGE_PARA :: struct { | |
| cbSize : DWORD, | |
| dwMsgEncodingType : DWORD, | |
| pSigningCert : PCCERT_CONTEXT, | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvHashAuxInfo : rawptr, | |
| cMsgCert : DWORD, | |
| rgpMsgCert : ^PCCERT_CONTEXT, | |
| cMsgCrl : DWORD, | |
| rgpMsgCrl : ^PCCRL_CONTEXT, | |
| cAuthAttr : DWORD, | |
| rgAuthAttr : PCRYPT_ATTRIBUTE, | |
| cUnauthAttr : DWORD, | |
| rgUnauthAttr : PCRYPT_ATTRIBUTE, | |
| dwFlags : DWORD, | |
| dwInnerContentType : DWORD, | |
| }; | |
| PCRYPT_SIGN_MESSAGE_PARA :: ^CRYPT_SIGN_MESSAGE_PARA; | |
| CRYPT_VERIFY_MESSAGE_PARA :: struct { | |
| cbSize : DWORD, | |
| dwMsgAndCertEncodingType : DWORD, | |
| hCryptProv : HCRYPTPROV_LEGACY, | |
| pfnGetSignerCertificate : PFN_CRYPT_GET_SIGNER_CERTIFICATE, | |
| pvGetArg : rawptr, | |
| }; | |
| PCRYPT_VERIFY_MESSAGE_PARA :: ^CRYPT_VERIFY_MESSAGE_PARA; | |
| CRYPT_ENCRYPT_MESSAGE_PARA :: struct { | |
| cbSize : DWORD, | |
| dwMsgEncodingType : DWORD, | |
| hCryptProv : HCRYPTPROV_LEGACY, | |
| ContentEncryptionAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvEncryptionAuxInfo : rawptr, | |
| dwFlags : DWORD, | |
| dwInnerContentType : DWORD, | |
| }; | |
| PCRYPT_ENCRYPT_MESSAGE_PARA :: ^CRYPT_ENCRYPT_MESSAGE_PARA; | |
| CRYPT_DECRYPT_MESSAGE_PARA :: struct { | |
| cbSize : DWORD, | |
| dwMsgAndCertEncodingType : DWORD, | |
| cCertStore : DWORD, | |
| rghCertStore : ^HCERTSTORE, | |
| }; | |
| PCRYPT_DECRYPT_MESSAGE_PARA :: ^CRYPT_DECRYPT_MESSAGE_PARA; | |
| CRYPT_HASH_MESSAGE_PARA :: struct { | |
| cbSize : DWORD, | |
| dwMsgEncodingType : DWORD, | |
| hCryptProv : HCRYPTPROV_LEGACY, | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvHashAuxInfo : rawptr, | |
| }; | |
| PCRYPT_HASH_MESSAGE_PARA :: ^CRYPT_HASH_MESSAGE_PARA; | |
| CRYPT_KEY_SIGN_MESSAGE_PARA :: struct { | |
| cbSize : DWORD, | |
| dwMsgAndCertEncodingType : DWORD, | |
| u : struct #raw_union { | |
| hCryptProv : HCRYPTPROV, | |
| hNCryptKey : NCRYPT_KEY_HANDLE, | |
| }, | |
| dwKeySpec : DWORD, | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| pvHashAuxInfo : rawptr, | |
| PubKeyAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| }; | |
| PCRYPT_KEY_SIGN_MESSAGE_PARA :: ^CRYPT_KEY_SIGN_MESSAGE_PARA; | |
| CRYPT_KEY_VERIFY_MESSAGE_PARA :: struct { | |
| cbSize : DWORD, | |
| dwMsgEncodingType : DWORD, | |
| hCryptProv : HCRYPTPROV_LEGACY, | |
| }; | |
| PCRYPT_KEY_VERIFY_MESSAGE_PARA :: ^CRYPT_KEY_VERIFY_MESSAGE_PARA; | |
| CERT_CHAIN :: struct { | |
| cCerts : DWORD, | |
| certs : PCERT_BLOB, | |
| keyLocatorInfo : CRYPT_KEY_PROV_INFO, | |
| }; | |
| PCERT_CHAIN :: ^CERT_CHAIN; | |
| HCRYPTASYNC :: HANDLE; | |
| PHCRYPTASYNC :: ^HANDLE; | |
| PFN_CRYPT_ASYNC_PARAM_FREE_FUNC :: proc "stdcall" (pszParamOid : LPSTR, pvParam : LPVOID); | |
| CRYPT_BLOB_ARRAY :: struct { | |
| cBlob : DWORD, | |
| rgBlob : PCRYPT_DATA_BLOB, | |
| }; | |
| PCRYPT_BLOB_ARRAY :: ^CRYPT_BLOB_ARRAY; | |
| CRYPT_CREDENTIALS :: struct { | |
| cbSize : DWORD, | |
| pszCredentialsOid : LPCSTR, | |
| pvCredentials : LPVOID, | |
| }; | |
| PCRYPT_CREDENTIALS :: ^CRYPT_CREDENTIALS; | |
| CRYPT_PASSWORD_CREDENTIALSA :: struct { | |
| cbSize : DWORD, | |
| pszUsername : LPSTR, | |
| pszPassword : LPSTR, | |
| }; | |
| PCRYPT_PASSWORD_CREDENTIALSA :: ^CRYPT_PASSWORD_CREDENTIALSA; | |
| CRYPT_PASSWORD_CREDENTIALSW :: struct { | |
| cbSize : DWORD, | |
| pszUsername : LPWSTR, | |
| pszPassword : LPWSTR, | |
| }; | |
| PCRYPT_PASSWORD_CREDENTIALSW :: ^CRYPT_PASSWORD_CREDENTIALSW; | |
| CRYPT_PASSWORD_CREDENTIALS :: CRYPT_PASSWORD_CREDENTIALSA; | |
| PCRYPT_PASSWORD_CREDENTIALS :: PCRYPT_PASSWORD_CREDENTIALSA; | |
| PFN_FREE_ENCODED_OBJECT_FUNC :: proc "stdcall" (pszObjectOid : LPCSTR, pObject : PCRYPT_BLOB_ARRAY, pvFreeContext : LPVOID); | |
| CRYPTNET_URL_CACHE_PRE_FETCH_INFO :: struct { | |
| cbSize : DWORD, | |
| dwObjectType : DWORD, | |
| dwError : DWORD, | |
| dwReserved : DWORD, | |
| ThisUpdateTime : FILETIME, | |
| NextUpdateTime : FILETIME, | |
| PublishTime : FILETIME, | |
| }; | |
| PCRYPTNET_URL_CACHE_PRE_FETCH_INFO :: ^CRYPTNET_URL_CACHE_PRE_FETCH_INFO; | |
| CRYPTNET_URL_CACHE_FLUSH_INFO :: struct { | |
| cbSize : DWORD, | |
| dwExemptSeconds : DWORD, | |
| ExpireTime : FILETIME, | |
| }; | |
| PCRYPTNET_URL_CACHE_FLUSH_INFO :: ^CRYPTNET_URL_CACHE_FLUSH_INFO; | |
| CRYPTNET_URL_CACHE_RESPONSE_INFO :: struct { | |
| cbSize : DWORD, | |
| wResponseType : WORD, | |
| wResponseFlags : WORD, | |
| LastModifiedTime : FILETIME, | |
| dwMaxAge : DWORD, | |
| pwszETag : LPCWSTR, | |
| dwProxyId : DWORD, | |
| }; | |
| PCRYPTNET_URL_CACHE_RESPONSE_INFO :: ^CRYPTNET_URL_CACHE_RESPONSE_INFO; | |
| CRYPT_RETRIEVE_AUX_INFO :: struct { | |
| cbSize : DWORD, | |
| pLastSyncTime : ^FILETIME, | |
| dwMaxUrlRetrievalByteCount : DWORD, | |
| pPreFetchInfo : PCRYPTNET_URL_CACHE_PRE_FETCH_INFO, | |
| pFlushInfo : PCRYPTNET_URL_CACHE_FLUSH_INFO, | |
| ppResponseInfo : ^PCRYPTNET_URL_CACHE_RESPONSE_INFO, | |
| pwszCacheFileNamePrefix : LPWSTR, | |
| pftCacheResync : LPFILETIME, | |
| fProxyCacheRetrieval : BOOL, | |
| dwHttpStatusCode : DWORD, | |
| ppwszErrorResponseHeaders : ^LPWSTR, | |
| ppErrorContentBlob : ^PCRYPT_DATA_BLOB, | |
| }; | |
| PCRYPT_RETRIEVE_AUX_INFO :: ^CRYPT_RETRIEVE_AUX_INFO; | |
| PFN_CRYPT_CANCEL_RETRIEVAL :: (proc "stdcall" (dwFlags : DWORD, pvArg : rawptr) -> BOOL); | |
| PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC :: proc "stdcall" (pvCompletion : LPVOID, dwCompletionCode : DWORD, pszUrl : LPCSTR, pszObjectOid : LPSTR, pvObject : LPVOID); | |
| CRYPT_ASYNC_RETRIEVAL_COMPLETION :: struct { | |
| pfnCompletion : PFN_CRYPT_ASYNC_RETRIEVAL_COMPLETION_FUNC, | |
| pvCompletion : LPVOID, | |
| }; | |
| PCRYPT_ASYNC_RETRIEVAL_COMPLETION :: ^CRYPT_ASYNC_RETRIEVAL_COMPLETION; | |
| PFN_CANCEL_ASYNC_RETRIEVAL_FUNC :: (proc "stdcall" (hAsyncRetrieve : HCRYPTASYNC) -> BOOL); | |
| CRYPT_URL_ARRAY :: struct { | |
| cUrl : DWORD, | |
| rgwszUrl : ^LPWSTR, | |
| }; | |
| PCRYPT_URL_ARRAY :: ^CRYPT_URL_ARRAY; | |
| CRYPT_URL_INFO :: struct { | |
| cbSize : DWORD, | |
| dwSyncDeltaTime : DWORD, | |
| cGroup : DWORD, | |
| rgcGroupEntry : ^DWORD, | |
| }; | |
| PCRYPT_URL_INFO :: ^CRYPT_URL_INFO; | |
| CERT_CRL_CONTEXT_PAIR :: struct { | |
| pCertContext : PCCERT_CONTEXT, | |
| pCrlContext : PCCRL_CONTEXT, | |
| }; | |
| PCERT_CRL_CONTEXT_PAIR :: ^CERT_CRL_CONTEXT_PAIR; | |
| PCCERT_CRL_CONTEXT_PAIR :: ^CERT_CRL_CONTEXT_PAIR; | |
| CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO :: struct { | |
| cbSize : DWORD, | |
| iDeltaCrlIndicator : _c.int, | |
| pftCacheResync : LPFILETIME, | |
| pLastSyncTime : LPFILETIME, | |
| pMaxAgeTime : LPFILETIME, | |
| pChainPara : PCERT_REVOCATION_CHAIN_PARA, | |
| pDeltaCrlIndicator : PCRYPT_INTEGER_BLOB, | |
| }; | |
| PCRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO :: ^CRYPT_GET_TIME_VALID_OBJECT_EXTRA_INFO; | |
| PFN_CRYPT_ENUM_KEYID_PROP :: (proc "stdcall" (pKeyIdentifier : ^CRYPT_HASH_BLOB, dwFlags : DWORD, pvReserved : rawptr, pvArg : rawptr, cProp : DWORD, rgdwPropId : ^DWORD, rgpvData : ^rawptr, rgcbData : ^DWORD) -> BOOL); | |
| HCERTCHAINENGINE :: HANDLE; | |
| CERT_CHAIN_ENGINE_CONFIG :: struct { | |
| cbSize : DWORD, | |
| hRestrictedRoot : HCERTSTORE, | |
| hRestrictedTrust : HCERTSTORE, | |
| hRestrictedOther : HCERTSTORE, | |
| cAdditionalStore : DWORD, | |
| rghAdditionalStore : ^HCERTSTORE, | |
| dwFlags : DWORD, | |
| dwUrlRetrievalTimeout : DWORD, | |
| MaximumCachedCertificates : DWORD, | |
| CycleDetectionModulus : DWORD, | |
| hExclusiveRoot : HCERTSTORE, | |
| hExclusiveTrustedPeople : HCERTSTORE, | |
| dwExclusiveFlags : DWORD, | |
| }; | |
| PCERT_CHAIN_ENGINE_CONFIG :: ^CERT_CHAIN_ENGINE_CONFIG; | |
| CERT_TRUST_STATUS :: struct { | |
| dwErrorStatus : DWORD, | |
| dwInfoStatus : DWORD, | |
| }; | |
| PCERT_TRUST_STATUS :: ^CERT_TRUST_STATUS; | |
| CERT_REVOCATION_INFO :: struct { | |
| cbSize : DWORD, | |
| dwRevocationResult : DWORD, | |
| pszRevocationOid : LPCSTR, | |
| pvOidSpecificInfo : LPVOID, | |
| fHasFreshnessTime : BOOL, | |
| dwFreshnessTime : DWORD, | |
| pCrlInfo : PCERT_REVOCATION_CRL_INFO, | |
| }; | |
| PCERT_REVOCATION_INFO :: ^CERT_REVOCATION_INFO; | |
| CERT_TRUST_LIST_INFO :: struct { | |
| cbSize : DWORD, | |
| pCtlEntry : PCTL_ENTRY, | |
| pCtlContext : PCCTL_CONTEXT, | |
| }; | |
| PCERT_TRUST_LIST_INFO :: ^CERT_TRUST_LIST_INFO; | |
| CERT_CHAIN_ELEMENT :: struct { | |
| 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 :: ^CERT_CHAIN_ELEMENT; | |
| PCCERT_CHAIN_ELEMENT :: ^CERT_CHAIN_ELEMENT; | |
| CERT_SIMPLE_CHAIN :: struct { | |
| cbSize : DWORD, | |
| TrustStatus : CERT_TRUST_STATUS, | |
| cElement : DWORD, | |
| rgpElement : ^PCERT_CHAIN_ELEMENT, | |
| pTrustListInfo : PCERT_TRUST_LIST_INFO, | |
| fHasRevocationFreshnessTime : BOOL, | |
| dwRevocationFreshnessTime : DWORD, | |
| }; | |
| PCERT_SIMPLE_CHAIN :: ^CERT_SIMPLE_CHAIN; | |
| PCCERT_SIMPLE_CHAIN :: ^CERT_SIMPLE_CHAIN; | |
| PCERT_CHAIN_CONTEXT :: ^CERT_CHAIN_CONTEXT; | |
| PCCERT_CHAIN_CONTEXT :: ^CERT_CHAIN_CONTEXT; | |
| CERT_CHAIN_CONTEXT :: struct { | |
| cbSize : DWORD, | |
| TrustStatus : CERT_TRUST_STATUS, | |
| cChain : DWORD, | |
| rgpChain : ^PCERT_SIMPLE_CHAIN, | |
| cLowerQualityChainContext : DWORD, | |
| rgpLowerQualityChainContext : ^PCCERT_CHAIN_CONTEXT, | |
| fHasRevocationFreshnessTime : BOOL, | |
| dwRevocationFreshnessTime : DWORD, | |
| dwCreateFlags : DWORD, | |
| ChainId : GUID, | |
| }; | |
| CERT_USAGE_MATCH :: struct { | |
| dwType : DWORD, | |
| Usage : CERT_ENHKEY_USAGE, | |
| }; | |
| PCERT_USAGE_MATCH :: ^CERT_USAGE_MATCH; | |
| CTL_USAGE_MATCH :: struct { | |
| dwType : DWORD, | |
| Usage : CTL_USAGE, | |
| }; | |
| PCTL_USAGE_MATCH :: ^CTL_USAGE_MATCH; | |
| CERT_CHAIN_PARA :: struct { | |
| cbSize : DWORD, | |
| RequestedUsage : CERT_USAGE_MATCH, | |
| }; | |
| PCERT_CHAIN_PARA :: ^CERT_CHAIN_PARA; | |
| CERT_REVOCATION_CHAIN_PARA :: struct { | |
| cbSize : DWORD, | |
| hChainEngine : HCERTCHAINENGINE, | |
| hAdditionalStore : HCERTSTORE, | |
| dwChainFlags : DWORD, | |
| dwUrlRetrievalTimeout : DWORD, | |
| pftCurrentTime : LPFILETIME, | |
| pftCacheResync : LPFILETIME, | |
| cbMaxUrlRetrievalByteCount : DWORD, | |
| }; | |
| CRL_REVOCATION_INFO :: struct { | |
| pCrlEntry : PCRL_ENTRY, | |
| pCrlContext : PCCRL_CONTEXT, | |
| pCrlIssuerChain : PCCERT_CHAIN_CONTEXT, | |
| }; | |
| PCRL_REVOCATION_INFO :: ^CRL_REVOCATION_INFO; | |
| PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK :: (proc "stdcall" (pCert : PCCERT_CONTEXT, pvFindArg : rawptr) -> BOOL); | |
| CERT_CHAIN_FIND_ISSUER_PARA :: struct { | |
| cbSize : DWORD, | |
| pszUsageIdentifier : LPCSTR, | |
| dwKeySpec : DWORD, | |
| dwAcquirePrivateKeyFlags : DWORD, | |
| cIssuer : DWORD, | |
| rgIssuer : ^CERT_NAME_BLOB, | |
| pfnFindCallback : PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK, | |
| pvFindArg : rawptr, | |
| }; | |
| PCERT_CHAIN_FIND_ISSUER_PARA :: ^CERT_CHAIN_FIND_ISSUER_PARA; | |
| CERT_CHAIN_FIND_BY_ISSUER_PARA :: struct { | |
| cbSize : DWORD, | |
| pszUsageIdentifier : LPCSTR, | |
| dwKeySpec : DWORD, | |
| dwAcquirePrivateKeyFlags : DWORD, | |
| cIssuer : DWORD, | |
| rgIssuer : ^CERT_NAME_BLOB, | |
| pfnFindCallback : PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK, | |
| pvFindArg : rawptr, | |
| }; | |
| PCERT_CHAIN_FIND_BY_ISSUER_PARA :: ^CERT_CHAIN_FIND_BY_ISSUER_PARA; | |
| CERT_CHAIN_POLICY_PARA :: struct { | |
| cbSize : DWORD, | |
| dwFlags : DWORD, | |
| pvExtraPolicyPara : rawptr, | |
| }; | |
| PCERT_CHAIN_POLICY_PARA :: ^CERT_CHAIN_POLICY_PARA; | |
| CERT_CHAIN_POLICY_STATUS :: struct { | |
| cbSize : DWORD, | |
| dwError : DWORD, | |
| lChainIndex : LONG, | |
| lElementIndex : LONG, | |
| pvExtraPolicyStatus : rawptr, | |
| }; | |
| PCERT_CHAIN_POLICY_STATUS :: ^CERT_CHAIN_POLICY_STATUS; | |
| AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA :: struct { | |
| cbSize : DWORD, | |
| dwRegPolicySettings : DWORD, | |
| pSignerInfo : PCMSG_SIGNER_INFO, | |
| }; | |
| PAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA :: ^AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA; | |
| AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct { | |
| cbSize : DWORD, | |
| fCommercial : BOOL, | |
| }; | |
| PAUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS; | |
| AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA :: struct { | |
| cbSize : DWORD, | |
| dwRegPolicySettings : DWORD, | |
| fCommercial : BOOL, | |
| }; | |
| PAUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA :: ^AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA; | |
| HTTPSPolicyCallbackData :: struct { | |
| u : struct #raw_union { | |
| cbStruct : DWORD, | |
| cbSize : DWORD, | |
| }, | |
| dwAuthType : DWORD, | |
| fdwChecks : DWORD, | |
| pwszServerName : ^WCHAR, | |
| }; | |
| PHTTPSPolicyCallbackData :: ^HTTPSPolicyCallbackData; | |
| SSL_EXTRA_CERT_CHAIN_POLICY_PARA :: struct { | |
| u : struct #raw_union { | |
| cbStruct : DWORD, | |
| cbSize : DWORD, | |
| }, | |
| dwAuthType : DWORD, | |
| fdwChecks : DWORD, | |
| pwszServerName : ^WCHAR, | |
| }; | |
| PSSL_EXTRA_CERT_CHAIN_POLICY_PARA :: ^SSL_EXTRA_CERT_CHAIN_POLICY_PARA; | |
| EV_EXTRA_CERT_CHAIN_POLICY_PARA :: struct { | |
| cbSize : DWORD, | |
| dwRootProgramQualifierFlags : DWORD, | |
| }; | |
| PEV_EXTRA_CERT_CHAIN_POLICY_PARA :: ^EV_EXTRA_CERT_CHAIN_POLICY_PARA; | |
| EV_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct { | |
| cbSize : DWORD, | |
| dwQualifiers : DWORD, | |
| dwIssuanceUsageIndex : DWORD, | |
| }; | |
| PEV_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^EV_EXTRA_CERT_CHAIN_POLICY_STATUS; | |
| SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct { | |
| cbSize : DWORD, | |
| dwErrorLevel : DWORD, | |
| dwErrorCategory : DWORD, | |
| dwReserved : DWORD, | |
| wszErrorText : [256]WCHAR, | |
| }; | |
| PSSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^SSL_F12_EXTRA_CERT_CHAIN_POLICY_STATUS; | |
| SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA :: struct { | |
| cbSize : DWORD, | |
| dwReserved : DWORD, | |
| pwszServerName : LPWSTR, | |
| rgpszHpkpValue : [2]LPSTR, | |
| }; | |
| PSSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA :: ^SSL_HPKP_HEADER_EXTRA_CERT_CHAIN_POLICY_PARA; | |
| SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA :: struct { | |
| cbSize : DWORD, | |
| dwReserved : DWORD, | |
| pwszServerName : PCWSTR, | |
| }; | |
| PSSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA :: ^SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_PARA; | |
| SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS :: struct { | |
| cbSize : DWORD, | |
| lError : LONG, | |
| wszErrorText : [512]WCHAR, | |
| }; | |
| PSSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS :: ^SSL_KEY_PIN_EXTRA_CERT_CHAIN_POLICY_STATUS; | |
| CRYPT_PKCS12_PBE_PARAMS :: struct { | |
| iIterations : _c.int, | |
| cbSalt : ULONG, | |
| }; | |
| PKCS12_PBES2_EXPORT_PARAMS :: struct { | |
| dwSize : DWORD, | |
| hNcryptDescriptor : PVOID, | |
| pwszPbes2Alg : LPWSTR, | |
| }; | |
| PPKCS12_PBES2_EXPORT_PARAMS :: ^PKCS12_PBES2_EXPORT_PARAMS; | |
| HCERT_SERVER_OCSP_RESPONSE :: rawptr; | |
| PCERT_SERVER_OCSP_RESPONSE_CONTEXT :: ^CERT_SERVER_OCSP_RESPONSE_CONTEXT; | |
| PCCERT_SERVER_OCSP_RESPONSE_CONTEXT :: ^CERT_SERVER_OCSP_RESPONSE_CONTEXT; | |
| CERT_SERVER_OCSP_RESPONSE_CONTEXT :: struct { | |
| cbSize : DWORD, | |
| pbEncodedOcspResponse : ^BYTE, | |
| cbEncodedOcspResponse : DWORD, | |
| }; | |
| PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK :: proc "stdcall" (pChainContext : PCCERT_CHAIN_CONTEXT, pServerOcspResponseContext : PCCERT_SERVER_OCSP_RESPONSE_CONTEXT, pNewCrlContext : PCCRL_CONTEXT, pPrevCrlContext : PCCRL_CONTEXT, pvArg : PVOID, dwWriteOcspFileError : DWORD); | |
| CERT_SERVER_OCSP_RESPONSE_OPEN_PARA :: struct { | |
| cbSize : DWORD, | |
| dwFlags : DWORD, | |
| pcbUsedSize : ^DWORD, | |
| pwszOcspDirectory : PWSTR, | |
| pfnUpdateCallback : PFN_CERT_SERVER_OCSP_RESPONSE_UPDATE_CALLBACK, | |
| pvUpdateCallbackArg : PVOID, | |
| }; | |
| PCERT_SERVER_OCSP_RESPONSE_OPEN_PARA :: ^CERT_SERVER_OCSP_RESPONSE_OPEN_PARA; | |
| CERT_SELECT_CHAIN_PARA :: struct { | |
| hChainEngine : HCERTCHAINENGINE, | |
| pTime : PFILETIME, | |
| hAdditionalStore : HCERTSTORE, | |
| pChainPara : PCERT_CHAIN_PARA, | |
| dwFlags : DWORD, | |
| }; | |
| PCERT_SELECT_CHAIN_PARA :: ^CERT_SELECT_CHAIN_PARA; | |
| PCCERT_SELECT_CHAIN_PARA :: ^CERT_SELECT_CHAIN_PARA; | |
| CERT_SELECT_CRITERIA :: struct { | |
| dwType : DWORD, | |
| cPara : DWORD, | |
| ppPara : ^rawptr, | |
| }; | |
| PCERT_SELECT_CRITERIA :: ^CERT_SELECT_CRITERIA; | |
| PCCERT_SELECT_CRITERIA :: ^CERT_SELECT_CRITERIA; | |
| CRYPT_TIMESTAMP_REQUEST :: struct { | |
| dwVersion : DWORD, | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| HashedMessage : CRYPT_DER_BLOB, | |
| pszTSAPolicyId : LPSTR, | |
| Nonce : CRYPT_INTEGER_BLOB, | |
| fCertReq : BOOL, | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| PCRYPT_TIMESTAMP_REQUEST :: ^CRYPT_TIMESTAMP_REQUEST; | |
| CRYPT_TIMESTAMP_RESPONSE :: struct { | |
| dwStatus : DWORD, | |
| cFreeText : DWORD, | |
| rgFreeText : ^LPWSTR, | |
| FailureInfo : CRYPT_BIT_BLOB, | |
| ContentInfo : CRYPT_DER_BLOB, | |
| }; | |
| PCRYPT_TIMESTAMP_RESPONSE :: ^CRYPT_TIMESTAMP_RESPONSE; | |
| CRYPT_TIMESTAMP_ACCURACY :: struct { | |
| dwSeconds : DWORD, | |
| dwMillis : DWORD, | |
| dwMicros : DWORD, | |
| }; | |
| PCRYPT_TIMESTAMP_ACCURACY :: ^CRYPT_TIMESTAMP_ACCURACY; | |
| CRYPT_TIMESTAMP_INFO :: struct { | |
| dwVersion : DWORD, | |
| pszTSAPolicyId : LPSTR, | |
| HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER, | |
| HashedMessage : CRYPT_DER_BLOB, | |
| SerialNumber : CRYPT_INTEGER_BLOB, | |
| ftTime : FILETIME, | |
| pvAccuracy : PCRYPT_TIMESTAMP_ACCURACY, | |
| fOrdering : BOOL, | |
| Nonce : CRYPT_DER_BLOB, | |
| Tsa : CRYPT_DER_BLOB, | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| PCRYPT_TIMESTAMP_INFO :: ^CRYPT_TIMESTAMP_INFO; | |
| CRYPT_TIMESTAMP_CONTEXT :: struct { | |
| cbEncoded : DWORD, | |
| pbEncoded : ^BYTE, | |
| pTimeStamp : PCRYPT_TIMESTAMP_INFO, | |
| }; | |
| PCRYPT_TIMESTAMP_CONTEXT :: ^CRYPT_TIMESTAMP_CONTEXT; | |
| CRYPT_TIMESTAMP_PARA :: struct { | |
| pszTSAPolicyId : LPCSTR, | |
| fRequestCerts : BOOL, | |
| Nonce : CRYPT_INTEGER_BLOB, | |
| cExtension : DWORD, | |
| rgExtension : PCERT_EXTENSION, | |
| }; | |
| PCRYPT_TIMESTAMP_PARA :: ^CRYPT_TIMESTAMP_PARA; | |
| PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH :: (proc "stdcall" (pContext : LPVOID, rgIdentifierOrNameList : ^PCERT_NAME_BLOB, dwIdentifierOrNameListCount : DWORD) -> BOOL); | |
| PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET :: (proc "stdcall" (pPluginContext : LPVOID, pIdentifier : PCRYPT_DATA_BLOB, dwNameType : DWORD, pNameBlob : PCERT_NAME_BLOB, ppbContent : ^PBYTE, pcbContent : ^DWORD, ppwszPassword : ^PCWSTR, ppIdentifier : ^PCRYPT_DATA_BLOB) -> BOOL); | |
| PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE :: proc "stdcall" (dwReason : DWORD, pPluginContext : LPVOID); | |
| PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD :: proc "stdcall" (pPluginContext : LPVOID, pwszPassword : PCWSTR); | |
| PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE :: proc "stdcall" (pPluginContext : LPVOID, pbData : PBYTE); | |
| PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER :: proc "stdcall" (pPluginContext : LPVOID, pIdentifier : PCRYPT_DATA_BLOB); | |
| CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE :: struct { | |
| cbSize : DWORD, | |
| pfnGet : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_GET, | |
| pfnRelease : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_RELEASE, | |
| pfnFreePassword : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_PASSWORD, | |
| pfnFree : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE, | |
| pfnFreeIdentifier : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FREE_IDENTIFIER, | |
| }; | |
| PCRYPT_OBJECT_LOCATOR_PROVIDER_TABLE :: ^CRYPT_OBJECT_LOCATOR_PROVIDER_TABLE; | |
| PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_INITIALIZE :: (proc "stdcall" (pfnFlush : PFN_CRYPT_OBJECT_LOCATOR_PROVIDER_FLUSH, pContext : LPVOID, pdwExpectedObjectCount : ^DWORD, ppFuncTable : ^PCRYPT_OBJECT_LOCATOR_PROVIDER_TABLE, ppPluginContext : ^rawptr) -> BOOL); | |
| PFN_CERT_IS_WEAK_HASH :: (proc "stdcall" (dwHashUseType : DWORD, pwszCNGHashAlgid : LPCWSTR, dwChainFlags : DWORD, pSignerChainContext : PCCERT_CHAIN_CONTEXT, pTimeStamp : LPFILETIME, pwszFileName : LPCWSTR) -> BOOL); | |
| CRYPTPROTECT_PROMPTSTRUCT :: struct { | |
| cbSize : DWORD, | |
| dwPromptFlags : DWORD, | |
| hwndApp : HWND, | |
| szPrompt : LPCWSTR, | |
| }; | |
| PCRYPTPROTECT_PROMPTSTRUCT :: ^CRYPTPROTECT_PROMPTSTRUCT; | |
| EFS_CERTIFICATE_BLOB :: struct { | |
| dwCertEncodingType : DWORD, | |
| cbData : DWORD, | |
| pbData : PBYTE, | |
| }; | |
| PEFS_CERTIFICATE_BLOB :: ^EFS_CERTIFICATE_BLOB; | |
| EFS_HASH_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : PBYTE, | |
| }; | |
| PEFS_HASH_BLOB :: ^EFS_HASH_BLOB; | |
| EFS_RPC_BLOB :: struct { | |
| cbData : DWORD, | |
| pbData : PBYTE, | |
| }; | |
| PEFS_RPC_BLOB :: ^EFS_RPC_BLOB; | |
| EFS_PIN_BLOB :: struct { | |
| cbPadding : DWORD, | |
| cbData : DWORD, | |
| pbData : PBYTE, | |
| }; | |
| PEFS_PIN_BLOB :: ^EFS_PIN_BLOB; | |
| EFS_KEY_INFO :: struct { | |
| dwVersion : DWORD, | |
| Entropy : ULONG, | |
| Algorithm : ALG_ID, | |
| KeyLength : ULONG, | |
| }; | |
| PEFS_KEY_INFO :: ^EFS_KEY_INFO; | |
| EFS_COMPATIBILITY_INFO :: struct { | |
| EfsVersion : DWORD, | |
| }; | |
| PEFS_COMPATIBILITY_INFO :: ^EFS_COMPATIBILITY_INFO; | |
| EFS_VERSION_INFO :: struct { | |
| EfsVersion : DWORD, | |
| SubVersion : DWORD, | |
| }; | |
| PEFS_VERSION_INFO :: ^EFS_VERSION_INFO; | |
| EFS_DECRYPTION_STATUS_INFO :: struct { | |
| dwDecryptionError : DWORD, | |
| dwHashOffset : DWORD, | |
| cbHash : DWORD, | |
| }; | |
| PEFS_DECRYPTION_STATUS_INFO :: ^EFS_DECRYPTION_STATUS_INFO; | |
| EFS_ENCRYPTION_STATUS_INFO :: struct { | |
| bHasCurrentKey : BOOL, | |
| dwEncryptionError : DWORD, | |
| }; | |
| PEFS_ENCRYPTION_STATUS_INFO :: ^EFS_ENCRYPTION_STATUS_INFO; | |
| ENCRYPTION_CERTIFICATE :: struct { | |
| cbTotalLength : DWORD, | |
| pUserSid : ^SID, | |
| pCertBlob : PEFS_CERTIFICATE_BLOB, | |
| }; | |
| PENCRYPTION_CERTIFICATE :: ^ENCRYPTION_CERTIFICATE; | |
| ENCRYPTION_CERTIFICATE_HASH :: struct { | |
| cbTotalLength : DWORD, | |
| pUserSid : ^SID, | |
| pHash : PEFS_HASH_BLOB, | |
| lpDisplayInformation : LPWSTR, | |
| }; | |
| PENCRYPTION_CERTIFICATE_HASH :: ^ENCRYPTION_CERTIFICATE_HASH; | |
| ENCRYPTION_CERTIFICATE_HASH_LIST :: struct { | |
| nCert_Hash : DWORD, | |
| pUsers : ^PENCRYPTION_CERTIFICATE_HASH, | |
| }; | |
| PENCRYPTION_CERTIFICATE_HASH_LIST :: ^ENCRYPTION_CERTIFICATE_HASH_LIST; | |
| ENCRYPTION_CERTIFICATE_LIST :: struct { | |
| nUsers : DWORD, | |
| pUsers : ^PENCRYPTION_CERTIFICATE, | |
| }; | |
| PENCRYPTION_CERTIFICATE_LIST :: ^ENCRYPTION_CERTIFICATE_LIST; | |
| ENCRYPTED_FILE_METADATA_SIGNATURE :: struct { | |
| dwEfsAccessType : DWORD, | |
| pCertificatesAdded : PENCRYPTION_CERTIFICATE_HASH_LIST, | |
| pEncryptionCertificate : PENCRYPTION_CERTIFICATE, | |
| pEfsStreamSignature : PEFS_RPC_BLOB, | |
| }; | |
| PENCRYPTED_FILE_METADATA_SIGNATURE :: ^ENCRYPTED_FILE_METADATA_SIGNATURE; | |
| ENCRYPTION_PROTECTOR :: struct { | |
| cbTotalLength : DWORD, | |
| pUserSid : ^SID, | |
| lpProtectorDescriptor : LPWSTR, | |
| }; | |
| PENCRYPTION_PROTECTOR :: ^ENCRYPTION_PROTECTOR; | |
| ENCRYPTION_PROTECTOR_LIST :: struct { | |
| nProtectors : DWORD, | |
| pProtectors : ^PENCRYPTION_PROTECTOR, | |
| }; | |
| PENCRYPTION_PROTECTOR_LIST :: ^ENCRYPTION_PROTECTOR_LIST; | |
| RPC_IMPORT_CONTEXT_P :: struct { | |
| LookupContext : RPC_NS_HANDLE, | |
| ProposedHandle : RPC_BINDING_HANDLE, | |
| Bindings : ^RPC_BINDING_VECTOR, | |
| }; | |
| PRPC_IMPORT_CONTEXT_P :: ^RPC_IMPORT_CONTEXT_P; | |
| byte :: _c.uchar; | |
| cs_byte :: byte; | |
| boolean :: _c.uchar; | |
| NDR_CCONTEXT :: rawptr; | |
| NDR_SCONTEXT :: ^struct { | |
| pad : [2]rawptr, | |
| userContext : rawptr, | |
| }; | |
| NDR_RUNDOWN :: proc "stdcall" (context_ : rawptr); | |
| NDR_NOTIFY_ROUTINE :: proc "stdcall" (); | |
| NDR_NOTIFY2_ROUTINE :: proc "stdcall" (flag : boolean); | |
| SCONTEXT_QUEUE :: struct { | |
| NumberOfObjects : _c.ulong, | |
| ArrayOfObjects : ^NDR_SCONTEXT, | |
| }; | |
| PSCONTEXT_QUEUE :: ^SCONTEXT_QUEUE; | |
| error_status_t :: _c.ulong; | |
| RPC_BUFPTR :: ^_c.uchar; | |
| RPC_LENGTH :: _c.ulong; | |
| EXPR_EVAL :: proc "stdcall" (^MIDL_STUB_MESSAGE); | |
| PFORMAT_STRING :: ^_c.uchar; | |
| ARRAY_INFO :: struct { | |
| Dimension : _c.long, | |
| BufferConformanceMark : ^_c.ulong, | |
| BufferVarianceMark : ^_c.ulong, | |
| MaxCountArray : ^_c.ulong, | |
| OffsetArray : ^_c.ulong, | |
| ActualCountArray : ^_c.ulong, | |
| }; | |
| PARRAY_INFO :: ^ARRAY_INFO; | |
| PNDR_ASYNC_MESSAGE :: ^_NDR_ASYNC_MESSAGE; | |
| PNDR_CORRELATION_INFO :: ^_NDR_CORRELATION_INFO; | |
| ; | |
| PMIDL_SYNTAX_INFO :: ^MIDL_SYNTAX_INFO; | |
| NDR_ALLOC_ALL_NODES_CONTEXT :: struct {}; | |
| NDR_POINTER_QUEUE_STATE :: struct {}; | |
| _NDR_PROC_CONTEXT :: struct {}; | |
| MIDL_STUB_MESSAGE :: struct { | |
| RpcMsg : PRPC_MESSAGE, | |
| Buffer : ^_c.uchar, | |
| BufferStart : ^_c.uchar, | |
| BufferEnd : ^_c.uchar, | |
| BufferMark : ^_c.uchar, | |
| BufferLength : _c.ulong, | |
| MemorySize : _c.ulong, | |
| Memory : ^_c.uchar, | |
| IsClient : _c.uchar, | |
| Pad : _c.uchar, | |
| uFlags2 : _c.ushort, | |
| ReuseBuffer : _c.int, | |
| pAllocAllNodesContext : ^NDR_ALLOC_ALL_NODES_CONTEXT, | |
| pPointerQueueState : ^NDR_POINTER_QUEUE_STATE, | |
| IgnoreEmbeddedPointers : _c.int, | |
| PointerBufferMark : ^_c.uchar, | |
| CorrDespIncrement : _c.uchar, | |
| uFlags : _c.uchar, | |
| UniquePtrCount : _c.ushort, | |
| MaxCount : ULONG_PTR, | |
| Offset : _c.ulong, | |
| ActualCount : _c.ulong, | |
| pfnAllocate : (proc "stdcall" (_c.size_t) -> rawptr), | |
| pfnFree : proc "stdcall" (rawptr), | |
| StackTop : ^_c.uchar, | |
| pPresentedType : ^_c.uchar, | |
| pTransmitType : ^_c.uchar, | |
| SavedHandle : handle_t, | |
| StubDesc : ^MIDL_STUB_DESC, | |
| FullPtrXlatTables : ^FULL_PTR_XLAT_TABLES, | |
| FullPtrRefId : _c.ulong, | |
| PointerLength : _c.ulong, | |
| using _ : bit_field { | |
| fInDontFree : 1, | |
| fDontCallFreeInst : 1, | |
| fUnused1 : 1, | |
| fHasReturn : 1, | |
| fHasExtensions : 1, | |
| fHasNewCorrDesc : 1, | |
| fIsIn : 1, | |
| fIsOut : 1, | |
| fIsOicf : 1, | |
| fBufferValid : 1, | |
| fHasMemoryValidateCallback : 1, | |
| fInFree : 1, | |
| fNeedMCCP : 1, | |
| fUnused2 : 3, | |
| fUnused3 : 16, | |
| }, | |
| dwDestContext : _c.ulong, | |
| pvDestContext : rawptr, | |
| SavedContextHandles : ^NDR_SCONTEXT, | |
| ParamNumber : _c.long, | |
| pRpcChannelBuffer : ^IRpcChannelBuffer, | |
| pArrayInfo : PARRAY_INFO, | |
| SizePtrCountArray : ^_c.ulong, | |
| SizePtrOffsetArray : ^_c.ulong, | |
| SizePtrLengthArray : ^_c.ulong, | |
| pArgQueue : rawptr, | |
| dwStubPhase : _c.ulong, | |
| LowStackMark : rawptr, | |
| pAsyncMsg : PNDR_ASYNC_MESSAGE, | |
| pCorrInfo : PNDR_CORRELATION_INFO, | |
| pCorrMemory : ^_c.uchar, | |
| pMemoryList : rawptr, | |
| pCSInfo : INT_PTR, | |
| ConformanceMark : ^_c.uchar, | |
| VarianceMark : ^_c.uchar, | |
| Unused : INT_PTR, | |
| pContext : ^_NDR_PROC_CONTEXT, | |
| ContextHandleHash : rawptr, | |
| pUserMarshalList : rawptr, | |
| Reserved51_3 : INT_PTR, | |
| Reserved51_4 : INT_PTR, | |
| Reserved51_5 : INT_PTR, | |
| }; | |
| PMIDL_STUB_MESSAGE :: ^MIDL_STUB_MESSAGE; | |
| ; | |
| GENERIC_BINDING_ROUTINE :: (proc "stdcall" (rawptr) -> rawptr); | |
| GENERIC_UNBIND_ROUTINE :: proc "stdcall" (rawptr, ^_c.uchar); | |
| GENERIC_BINDING_ROUTINE_PAIR :: struct { | |
| pfnBind : GENERIC_BINDING_ROUTINE, | |
| pfnUnbind : GENERIC_UNBIND_ROUTINE, | |
| }; | |
| PGENERIC_BINDING_ROUTINE_PAIR :: ^GENERIC_BINDING_ROUTINE_PAIR; | |
| GENERIC_BINDING_INFO :: struct { | |
| pObj : rawptr, | |
| Size : _c.uint, | |
| pfnBind : GENERIC_BINDING_ROUTINE, | |
| pfnUnbind : GENERIC_UNBIND_ROUTINE, | |
| }; | |
| PGENERIC_BINDING_INFO :: ^GENERIC_BINDING_INFO; | |
| XMIT_HELPER_ROUTINE :: proc "stdcall" (PMIDL_STUB_MESSAGE); | |
| XMIT_ROUTINE_QUINTUPLE :: struct { | |
| pfnTranslateToXmit : XMIT_HELPER_ROUTINE, | |
| pfnTranslateFromXmit : XMIT_HELPER_ROUTINE, | |
| pfnFreeXmit : XMIT_HELPER_ROUTINE, | |
| pfnFreeInst : XMIT_HELPER_ROUTINE, | |
| }; | |
| PXMIT_ROUTINE_QUINTUPLE :: ^XMIT_ROUTINE_QUINTUPLE; | |
| USER_MARSHAL_SIZING_ROUTINE :: (proc "stdcall" (^_c.ulong, _c.ulong, rawptr) -> _c.ulong); | |
| USER_MARSHAL_MARSHALLING_ROUTINE :: (proc "stdcall" (^_c.ulong, ^_c.uchar, rawptr) -> ^_c.uchar); | |
| USER_MARSHAL_UNMARSHALLING_ROUTINE :: (proc "stdcall" (^_c.ulong, ^_c.uchar, rawptr) -> ^_c.uchar); | |
| USER_MARSHAL_FREEING_ROUTINE :: proc "stdcall" (^_c.ulong, rawptr); | |
| USER_MARSHAL_ROUTINE_QUADRUPLE :: struct { | |
| pfnBufferSize : USER_MARSHAL_SIZING_ROUTINE, | |
| pfnMarshall : USER_MARSHAL_MARSHALLING_ROUTINE, | |
| pfnUnmarshall : USER_MARSHAL_UNMARSHALLING_ROUTINE, | |
| pfnFree : USER_MARSHAL_FREEING_ROUTINE, | |
| }; | |
| /* USER_MARSHAL_CB_TYPE :: enum { */ | |
| USER_MARSHAL_CB_TYPE :: _c.int; | |
| USER_MARSHAL_CB_BUFFER_SIZE :: 0; | |
| USER_MARSHAL_CB_MARSHALL :: USER_MARSHAL_CB_BUFFER_SIZE + 1; | |
| USER_MARSHAL_CB_UNMARSHALL :: USER_MARSHAL_CB_MARSHALL + 1; | |
| USER_MARSHAL_CB_FREE :: USER_MARSHAL_CB_UNMARSHALL + 1; | |
| /* } */ | |
| ; | |
| USER_MARSHAL_CB :: struct { | |
| Flags : _c.ulong, | |
| pStubMsg : PMIDL_STUB_MESSAGE, | |
| pReserve : PFORMAT_STRING, | |
| Signature : _c.ulong, | |
| CBType : USER_MARSHAL_CB_TYPE, | |
| pFormat : PFORMAT_STRING, | |
| pTypeFormat : PFORMAT_STRING, | |
| }; | |
| MALLOC_FREE_STRUCT :: struct { | |
| pfnAllocate : (proc "stdcall" (_c.size_t) -> rawptr), | |
| pfnFree : proc "stdcall" (rawptr), | |
| }; | |
| COMM_FAULT_OFFSETS :: struct { | |
| CommOffset : _c.short, | |
| FaultOffset : _c.short, | |
| }; | |
| /* IDL_CS_CONVERT :: enum { */ | |
| IDL_CS_CONVERT :: _c.int; | |
| IDL_CS_NO_CONVERT :: 0; | |
| IDL_CS_IN_PLACE_CONVERT :: IDL_CS_NO_CONVERT + 1; | |
| IDL_CS_NEW_BUFFER_CONVERT :: IDL_CS_IN_PLACE_CONVERT + 1; | |
| /* } */ | |
| ; | |
| CS_TYPE_NET_SIZE_ROUTINE :: proc "stdcall" (hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : _c.ulong, ulLocalBufferSize : _c.ulong, conversionType : ^IDL_CS_CONVERT, pulNetworkBufferSize : ^_c.ulong, pStatus : ^error_status_t); | |
| CS_TYPE_LOCAL_SIZE_ROUTINE :: proc "stdcall" (hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : _c.ulong, ulNetworkBufferSize : _c.ulong, conversionType : ^IDL_CS_CONVERT, pulLocalBufferSize : ^_c.ulong, pStatus : ^error_status_t); | |
| CS_TYPE_TO_NETCS_ROUTINE :: proc "stdcall" (hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : _c.ulong, pLocalData : rawptr, ulLocalDataLength : _c.ulong, pNetworkData : ^byte, pulNetworkDataLength : ^_c.ulong, pStatus : ^error_status_t); | |
| CS_TYPE_FROM_NETCS_ROUTINE :: proc "stdcall" (hBinding : RPC_BINDING_HANDLE, ulNetworkCodeSet : _c.ulong, pNetworkData : ^byte, ulNetworkDataLength : _c.ulong, ulLocalBufferSize : _c.ulong, pLocalData : rawptr, pulLocalDataLength : ^_c.ulong, pStatus : ^error_status_t); | |
| CS_TAG_GETTING_ROUTINE :: proc "stdcall" (hBinding : RPC_BINDING_HANDLE, fServerSide : _c.int, pulSendingTag : ^_c.ulong, pulDesiredReceivingTag : ^_c.ulong, pulReceivingTag : ^_c.ulong, pStatus : ^error_status_t); | |
| NDR_CS_SIZE_CONVERT_ROUTINES :: struct { | |
| pfnNetSize : CS_TYPE_NET_SIZE_ROUTINE, | |
| pfnToNetCs : CS_TYPE_TO_NETCS_ROUTINE, | |
| pfnLocalSize : CS_TYPE_LOCAL_SIZE_ROUTINE, | |
| pfnFromNetCs : CS_TYPE_FROM_NETCS_ROUTINE, | |
| }; | |
| NDR_CS_ROUTINES :: struct { | |
| pSizeConvertRoutines : ^NDR_CS_SIZE_CONVERT_ROUTINES, | |
| pTagGettingRoutines : ^CS_TAG_GETTING_ROUTINE, | |
| }; | |
| NDR_EXPR_DESC :: struct { | |
| pOffset : ^_c.ushort, | |
| pFormatExpr : PFORMAT_STRING, | |
| }; | |
| MIDL_STUB_DESC :: struct { | |
| RpcInterfaceInformation : rawptr, | |
| pfnAllocate : (proc "stdcall" (_c.size_t) -> rawptr), | |
| pfnFree : proc "stdcall" (rawptr), | |
| IMPLICIT_HANDLE_INFO : struct #raw_union { | |
| pAutoHandle : ^handle_t, | |
| pPrimitiveHandle : ^handle_t, | |
| pGenericBindingInfo : PGENERIC_BINDING_INFO, | |
| }, | |
| apfnNdrRundownRoutines : ^NDR_RUNDOWN, | |
| aGenericBindingRoutinePairs : ^GENERIC_BINDING_ROUTINE_PAIR, | |
| apfnExprEval : ^EXPR_EVAL, | |
| aXmitQuintuple : ^XMIT_ROUTINE_QUINTUPLE, | |
| pFormatTypes : ^_c.uchar, | |
| fCheckBounds : _c.int, | |
| Version : _c.ulong, | |
| pMallocFreeStruct : ^MALLOC_FREE_STRUCT, | |
| MIDLVersion : _c.long, | |
| CommFaultOffsets : ^COMM_FAULT_OFFSETS, | |
| aUserMarshalQuadruple : ^USER_MARSHAL_ROUTINE_QUADRUPLE, | |
| NotifyRoutineTable : ^NDR_NOTIFY_ROUTINE, | |
| mFlags : ULONG_PTR, | |
| CsRoutineTables : ^NDR_CS_ROUTINES, | |
| ProxyServerInfo : rawptr, | |
| pExprInfo : ^NDR_EXPR_DESC, | |
| }; | |
| PMIDL_STUB_DESC :: ^MIDL_STUB_DESC; | |
| PMIDL_XMIT_TYPE :: rawptr; | |
| STUB_THUNK :: proc "stdcall" (PMIDL_STUB_MESSAGE); | |
| SERVER_ROUTINE :: (proc "stdcall" () -> _c.long); | |
| MIDL_METHOD_PROPERTY :: struct { | |
| Id : _c.ulong, | |
| Value : ULONG_PTR, | |
| }; | |
| PMIDL_METHOD_PROPERTY :: ^MIDL_METHOD_PROPERTY; | |
| MIDL_METHOD_PROPERTY_MAP :: struct { | |
| Count : _c.ulong, | |
| Properties : ^MIDL_METHOD_PROPERTY, | |
| }; | |
| PMIDL_METHOD_PROPERTY_MAP :: ^MIDL_METHOD_PROPERTY_MAP; | |
| MIDL_INTERFACE_METHOD_PROPERTIES :: struct { | |
| MethodCount : _c.ushort, | |
| MethodProperties : ^^MIDL_METHOD_PROPERTY_MAP, | |
| }; | |
| MIDL_SERVER_INFO :: struct { | |
| pStubDesc : PMIDL_STUB_DESC, | |
| DispatchTable : ^SERVER_ROUTINE, | |
| ProcString : PFORMAT_STRING, | |
| FmtStringOffset : ^_c.ushort, | |
| ThunkTable : ^STUB_THUNK, | |
| pTransferSyntax : PRPC_SYNTAX_IDENTIFIER, | |
| nCount : ULONG_PTR, | |
| pSyntaxInfo : PMIDL_SYNTAX_INFO, | |
| }; | |
| PMIDL_SERVER_INFO :: ^MIDL_SERVER_INFO; | |
| MIDL_STUBLESS_PROXY_INFO :: struct { | |
| pStubDesc : PMIDL_STUB_DESC, | |
| ProcFormatString : PFORMAT_STRING, | |
| FormatStringOffset : ^_c.ushort, | |
| pTransferSyntax : PRPC_SYNTAX_IDENTIFIER, | |
| nCount : ULONG_PTR, | |
| pSyntaxInfo : PMIDL_SYNTAX_INFO, | |
| }; | |
| PMIDL_STUBLESS_PROXY_INFO :: ^MIDL_STUBLESS_PROXY_INFO; | |
| MIDL_SYNTAX_INFO :: struct { | |
| TransferSyntax : RPC_SYNTAX_IDENTIFIER, | |
| DispatchTable : ^RPC_DISPATCH_TABLE, | |
| ProcString : PFORMAT_STRING, | |
| FmtStringOffset : ^_c.ushort, | |
| TypeString : PFORMAT_STRING, | |
| aUserMarshalQuadruple : rawptr, | |
| pMethodProperties : ^MIDL_INTERFACE_METHOD_PROPERTIES, | |
| pReserved2 : ULONG_PTR, | |
| }; | |
| ; | |
| PARAM_OFFSETTABLE :: ^_c.ushort; | |
| PPARAM_OFFSETTABLE :: ^_c.ushort; | |
| CLIENT_CALL_RETURN :: struct #raw_union { | |
| Pointer : rawptr, | |
| Simple : LONG_PTR, | |
| }; | |
| /* XLAT_SIDE :: enum { */ | |
| XLAT_SIDE :: _c.int; | |
| XLAT_SERVER :: 1; | |
| XLAT_CLIENT :: XLAT_SERVER + 1; | |
| /* } */ | |
| ; | |
| FULL_PTR_XLAT_TABLES :: struct { | |
| RefIdToPointer : rawptr, | |
| PointerToRefId : rawptr, | |
| NextRefId : _c.ulong, | |
| XlatSide : XLAT_SIDE, | |
| }; | |
| PFULL_PTR_XLAT_TABLES :: ^FULL_PTR_XLAT_TABLES; | |
| /* system_handle_t :: enum { */ | |
| system_handle_t :: _c.int; | |
| SYSTEM_HANDLE_FILE :: 0; | |
| SYSTEM_HANDLE_SEMAPHORE :: 1; | |
| SYSTEM_HANDLE_EVENT :: 2; | |
| SYSTEM_HANDLE_MUTEX :: 3; | |
| SYSTEM_HANDLE_PROCESS :: 4; | |
| SYSTEM_HANDLE_TOKEN :: 5; | |
| SYSTEM_HANDLE_SECTION :: 6; | |
| SYSTEM_HANDLE_REG_KEY :: 7; | |
| SYSTEM_HANDLE_THREAD :: 8; | |
| SYSTEM_HANDLE_COMPOSITION_OBJECT :: 9; | |
| SYSTEM_HANDLE_SOCKET :: 10; | |
| SYSTEM_HANDLE_JOB :: 11; | |
| SYSTEM_HANDLE_PIPE :: 12; | |
| SYSTEM_HANDLE_MAX :: 12; | |
| SYSTEM_HANDLE_INVALID :: 0xFF; | |
| /* } */ | |
| ; | |
| /* using _ :: enum { */ | |
| MidlInterceptionInfoVersionOne :: 1; | |
| /* } */ | |
| ; | |
| /* using _ :: enum { */ | |
| MidlWinrtTypeSerializationInfoVersionOne :: 1; | |
| /* } */ | |
| ; | |
| MIDL_INTERCEPTION_INFO :: struct { | |
| Version : _c.ulong, | |
| ProcString : PFORMAT_STRING, | |
| ProcFormatOffsetTable : ^_c.ushort, | |
| ProcCount : _c.ulong, | |
| TypeString : PFORMAT_STRING, | |
| }; | |
| PMIDL_INTERCEPTION_INFO :: ^MIDL_INTERCEPTION_INFO; | |
| MIDL_WINRT_TYPE_SERIALIZATION_INFO :: struct { | |
| Version : _c.ulong, | |
| TypeFormatString : PFORMAT_STRING, | |
| FormatStringSize : _c.ushort, | |
| TypeOffset : _c.ushort, | |
| StubDesc : PMIDL_STUB_DESC, | |
| }; | |
| PMIDL_WINRT_TYPE_SERIALIZATION_INFO :: ^MIDL_WINRT_TYPE_SERIALIZATION_INFO; | |
| /* STUB_PHASE :: enum { */ | |
| STUB_PHASE :: _c.int; | |
| STUB_UNMARSHAL :: 0; | |
| STUB_CALL_SERVER :: STUB_UNMARSHAL + 1; | |
| STUB_MARSHAL :: STUB_CALL_SERVER + 1; | |
| STUB_CALL_SERVER_NO_HRESULT :: STUB_MARSHAL + 1; | |
| /* } */ | |
| ; | |
| /* PROXY_PHASE :: enum { */ | |
| PROXY_PHASE :: _c.int; | |
| PROXY_CALCSIZE :: 0; | |
| PROXY_GETBUFFER :: PROXY_CALCSIZE + 1; | |
| PROXY_MARSHAL :: PROXY_GETBUFFER + 1; | |
| PROXY_SENDRECEIVE :: PROXY_MARSHAL + 1; | |
| PROXY_UNMARSHAL :: PROXY_SENDRECEIVE + 1; | |
| /* } */ | |
| ; | |
| RPC_SS_THREAD_HANDLE :: rawptr; | |
| RPC_CLIENT_ALLOC :: #type (proc "stdcall" (Size : _c.size_t) -> rawptr); | |
| RPC_CLIENT_FREE :: #type proc "stdcall" (Ptr : rawptr); | |
| NDR_USER_MARSHAL_INFO_LEVEL1 :: struct { | |
| Buffer : rawptr, | |
| BufferSize : _c.ulong, | |
| pfnAllocate : (proc "stdcall" (_c.size_t) -> rawptr), | |
| pfnFree : proc "stdcall" (rawptr), | |
| pRpcChannelBuffer : ^IRpcChannelBuffer, | |
| Reserved : [5]ULONG_PTR, | |
| }; | |
| NDR_USER_MARSHAL_INFO :: struct { | |
| InformationLevel : _c.ulong, | |
| u : struct #raw_union { | |
| Level1 : NDR_USER_MARSHAL_INFO_LEVEL1, | |
| }, | |
| }; | |
| OLECHAR :: WCHAR; | |
| LPOLESTR :: ^OLECHAR; | |
| LPCOLESTR :: ^OLECHAR; | |
| ; | |
| ; | |
| ; | |
| ; | |
| DOUBLE :: _c.double; | |
| COAUTHIDENTITY :: struct { | |
| User : ^USHORT, | |
| UserLength : ULONG, | |
| Domain : ^USHORT, | |
| DomainLength : ULONG, | |
| Password : ^USHORT, | |
| PasswordLength : ULONG, | |
| Flags : ULONG, | |
| }; | |
| COAUTHINFO :: struct { | |
| dwAuthnSvc : DWORD, | |
| dwAuthzSvc : DWORD, | |
| pwszServerPrincName : LPWSTR, | |
| dwAuthnLevel : DWORD, | |
| dwImpersonationLevel : DWORD, | |
| pAuthIdentityData : ^COAUTHIDENTITY, | |
| dwCapabilities : DWORD, | |
| }; | |
| SCODE :: LONG; | |
| PSCODE :: ^SCODE; | |
| /* MEMCTX :: enum { */ | |
| MEMCTX :: _c.int; | |
| MEMCTX_TASK :: 1; | |
| MEMCTX_SHARED :: 2; | |
| MEMCTX_MACSYSTEM :: 3; | |
| MEMCTX_UNKNOWN :: -1; | |
| MEMCTX_SAME :: -2; | |
| /* } */ | |
| ; | |
| /* CLSCTX :: enum { */ | |
| CLSCTX :: _c.int; | |
| CLSCTX_INPROC_SERVER :: 0x1; | |
| CLSCTX_INPROC_HANDLER :: 0x2; | |
| CLSCTX_LOCAL_SERVER :: 0x4; | |
| CLSCTX_INPROC_SERVER16 :: 0x8; | |
| CLSCTX_REMOTE_SERVER :: 0x10; | |
| CLSCTX_INPROC_HANDLER16 :: 0x20; | |
| CLSCTX_RESERVED1 :: 0x40; | |
| CLSCTX_RESERVED2 :: 0x80; | |
| CLSCTX_RESERVED3 :: 0x100; | |
| CLSCTX_RESERVED4 :: 0x200; | |
| CLSCTX_NO_CODE_DOWNLOAD :: 0x400; | |
| CLSCTX_RESERVED5 :: 0x800; | |
| CLSCTX_NO_CUSTOM_MARSHAL :: 0x1000; | |
| CLSCTX_ENABLE_CODE_DOWNLOAD :: 0x2000; | |
| CLSCTX_NO_FAILURE_LOG :: 0x4000; | |
| CLSCTX_DISABLE_AAA :: 0x8000; | |
| CLSCTX_ENABLE_AAA :: 0x10000; | |
| CLSCTX_FROM_DEFAULT_CONTEXT :: 0x20000; | |
| CLSCTX_ACTIVATE_X86_SERVER :: 0x40000; | |
| CLSCTX_ACTIVATE_32_BIT_SERVER :: CLSCTX_ACTIVATE_X86_SERVER; | |
| CLSCTX_ACTIVATE_64_BIT_SERVER :: 0x80000; | |
| CLSCTX_ENABLE_CLOAKING :: 0x100000; | |
| CLSCTX_APPCONTAINER :: 0x400000; | |
| CLSCTX_ACTIVATE_AAA_AS_IU :: 0x800000; | |
| CLSCTX_RESERVED6 :: 0x1000000; | |
| CLSCTX_ACTIVATE_ARM32_SERVER :: 0x2000000; | |
| CLSCTX_PS_DLL :: 0x80000000; | |
| /* } */ | |
| ; | |
| /* MSHLFLAGS :: enum { */ | |
| MSHLFLAGS :: _c.int; | |
| MSHLFLAGS_NORMAL :: 0; | |
| MSHLFLAGS_TABLESTRONG :: 1; | |
| MSHLFLAGS_TABLEWEAK :: 2; | |
| MSHLFLAGS_NOPING :: 4; | |
| MSHLFLAGS_RESERVED1 :: 8; | |
| MSHLFLAGS_RESERVED2 :: 16; | |
| MSHLFLAGS_RESERVED3 :: 32; | |
| MSHLFLAGS_RESERVED4 :: 64; | |
| /* } */ | |
| ; | |
| /* MSHCTX :: enum { */ | |
| MSHCTX :: _c.int; | |
| MSHCTX_LOCAL :: 0; | |
| MSHCTX_NOSHAREDMEM :: 1; | |
| MSHCTX_DIFFERENTMACHINE :: 2; | |
| MSHCTX_INPROC :: 3; | |
| MSHCTX_CROSSCTX :: 4; | |
| MSHCTX_RESERVED1 :: 5; | |
| /* } */ | |
| ; | |
| BYTE_BLOB :: struct { | |
| clSize : ULONG, | |
| abData : [1]byte, | |
| }; | |
| UP_BYTE_BLOB :: ^BYTE_BLOB; | |
| WORD_BLOB :: struct { | |
| clSize : ULONG, | |
| asData : [1]_c.ushort, | |
| }; | |
| UP_WORD_BLOB :: ^WORD_BLOB; | |
| DWORD_BLOB :: struct { | |
| clSize : ULONG, | |
| alData : [1]ULONG, | |
| }; | |
| UP_DWORD_BLOB :: ^DWORD_BLOB; | |
| FLAGGED_BYTE_BLOB :: struct { | |
| fFlags : ULONG, | |
| clSize : ULONG, | |
| abData : [1]byte, | |
| }; | |
| UP_FLAGGED_BYTE_BLOB :: ^FLAGGED_BYTE_BLOB; | |
| FLAGGED_WORD_BLOB :: struct { | |
| fFlags : ULONG, | |
| clSize : ULONG, | |
| asData : [1]_c.ushort, | |
| }; | |
| UP_FLAGGED_WORD_BLOB :: ^FLAGGED_WORD_BLOB; | |
| BYTE_SIZEDARR :: struct { | |
| clSize : ULONG, | |
| pData : ^byte, | |
| }; | |
| WORD_SIZEDARR :: struct { | |
| clSize : ULONG, | |
| pData : ^_c.ushort, | |
| }; | |
| DWORD_SIZEDARR :: struct { | |
| clSize : ULONG, | |
| pData : ^ULONG, | |
| }; | |
| HYPER_SIZEDARR :: struct { | |
| clSize : ULONG, | |
| pData : ^i64, | |
| }; | |
| ; | |
| BLOB :: struct { | |
| cbSize : ULONG, | |
| pBlobData : ^BYTE, | |
| }; | |
| LPBLOB :: ^BLOB; | |
| RemHGLOBAL :: struct { | |
| fNullHGlobal : LONG, | |
| cbData : ULONG, | |
| data : [1]byte, | |
| }; | |
| RemHMETAFILEPICT :: struct { | |
| mm : LONG, | |
| xExt : LONG, | |
| yExt : LONG, | |
| cbData : ULONG, | |
| data : [1]byte, | |
| }; | |
| RemHENHMETAFILE :: struct { | |
| cbData : ULONG, | |
| data : [1]byte, | |
| }; | |
| RemHBITMAP :: struct { | |
| cbData : ULONG, | |
| data : [1]byte, | |
| }; | |
| RemHPALETTE :: struct { | |
| cbData : ULONG, | |
| data : [1]byte, | |
| }; | |
| RemHBRUSH :: struct { | |
| cbData : ULONG, | |
| data : [1]byte, | |
| }; | |
| /* DVASPECT :: enum { */ | |
| DVASPECT :: _c.int; | |
| DVASPECT_CONTENT :: 1; | |
| DVASPECT_THUMBNAIL :: 2; | |
| DVASPECT_ICON :: 4; | |
| DVASPECT_DOCPRINT :: 8; | |
| /* } */ | |
| ; | |
| /* STGC :: enum { */ | |
| STGC :: _c.int; | |
| STGC_DEFAULT :: 0; | |
| STGC_OVERWRITE :: 1; | |
| STGC_ONLYIFCURRENT :: 2; | |
| STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE :: 4; | |
| STGC_CONSOLIDATE :: 8; | |
| /* } */ | |
| ; | |
| /* STGMOVE :: enum { */ | |
| STGMOVE :: _c.int; | |
| STGMOVE_MOVE :: 0; | |
| STGMOVE_COPY :: 1; | |
| STGMOVE_SHALLOWCOPY :: 2; | |
| /* } */ | |
| ; | |
| /* STATFLAG :: enum { */ | |
| STATFLAG :: _c.int; | |
| STATFLAG_DEFAULT :: 0; | |
| STATFLAG_NONAME :: 1; | |
| STATFLAG_NOOPEN :: 2; | |
| /* } */ | |
| ; | |
| HCONTEXT :: rawptr; | |
| ; | |
| ; | |
| userCLIPFORMAT :: struct { | |
| fContext : LONG, | |
| u : struct #raw_union { | |
| dwValue : DWORD, | |
| pwszName : ^_c.wchar_t, | |
| }, | |
| }; | |
| wireCLIPFORMAT :: ^userCLIPFORMAT; | |
| CLIPFORMAT :: WORD; | |
| GDI_NONREMOTE :: struct { | |
| fContext : LONG, | |
| u : struct #raw_union { | |
| hInproc : LONG, | |
| hRemote : ^DWORD_BLOB, | |
| }, | |
| }; | |
| userHGLOBAL :: struct { | |
| fContext : LONG, | |
| u : struct #raw_union { | |
| hInproc : LONG, | |
| hRemote : ^FLAGGED_BYTE_BLOB, | |
| hInproc64 : i64, | |
| }, | |
| }; | |
| wireHGLOBAL :: ^userHGLOBAL; | |
| userHMETAFILE :: struct { | |
| fContext : LONG, | |
| u : struct #raw_union { | |
| hInproc : LONG, | |
| hRemote : ^BYTE_BLOB, | |
| hInproc64 : i64, | |
| }, | |
| }; | |
| remoteMETAFILEPICT :: struct { | |
| mm : LONG, | |
| xExt : LONG, | |
| yExt : LONG, | |
| hMF : ^userHMETAFILE, | |
| }; | |
| userHMETAFILEPICT :: struct { | |
| fContext : LONG, | |
| u : struct #raw_union { | |
| hInproc : LONG, | |
| hRemote : ^remoteMETAFILEPICT, | |
| hInproc64 : i64, | |
| }, | |
| }; | |
| userHENHMETAFILE :: struct { | |
| fContext : LONG, | |
| u : struct #raw_union { | |
| hInproc : LONG, | |
| hRemote : ^BYTE_BLOB, | |
| hInproc64 : i64, | |
| }, | |
| }; | |
| userBITMAP :: struct { | |
| bmType : LONG, | |
| bmWidth : LONG, | |
| bmHeight : LONG, | |
| bmWidthBytes : LONG, | |
| bmPlanes : WORD, | |
| bmBitsPixel : WORD, | |
| cbSize : ULONG, | |
| pBuffer : [1]byte, | |
| }; | |
| userHBITMAP :: struct { | |
| fContext : LONG, | |
| u : struct #raw_union { | |
| hInproc : LONG, | |
| hRemote : ^userBITMAP, | |
| hInproc64 : i64, | |
| }, | |
| }; | |
| userHPALETTE :: struct { | |
| fContext : LONG, | |
| u : struct #raw_union { | |
| hInproc : LONG, | |
| hRemote : ^LOGPALETTE, | |
| hInproc64 : i64, | |
| }, | |
| }; | |
| RemotableHandle :: struct { | |
| fContext : LONG, | |
| u : struct #raw_union { | |
| hInproc : LONG, | |
| hRemote : LONG, | |
| }, | |
| }; | |
| wireHWND :: ^RemotableHandle; | |
| wireHMENU :: ^RemotableHandle; | |
| wireHACCEL :: ^RemotableHandle; | |
| wireHBRUSH :: ^RemotableHandle; | |
| wireHFONT :: ^RemotableHandle; | |
| wireHDC :: ^RemotableHandle; | |
| wireHICON :: ^RemotableHandle; | |
| wireHRGN :: ^RemotableHandle; | |
| wireHMONITOR :: ^RemotableHandle; | |
| wireHBITMAP :: ^userHBITMAP; | |
| wireHPALETTE :: ^userHPALETTE; | |
| wireHENHMETAFILE :: ^userHENHMETAFILE; | |
| wireHMETAFILE :: ^userHMETAFILE; | |
| wireHMETAFILEPICT :: ^userHMETAFILEPICT; | |
| HMETAFILEPICT :: rawptr; | |
| DATE :: _c.double; | |
| CY :: struct #raw_union { | |
| s : struct { | |
| Lo : ULONG, | |
| Hi : LONG, | |
| }, | |
| int64 : LONGLONG, | |
| }; | |
| LPCY :: ^CY; | |
| DECIMAL :: struct { | |
| wReserved : USHORT, | |
| u : struct #raw_union { | |
| s : struct { | |
| scale : BYTE, | |
| sign : BYTE, | |
| }, | |
| signscale : USHORT, | |
| }, | |
| Hi32 : ULONG, | |
| u2 : struct #raw_union { | |
| s2 : struct { | |
| Lo32 : ULONG, | |
| Mid32 : ULONG, | |
| }, | |
| Lo64 : ULONGLONG, | |
| }, | |
| }; | |
| LPDECIMAL :: ^DECIMAL; | |
| wireBSTR :: ^FLAGGED_WORD_BLOB; | |
| BSTR :: ^OLECHAR; | |
| LPBSTR :: ^BSTR; | |
| VARIANT_BOOL :: _c.short; | |
| BSTRBLOB :: struct { | |
| cbSize : ULONG, | |
| pData : ^BYTE, | |
| }; | |
| LPBSTRBLOB :: ^BSTRBLOB; | |
| CLIPDATA :: struct { | |
| cbSize : ULONG, | |
| ulClipFmt : LONG, | |
| pClipData : ^BYTE, | |
| }; | |
| VARTYPE :: _c.ushort; | |
| /* VARENUM :: enum { */ | |
| VARENUM :: _c.int; | |
| VT_EMPTY :: 0; | |
| VT_NULL :: 1; | |
| VT_I2 :: 2; | |
| VT_I4 :: 3; | |
| VT_R4 :: 4; | |
| VT_R8 :: 5; | |
| VT_CY :: 6; | |
| VT_DATE :: 7; | |
| VT_BSTR :: 8; | |
| VT_DISPATCH :: 9; | |
| VT_ERROR :: 10; | |
| VT_BOOL :: 11; | |
| VT_VARIANT :: 12; | |
| VT_UNKNOWN :: 13; | |
| VT_DECIMAL :: 14; | |
| VT_I1 :: 16; | |
| VT_UI1 :: 17; | |
| VT_UI2 :: 18; | |
| VT_UI4 :: 19; | |
| VT_I8 :: 20; | |
| VT_UI8 :: 21; | |
| VT_INT :: 22; | |
| VT_UINT :: 23; | |
| VT_VOID :: 24; | |
| VT_HRESULT :: 25; | |
| VT_PTR :: 26; | |
| VT_SAFEARRAY :: 27; | |
| VT_CARRAY :: 28; | |
| VT_USERDEFINED :: 29; | |
| VT_LPSTR :: 30; | |
| VT_LPWSTR :: 31; | |
| VT_RECORD :: 36; | |
| VT_INT_PTR :: 37; | |
| VT_UINT_PTR :: 38; | |
| VT_FILETIME :: 64; | |
| VT_BLOB :: 65; | |
| VT_STREAM :: 66; | |
| VT_STORAGE :: 67; | |
| VT_STREAMED_OBJECT :: 68; | |
| VT_STORED_OBJECT :: 69; | |
| VT_BLOB_OBJECT :: 70; | |
| VT_CF :: 71; | |
| VT_CLSID :: 72; | |
| VT_VERSIONED_STREAM :: 73; | |
| VT_BSTR_BLOB :: 0xfff; | |
| VT_VECTOR :: 0x1000; | |
| VT_ARRAY :: 0x2000; | |
| VT_BYREF :: 0x4000; | |
| VT_RESERVED :: 0x8000; | |
| VT_ILLEGAL :: 0xffff; | |
| VT_ILLEGALMASKED :: 0xfff; | |
| VT_TYPEMASK :: 0xfff; | |
| /* } */ | |
| ; | |
| PROPID :: ULONG; | |
| PROPERTYKEY :: struct { | |
| fmtid : GUID, | |
| pid : DWORD, | |
| }; | |
| CSPLATFORM :: struct { | |
| dwPlatformId : DWORD, | |
| dwVersionHi : DWORD, | |
| dwVersionLo : DWORD, | |
| dwProcessorArch : DWORD, | |
| }; | |
| QUERYCONTEXT :: struct { | |
| dwContext : DWORD, | |
| Platform : CSPLATFORM, | |
| Locale : LCID, | |
| dwVersionHi : DWORD, | |
| dwVersionLo : DWORD, | |
| }; | |
| /* TYSPEC :: enum { */ | |
| TYSPEC :: _c.int; | |
| TYSPEC_CLSID :: 0; | |
| TYSPEC_FILEEXT :: (TYSPEC_CLSID + 1); | |
| TYSPEC_MIMETYPE :: (TYSPEC_FILEEXT + 1); | |
| TYSPEC_FILENAME :: (TYSPEC_MIMETYPE + 1); | |
| TYSPEC_PROGID :: (TYSPEC_FILENAME + 1); | |
| TYSPEC_PACKAGENAME :: (TYSPEC_PROGID + 1); | |
| TYSPEC_OBJECTID :: (TYSPEC_PACKAGENAME + 1); | |
| /* } */ | |
| ; | |
| uCLSSPEC :: struct { | |
| tyspec : DWORD, | |
| tagged_union : struct #raw_union { | |
| clsid : CLSID, | |
| pFileExt : LPOLESTR, | |
| pMimeType : LPOLESTR, | |
| pProgId : LPOLESTR, | |
| pFileName : LPOLESTR, | |
| ByName : struct { | |
| pPackageName : LPOLESTR, | |
| PolicyId : GUID, | |
| }, | |
| ByObjectId : struct { | |
| ObjectId : GUID, | |
| PolicyId : GUID, | |
| }, | |
| }, | |
| }; | |
| STORAGE_HOTPLUG_INFO :: struct { | |
| Size : DWORD, | |
| MediaRemovable : BOOLEAN, | |
| MediaHotplug : BOOLEAN, | |
| DeviceHotplug : BOOLEAN, | |
| WriteCacheEnableOverride : BOOLEAN, | |
| }; | |
| PSTORAGE_HOTPLUG_INFO :: ^STORAGE_HOTPLUG_INFO; | |
| STORAGE_DEVICE_NUMBER :: struct { | |
| DeviceType : DWORD, | |
| DeviceNumber : DWORD, | |
| PartitionNumber : DWORD, | |
| }; | |
| PSTORAGE_DEVICE_NUMBER :: ^STORAGE_DEVICE_NUMBER; | |
| STORAGE_DEVICE_NUMBERS :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| NumberOfDevices : DWORD, | |
| Devices : [1]STORAGE_DEVICE_NUMBER, | |
| }; | |
| PSTORAGE_DEVICE_NUMBERS :: ^STORAGE_DEVICE_NUMBERS; | |
| STORAGE_DEVICE_NUMBER_EX :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| DeviceType : DWORD, | |
| DeviceNumber : DWORD, | |
| DeviceGuid : GUID, | |
| PartitionNumber : DWORD, | |
| }; | |
| PSTORAGE_DEVICE_NUMBER_EX :: ^STORAGE_DEVICE_NUMBER_EX; | |
| STORAGE_BUS_RESET_REQUEST :: struct { | |
| PathId : BYTE, | |
| }; | |
| PSTORAGE_BUS_RESET_REQUEST :: ^STORAGE_BUS_RESET_REQUEST; | |
| STORAGE_BREAK_RESERVATION_REQUEST :: struct { | |
| Length : DWORD, | |
| _unused : BYTE, | |
| PathId : BYTE, | |
| TargetId : BYTE, | |
| Lun : BYTE, | |
| }; | |
| PSTORAGE_BREAK_RESERVATION_REQUEST :: ^STORAGE_BREAK_RESERVATION_REQUEST; | |
| PREVENT_MEDIA_REMOVAL :: struct { | |
| PreventMediaRemoval : BOOLEAN, | |
| }; | |
| PPREVENT_MEDIA_REMOVAL :: ^PREVENT_MEDIA_REMOVAL; | |
| CLASS_MEDIA_CHANGE_CONTEXT :: struct { | |
| MediaChangeCount : DWORD, | |
| NewState : DWORD, | |
| }; | |
| PCLASS_MEDIA_CHANGE_CONTEXT :: ^CLASS_MEDIA_CHANGE_CONTEXT; | |
| TAPE_STATISTICS :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| RecoveredWrites : LARGE_INTEGER, | |
| UnrecoveredWrites : LARGE_INTEGER, | |
| RecoveredReads : LARGE_INTEGER, | |
| UnrecoveredReads : LARGE_INTEGER, | |
| CompressionRatioReads : BYTE, | |
| CompressionRatioWrites : BYTE, | |
| }; | |
| PTAPE_STATISTICS :: ^TAPE_STATISTICS; | |
| TAPE_GET_STATISTICS :: struct { | |
| Operation : DWORD, | |
| }; | |
| PTAPE_GET_STATISTICS :: ^TAPE_GET_STATISTICS; | |
| /* STORAGE_MEDIA_TYPE :: enum { */ | |
| STORAGE_MEDIA_TYPE :: _c.int; | |
| DDS_4mm :: 0x20; | |
| MiniQic :: DDS_4mm + 1; | |
| Travan :: MiniQic + 1; | |
| QIC :: Travan + 1; | |
| MP_8mm :: QIC + 1; | |
| AME_8mm :: MP_8mm + 1; | |
| AIT1_8mm :: AME_8mm + 1; | |
| DLT :: AIT1_8mm + 1; | |
| NCTP :: DLT + 1; | |
| IBM_3480 :: NCTP + 1; | |
| IBM_3490E :: IBM_3480 + 1; | |
| IBM_Magstar_3590 :: IBM_3490E + 1; | |
| IBM_Magstar_MP :: IBM_Magstar_3590 + 1; | |
| STK_DATA_D3 :: IBM_Magstar_MP + 1; | |
| SONY_DTF :: STK_DATA_D3 + 1; | |
| DV_6mm :: SONY_DTF + 1; | |
| DMI :: DV_6mm + 1; | |
| SONY_D2 :: DMI + 1; | |
| CLEANER_CARTRIDGE :: SONY_D2 + 1; | |
| CD_ROM :: CLEANER_CARTRIDGE + 1; | |
| CD_R :: CD_ROM + 1; | |
| CD_RW :: CD_R + 1; | |
| DVD_ROM :: CD_RW + 1; | |
| DVD_R :: DVD_ROM + 1; | |
| DVD_RW :: DVD_R + 1; | |
| MO_3_RW :: DVD_RW + 1; | |
| MO_5_WO :: MO_3_RW + 1; | |
| MO_5_RW :: MO_5_WO + 1; | |
| MO_5_LIMDOW :: MO_5_RW + 1; | |
| PC_5_WO :: MO_5_LIMDOW + 1; | |
| PC_5_RW :: PC_5_WO + 1; | |
| PD_5_RW :: PC_5_RW + 1; | |
| ABL_5_WO :: PD_5_RW + 1; | |
| PINNACLE_APEX_5_RW :: ABL_5_WO + 1; | |
| SONY_12_WO :: PINNACLE_APEX_5_RW + 1; | |
| PHILIPS_12_WO :: SONY_12_WO + 1; | |
| HITACHI_12_WO :: PHILIPS_12_WO + 1; | |
| CYGNET_12_WO :: HITACHI_12_WO + 1; | |
| KODAK_14_WO :: CYGNET_12_WO + 1; | |
| MO_NFR_525 :: KODAK_14_WO + 1; | |
| NIKON_12_RW :: MO_NFR_525 + 1; | |
| IOMEGA_ZIP :: NIKON_12_RW + 1; | |
| IOMEGA_JAZ :: IOMEGA_ZIP + 1; | |
| SYQUEST_EZ135 :: IOMEGA_JAZ + 1; | |
| SYQUEST_EZFLYER :: SYQUEST_EZ135 + 1; | |
| SYQUEST_SYJET :: SYQUEST_EZFLYER + 1; | |
| AVATAR_F2 :: SYQUEST_SYJET + 1; | |
| MP2_8mm :: AVATAR_F2 + 1; | |
| DST_S :: MP2_8mm + 1; | |
| DST_M :: DST_S + 1; | |
| DST_L :: DST_M + 1; | |
| VXATape_1 :: DST_L + 1; | |
| VXATape_2 :: VXATape_1 + 1; | |
| STK_9840 :: VXATape_2 + 1; | |
| LTO_Ultrium :: STK_9840 + 1; | |
| LTO_Accelis :: LTO_Ultrium + 1; | |
| DVD_RAM :: LTO_Accelis + 1; | |
| AIT_8mm :: DVD_RAM + 1; | |
| ADR_1 :: AIT_8mm + 1; | |
| ADR_2 :: ADR_1 + 1; | |
| STK_9940 :: ADR_2 + 1; | |
| SAIT :: STK_9940 + 1; | |
| VXATape :: SAIT + 1; | |
| /* } */ | |
| PSTORAGE_MEDIA_TYPE :: ^STORAGE_MEDIA_TYPE; | |
| /* STORAGE_BUS_TYPE :: enum { */ | |
| STORAGE_BUS_TYPE :: _c.int; | |
| BusTypeUnknown :: 0x00; | |
| BusTypeScsi :: BusTypeUnknown + 1; | |
| BusTypeAtapi :: BusTypeScsi + 1; | |
| BusTypeAta :: BusTypeAtapi + 1; | |
| BusType1394 :: BusTypeAta + 1; | |
| BusTypeSsa :: BusType1394 + 1; | |
| BusTypeFibre :: BusTypeSsa + 1; | |
| BusTypeUsb :: BusTypeFibre + 1; | |
| BusTypeRAID :: BusTypeUsb + 1; | |
| BusTypeiScsi :: BusTypeRAID + 1; | |
| BusTypeSas :: BusTypeiScsi + 1; | |
| BusTypeSata :: BusTypeSas + 1; | |
| BusTypeSd :: BusTypeSata + 1; | |
| BusTypeMmc :: BusTypeSd + 1; | |
| BusTypeVirtual :: BusTypeMmc + 1; | |
| BusTypeFileBackedVirtual :: BusTypeVirtual + 1; | |
| BusTypeSpaces :: BusTypeFileBackedVirtual + 1; | |
| BusTypeNvme :: BusTypeSpaces + 1; | |
| BusTypeSCM :: BusTypeNvme + 1; | |
| BusTypeUfs :: BusTypeSCM + 1; | |
| BusTypeMax :: BusTypeUfs + 1; | |
| BusTypeMaxReserved :: 0x7F; | |
| /* } */ | |
| PSTORAGE_BUS_TYPE :: ^STORAGE_BUS_TYPE; | |
| DEVICE_MEDIA_INFO :: struct { | |
| DeviceSpecific : struct #raw_union { | |
| DiskInfo : struct { | |
| Cylinders : LARGE_INTEGER, | |
| MediaType : STORAGE_MEDIA_TYPE, | |
| TracksPerCylinder : DWORD, | |
| SectorsPerTrack : DWORD, | |
| BytesPerSector : DWORD, | |
| NumberMediaSides : DWORD, | |
| MediaCharacteristics : DWORD, | |
| }, | |
| RemovableDiskInfo : struct { | |
| Cylinders : LARGE_INTEGER, | |
| MediaType : STORAGE_MEDIA_TYPE, | |
| TracksPerCylinder : DWORD, | |
| SectorsPerTrack : DWORD, | |
| BytesPerSector : DWORD, | |
| NumberMediaSides : DWORD, | |
| MediaCharacteristics : DWORD, | |
| }, | |
| TapeInfo : struct { | |
| MediaType : STORAGE_MEDIA_TYPE, | |
| MediaCharacteristics : DWORD, | |
| CurrentBlockSize : DWORD, | |
| BusType : STORAGE_BUS_TYPE, | |
| BusSpecificData : struct #raw_union { | |
| ScsiInformation : struct { | |
| MediumType : BYTE, | |
| DensityCode : BYTE, | |
| }, | |
| }, | |
| }, | |
| }, | |
| }; | |
| PDEVICE_MEDIA_INFO :: ^DEVICE_MEDIA_INFO; | |
| GET_MEDIA_TYPES :: struct { | |
| DeviceType : DWORD, | |
| MediaInfoCount : DWORD, | |
| MediaInfo : [1]DEVICE_MEDIA_INFO, | |
| }; | |
| PGET_MEDIA_TYPES :: ^GET_MEDIA_TYPES; | |
| STORAGE_PREDICT_FAILURE :: struct { | |
| PredictFailure : DWORD, | |
| VendorSpecific : [512]BYTE, | |
| }; | |
| PSTORAGE_PREDICT_FAILURE :: ^STORAGE_PREDICT_FAILURE; | |
| STORAGE_FAILURE_PREDICTION_CONFIG :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Set : BOOLEAN, | |
| Enabled : BOOLEAN, | |
| Reserved : WORD, | |
| }; | |
| PSTORAGE_FAILURE_PREDICTION_CONFIG :: ^STORAGE_FAILURE_PREDICTION_CONFIG; | |
| /* STORAGE_QUERY_TYPE :: enum { */ | |
| STORAGE_QUERY_TYPE :: _c.int; | |
| PropertyStandardQuery :: 0; | |
| PropertyExistsQuery :: PropertyStandardQuery + 1; | |
| PropertyMaskQuery :: PropertyExistsQuery + 1; | |
| PropertyQueryMaxDefined :: PropertyMaskQuery + 1; | |
| /* } */ | |
| PSTORAGE_QUERY_TYPE :: ^STORAGE_QUERY_TYPE; | |
| /* STORAGE_SET_TYPE :: enum { */ | |
| STORAGE_SET_TYPE :: _c.int; | |
| PropertyStandardSet :: 0; | |
| PropertyExistsSet :: PropertyStandardSet + 1; | |
| PropertySetMaxDefined :: PropertyExistsSet + 1; | |
| /* } */ | |
| PSTORAGE_SET_TYPE :: ^STORAGE_SET_TYPE; | |
| /* STORAGE_PROPERTY_ID :: enum { */ | |
| STORAGE_PROPERTY_ID :: _c.int; | |
| StorageDeviceProperty :: 0; | |
| StorageAdapterProperty :: StorageDeviceProperty + 1; | |
| StorageDeviceIdProperty :: StorageAdapterProperty + 1; | |
| StorageDeviceUniqueIdProperty :: StorageDeviceIdProperty + 1; | |
| StorageDeviceWriteCacheProperty :: StorageDeviceUniqueIdProperty + 1; | |
| StorageMiniportProperty :: StorageDeviceWriteCacheProperty + 1; | |
| StorageAccessAlignmentProperty :: StorageMiniportProperty + 1; | |
| StorageDeviceSeekPenaltyProperty :: StorageAccessAlignmentProperty + 1; | |
| StorageDeviceTrimProperty :: StorageDeviceSeekPenaltyProperty + 1; | |
| StorageDeviceWriteAggregationProperty :: StorageDeviceTrimProperty + 1; | |
| StorageDeviceDeviceTelemetryProperty :: StorageDeviceWriteAggregationProperty + 1; | |
| StorageDeviceLBProvisioningProperty :: StorageDeviceDeviceTelemetryProperty + 1; | |
| StorageDevicePowerProperty :: StorageDeviceLBProvisioningProperty + 1; | |
| StorageDeviceCopyOffloadProperty :: StorageDevicePowerProperty + 1; | |
| StorageDeviceResiliencyProperty :: StorageDeviceCopyOffloadProperty + 1; | |
| StorageDeviceMediumProductType :: StorageDeviceResiliencyProperty + 1; | |
| StorageAdapterRpmbProperty :: StorageDeviceMediumProductType + 1; | |
| StorageAdapterCryptoProperty :: StorageAdapterRpmbProperty + 1; | |
| StorageDeviceIoCapabilityProperty :: 48; | |
| StorageAdapterProtocolSpecificProperty :: StorageDeviceIoCapabilityProperty + 1; | |
| StorageDeviceProtocolSpecificProperty :: StorageAdapterProtocolSpecificProperty + 1; | |
| StorageAdapterTemperatureProperty :: StorageDeviceProtocolSpecificProperty + 1; | |
| StorageDeviceTemperatureProperty :: StorageAdapterTemperatureProperty + 1; | |
| StorageAdapterPhysicalTopologyProperty :: StorageDeviceTemperatureProperty + 1; | |
| StorageDevicePhysicalTopologyProperty :: StorageAdapterPhysicalTopologyProperty + 1; | |
| StorageDeviceAttributesProperty :: StorageDevicePhysicalTopologyProperty + 1; | |
| StorageDeviceManagementStatus :: StorageDeviceAttributesProperty + 1; | |
| StorageAdapterSerialNumberProperty :: StorageDeviceManagementStatus + 1; | |
| StorageDeviceLocationProperty :: StorageAdapterSerialNumberProperty + 1; | |
| StorageDeviceNumaProperty :: StorageDeviceLocationProperty + 1; | |
| StorageDeviceZonedDeviceProperty :: StorageDeviceNumaProperty + 1; | |
| StorageDeviceUnsafeShutdownCount :: StorageDeviceZonedDeviceProperty + 1; | |
| StorageDeviceEnduranceProperty :: StorageDeviceUnsafeShutdownCount + 1; | |
| /* } */ | |
| PSTORAGE_PROPERTY_ID :: ^STORAGE_PROPERTY_ID; | |
| STORAGE_PROPERTY_QUERY :: struct { | |
| PropertyId : STORAGE_PROPERTY_ID, | |
| QueryType : STORAGE_QUERY_TYPE, | |
| AdditionalParameters : [1]BYTE, | |
| }; | |
| PSTORAGE_PROPERTY_QUERY :: ^STORAGE_PROPERTY_QUERY; | |
| STORAGE_PROPERTY_SET :: struct { | |
| PropertyId : STORAGE_PROPERTY_ID, | |
| SetType : STORAGE_SET_TYPE, | |
| AdditionalParameters : [1]BYTE, | |
| }; | |
| PSTORAGE_PROPERTY_SET :: ^STORAGE_PROPERTY_SET; | |
| STORAGE_DESCRIPTOR_HEADER :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| }; | |
| PSTORAGE_DESCRIPTOR_HEADER :: ^STORAGE_DESCRIPTOR_HEADER; | |
| STORAGE_DEVICE_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| DeviceType : BYTE, | |
| DeviceTypeModifier : BYTE, | |
| RemovableMedia : BOOLEAN, | |
| CommandQueueing : BOOLEAN, | |
| VendorIdOffset : DWORD, | |
| ProductIdOffset : DWORD, | |
| ProductRevisionOffset : DWORD, | |
| SerialNumberOffset : DWORD, | |
| BusType : STORAGE_BUS_TYPE, | |
| RawPropertiesLength : DWORD, | |
| RawDeviceProperties : [1]BYTE, | |
| }; | |
| PSTORAGE_DEVICE_DESCRIPTOR :: ^STORAGE_DEVICE_DESCRIPTOR; | |
| STORAGE_ADAPTER_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| MaximumTransferLength : DWORD, | |
| MaximumPhysicalPages : DWORD, | |
| AlignmentMask : DWORD, | |
| AdapterUsesPio : BOOLEAN, | |
| AdapterScansDown : BOOLEAN, | |
| CommandQueueing : BOOLEAN, | |
| AcceleratedTransfer : BOOLEAN, | |
| BusType : BYTE, | |
| BusMajorVersion : WORD, | |
| BusMinorVersion : WORD, | |
| SrbType : BYTE, | |
| AddressType : BYTE, | |
| }; | |
| PSTORAGE_ADAPTER_DESCRIPTOR :: ^STORAGE_ADAPTER_DESCRIPTOR; | |
| STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| BytesPerCacheLine : DWORD, | |
| BytesOffsetForCacheAlignment : DWORD, | |
| BytesPerLogicalSector : DWORD, | |
| BytesPerPhysicalSector : DWORD, | |
| BytesOffsetForSectorAlignment : DWORD, | |
| }; | |
| PSTORAGE_ACCESS_ALIGNMENT_DESCRIPTOR :: ^STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR; | |
| STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| MediumProductType : DWORD, | |
| }; | |
| PSTORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR :: ^STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR; | |
| /* STORAGE_PORT_CODE_SET :: enum { */ | |
| STORAGE_PORT_CODE_SET :: _c.int; | |
| StoragePortCodeSetReserved :: 0; | |
| StoragePortCodeSetStorport :: 1; | |
| StoragePortCodeSetSCSIport :: 2; | |
| StoragePortCodeSetSpaceport :: 3; | |
| StoragePortCodeSetATAport :: 4; | |
| StoragePortCodeSetUSBport :: 5; | |
| StoragePortCodeSetSBP2port :: 6; | |
| StoragePortCodeSetSDport :: 7; | |
| /* } */ | |
| PSTORAGE_PORT_CODE_SET :: ^STORAGE_PORT_CODE_SET; | |
| STORAGE_MINIPORT_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Portdriver : STORAGE_PORT_CODE_SET, | |
| LUNResetSupported : BOOLEAN, | |
| TargetResetSupported : BOOLEAN, | |
| IoTimeoutValue : WORD, | |
| ExtraIoInfoSupported : BOOLEAN, | |
| Reserved0 : [3]BYTE, | |
| Reserved1 : DWORD, | |
| }; | |
| PSTORAGE_MINIPORT_DESCRIPTOR :: ^STORAGE_MINIPORT_DESCRIPTOR; | |
| /* STORAGE_IDENTIFIER_CODE_SET :: enum { */ | |
| STORAGE_IDENTIFIER_CODE_SET :: _c.int; | |
| StorageIdCodeSetReserved :: 0; | |
| StorageIdCodeSetBinary :: 1; | |
| StorageIdCodeSetAscii :: 2; | |
| StorageIdCodeSetUtf8 :: 3; | |
| /* } */ | |
| PSTORAGE_IDENTIFIER_CODE_SET :: ^STORAGE_IDENTIFIER_CODE_SET; | |
| /* STORAGE_IDENTIFIER_TYPE :: enum { */ | |
| STORAGE_IDENTIFIER_TYPE :: _c.int; | |
| StorageIdTypeVendorSpecific :: 0; | |
| StorageIdTypeVendorId :: 1; | |
| StorageIdTypeEUI64 :: 2; | |
| StorageIdTypeFCPHName :: 3; | |
| StorageIdTypePortRelative :: 4; | |
| StorageIdTypeTargetPortGroup :: 5; | |
| StorageIdTypeLogicalUnitGroup :: 6; | |
| StorageIdTypeMD5LogicalUnitIdentifier :: 7; | |
| StorageIdTypeScsiNameString :: 8; | |
| /* } */ | |
| PSTORAGE_IDENTIFIER_TYPE :: ^STORAGE_IDENTIFIER_TYPE; | |
| /* STORAGE_ID_NAA_FORMAT :: enum { */ | |
| STORAGE_ID_NAA_FORMAT :: _c.int; | |
| StorageIdNAAFormatIEEEExtended :: 2; | |
| StorageIdNAAFormatIEEERegistered :: 3; | |
| StorageIdNAAFormatIEEEERegisteredExtended :: 5; | |
| /* } */ | |
| PSTORAGE_ID_NAA_FORMAT :: ^STORAGE_ID_NAA_FORMAT; | |
| /* STORAGE_ASSOCIATION_TYPE :: enum { */ | |
| STORAGE_ASSOCIATION_TYPE :: _c.int; | |
| StorageIdAssocDevice :: 0; | |
| StorageIdAssocPort :: 1; | |
| StorageIdAssocTarget :: 2; | |
| /* } */ | |
| PSTORAGE_ASSOCIATION_TYPE :: ^STORAGE_ASSOCIATION_TYPE; | |
| STORAGE_IDENTIFIER :: struct { | |
| CodeSet : STORAGE_IDENTIFIER_CODE_SET, | |
| Type : STORAGE_IDENTIFIER_TYPE, | |
| IdentifierSize : WORD, | |
| NextOffset : WORD, | |
| Association : STORAGE_ASSOCIATION_TYPE, | |
| Identifier : [1]BYTE, | |
| }; | |
| PSTORAGE_IDENTIFIER :: ^STORAGE_IDENTIFIER; | |
| STORAGE_DEVICE_ID_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| NumberOfIdentifiers : DWORD, | |
| Identifiers : [1]BYTE, | |
| }; | |
| PSTORAGE_DEVICE_ID_DESCRIPTOR :: ^STORAGE_DEVICE_ID_DESCRIPTOR; | |
| DEVICE_SEEK_PENALTY_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| IncursSeekPenalty : BOOLEAN, | |
| }; | |
| PDEVICE_SEEK_PENALTY_DESCRIPTOR :: ^DEVICE_SEEK_PENALTY_DESCRIPTOR; | |
| DEVICE_WRITE_AGGREGATION_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| BenefitsFromWriteAggregation : BOOLEAN, | |
| }; | |
| PDEVICE_WRITE_AGGREGATION_DESCRIPTOR :: ^DEVICE_WRITE_AGGREGATION_DESCRIPTOR; | |
| DEVICE_TRIM_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| TrimEnabled : BOOLEAN, | |
| }; | |
| PDEVICE_TRIM_DESCRIPTOR :: ^DEVICE_TRIM_DESCRIPTOR; | |
| DEVICE_LB_PROVISIONING_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| using _ : bit_field { | |
| ThinProvisioningEnabled : 1, | |
| ThinProvisioningReadZeros : 1, | |
| AnchorSupported : 3, | |
| UnmapGranularityAlignmentValid : 1, | |
| Reserved0 : 2, | |
| }, | |
| Reserved1 : [7]BYTE, | |
| OptimalUnmapGranularity : DWORDLONG, | |
| UnmapGranularityAlignment : DWORDLONG, | |
| MaxUnmapLbaCount : DWORD, | |
| MaxUnmapBlockDescriptorCount : DWORD, | |
| }; | |
| PDEVICE_LB_PROVISIONING_DESCRIPTOR :: ^DEVICE_LB_PROVISIONING_DESCRIPTOR; | |
| STORAGE_LB_PROVISIONING_MAP_RESOURCES :: struct { | |
| Size : DWORD, | |
| Version : DWORD, | |
| using _ : bit_field { | |
| AvailableMappingResourcesValid : 1, | |
| UsedMappingResourcesValid : 1, | |
| Reserved0 : 6, | |
| }, | |
| Reserved1 : [3]BYTE, | |
| using _ : bit_field { | |
| AvailableMappingResourcesScope : 2, | |
| UsedMappingResourcesScope : 2, | |
| Reserved2 : 4, | |
| }, | |
| Reserved3 : [3]BYTE, | |
| AvailableMappingResources : DWORDLONG, | |
| UsedMappingResources : DWORDLONG, | |
| }; | |
| PSTORAGE_LB_PROVISIONING_MAP_RESOURCES :: ^STORAGE_LB_PROVISIONING_MAP_RESOURCES; | |
| DEVICE_POWER_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| DeviceAttentionSupported : BOOLEAN, | |
| AsynchronousNotificationSupported : BOOLEAN, | |
| IdlePowerManagementEnabled : BOOLEAN, | |
| D3ColdEnabled : BOOLEAN, | |
| D3ColdSupported : BOOLEAN, | |
| NoVerifyDuringIdlePower : BOOLEAN, | |
| Reserved : [2]BYTE, | |
| IdleTimeoutInMS : DWORD, | |
| }; | |
| PDEVICE_POWER_DESCRIPTOR :: ^DEVICE_POWER_DESCRIPTOR; | |
| DEVICE_COPY_OFFLOAD_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| MaximumTokenLifetime : DWORD, | |
| DefaultTokenLifetime : DWORD, | |
| MaximumTransferSize : DWORDLONG, | |
| OptimalTransferCount : DWORDLONG, | |
| MaximumDataDescriptors : DWORD, | |
| MaximumTransferLengthPerDescriptor : DWORD, | |
| OptimalTransferLengthPerDescriptor : DWORD, | |
| OptimalTransferLengthGranularity : WORD, | |
| Reserved : [2]BYTE, | |
| }; | |
| PDEVICE_COPY_OFFLOAD_DESCRIPTOR :: ^DEVICE_COPY_OFFLOAD_DESCRIPTOR; | |
| STORAGE_DEVICE_RESILIENCY_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| NameOffset : DWORD, | |
| NumberOfLogicalCopies : DWORD, | |
| NumberOfPhysicalCopies : DWORD, | |
| PhysicalDiskRedundancy : DWORD, | |
| NumberOfColumns : DWORD, | |
| Interleave : DWORD, | |
| }; | |
| PSTORAGE_DEVICE_RESILIENCY_DESCRIPTOR :: ^STORAGE_DEVICE_RESILIENCY_DESCRIPTOR; | |
| /* STORAGE_RPMB_FRAME_TYPE :: enum { */ | |
| STORAGE_RPMB_FRAME_TYPE :: _c.int; | |
| StorageRpmbFrameTypeUnknown :: 0; | |
| StorageRpmbFrameTypeStandard :: StorageRpmbFrameTypeUnknown + 1; | |
| StorageRpmbFrameTypeMax :: StorageRpmbFrameTypeStandard + 1; | |
| /* } */ | |
| PSTORAGE_RPMB_FRAME_TYPE :: ^STORAGE_RPMB_FRAME_TYPE; | |
| STORAGE_RPMB_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| SizeInBytes : DWORD, | |
| MaxReliableWriteSizeInBytes : DWORD, | |
| FrameFormat : STORAGE_RPMB_FRAME_TYPE, | |
| }; | |
| PSTORAGE_RPMB_DESCRIPTOR :: ^STORAGE_RPMB_DESCRIPTOR; | |
| /* STORAGE_CRYPTO_ALGORITHM_ID :: enum { */ | |
| STORAGE_CRYPTO_ALGORITHM_ID :: _c.int; | |
| StorageCryptoAlgorithmUnknown :: 0; | |
| StorageCryptoAlgorithmXTSAES :: 1; | |
| StorageCryptoAlgorithmBitlockerAESCBC :: StorageCryptoAlgorithmXTSAES + 1; | |
| StorageCryptoAlgorithmAESECB :: StorageCryptoAlgorithmBitlockerAESCBC + 1; | |
| StorageCryptoAlgorithmESSIVAESCBC :: StorageCryptoAlgorithmAESECB + 1; | |
| StorageCryptoAlgorithmMax :: StorageCryptoAlgorithmESSIVAESCBC + 1; | |
| /* } */ | |
| PSTORAGE_CRYPTO_ALGORITHM_ID :: ^STORAGE_CRYPTO_ALGORITHM_ID; | |
| /* STORAGE_CRYPTO_KEY_SIZE :: enum { */ | |
| STORAGE_CRYPTO_KEY_SIZE :: _c.int; | |
| StorageCryptoKeySizeUnknown :: 0; | |
| StorageCryptoKeySize128Bits :: 1; | |
| StorageCryptoKeySize192Bits :: StorageCryptoKeySize128Bits + 1; | |
| StorageCryptoKeySize256Bits :: StorageCryptoKeySize192Bits + 1; | |
| StorageCryptoKeySize512Bits :: StorageCryptoKeySize256Bits + 1; | |
| /* } */ | |
| PSTORAGE_CRYPTO_KEY_SIZE :: ^STORAGE_CRYPTO_KEY_SIZE; | |
| STORAGE_CRYPTO_CAPABILITY :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| CryptoCapabilityIndex : DWORD, | |
| AlgorithmId : STORAGE_CRYPTO_ALGORITHM_ID, | |
| KeySize : STORAGE_CRYPTO_KEY_SIZE, | |
| DataUnitSizeBitmask : DWORD, | |
| }; | |
| PSTORAGE_CRYPTO_CAPABILITY :: ^STORAGE_CRYPTO_CAPABILITY; | |
| STORAGE_CRYPTO_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| NumKeysSupported : DWORD, | |
| NumCryptoCapabilities : DWORD, | |
| CryptoCapabilities : [1]STORAGE_CRYPTO_CAPABILITY, | |
| }; | |
| PSTORAGE_CRYPTO_DESCRIPTOR :: ^STORAGE_CRYPTO_DESCRIPTOR; | |
| /* STORAGE_TIER_MEDIA_TYPE :: enum { */ | |
| STORAGE_TIER_MEDIA_TYPE :: _c.int; | |
| StorageTierMediaTypeUnspecified :: 0; | |
| StorageTierMediaTypeDisk :: 1; | |
| StorageTierMediaTypeSsd :: 2; | |
| StorageTierMediaTypeScm :: 4; | |
| StorageTierMediaTypeMax :: StorageTierMediaTypeScm + 1; | |
| /* } */ | |
| PSTORAGE_TIER_MEDIA_TYPE :: ^STORAGE_TIER_MEDIA_TYPE; | |
| /* STORAGE_TIER_CLASS :: enum { */ | |
| STORAGE_TIER_CLASS :: _c.int; | |
| StorageTierClassUnspecified :: 0; | |
| StorageTierClassCapacity :: StorageTierClassUnspecified + 1; | |
| StorageTierClassPerformance :: StorageTierClassCapacity + 1; | |
| StorageTierClassMax :: StorageTierClassPerformance + 1; | |
| /* } */ | |
| PSTORAGE_TIER_CLASS :: ^STORAGE_TIER_CLASS; | |
| STORAGE_TIER :: struct { | |
| Id : GUID, | |
| Name : [(256)]WCHAR, | |
| Description : [(256)]WCHAR, | |
| Flags : DWORDLONG, | |
| ProvisionedCapacity : DWORDLONG, | |
| MediaType : STORAGE_TIER_MEDIA_TYPE, | |
| Class : STORAGE_TIER_CLASS, | |
| }; | |
| PSTORAGE_TIER :: ^STORAGE_TIER; | |
| STORAGE_DEVICE_TIERING_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| TotalNumberOfTiers : DWORD, | |
| NumberOfTiersReturned : DWORD, | |
| Tiers : [1]STORAGE_TIER, | |
| }; | |
| PSTORAGE_DEVICE_TIERING_DESCRIPTOR :: ^STORAGE_DEVICE_TIERING_DESCRIPTOR; | |
| STORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| NumberOfFaultDomains : DWORD, | |
| FaultDomainIds : [1]GUID, | |
| }; | |
| PSTORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR :: ^STORAGE_DEVICE_FAULT_DOMAIN_DESCRIPTOR; | |
| /* STORAGE_PROTOCOL_TYPE :: enum { */ | |
| STORAGE_PROTOCOL_TYPE :: _c.int; | |
| ProtocolTypeUnknown :: 0x00; | |
| ProtocolTypeScsi :: ProtocolTypeUnknown + 1; | |
| ProtocolTypeAta :: ProtocolTypeScsi + 1; | |
| ProtocolTypeNvme :: ProtocolTypeAta + 1; | |
| ProtocolTypeSd :: ProtocolTypeNvme + 1; | |
| ProtocolTypeUfs :: ProtocolTypeSd + 1; | |
| ProtocolTypeProprietary :: 0x7E; | |
| ProtocolTypeMaxReserved :: 0x7F; | |
| /* } */ | |
| PSTORAGE_PROTOCOL_TYPE :: ^STORAGE_PROTOCOL_TYPE; | |
| /* STORAGE_PROTOCOL_NVME_DATA_TYPE :: enum { */ | |
| STORAGE_PROTOCOL_NVME_DATA_TYPE :: _c.int; | |
| NVMeDataTypeUnknown :: 0; | |
| NVMeDataTypeIdentify :: NVMeDataTypeUnknown + 1; | |
| NVMeDataTypeLogPage :: NVMeDataTypeIdentify + 1; | |
| NVMeDataTypeFeature :: NVMeDataTypeLogPage + 1; | |
| /* } */ | |
| PSTORAGE_PROTOCOL_NVME_DATA_TYPE :: ^STORAGE_PROTOCOL_NVME_DATA_TYPE; | |
| /* STORAGE_PROTOCOL_ATA_DATA_TYPE :: enum { */ | |
| STORAGE_PROTOCOL_ATA_DATA_TYPE :: _c.int; | |
| AtaDataTypeUnknown :: 0; | |
| AtaDataTypeIdentify :: AtaDataTypeUnknown + 1; | |
| AtaDataTypeLogPage :: AtaDataTypeIdentify + 1; | |
| /* } */ | |
| PSTORAGE_PROTOCOL_ATA_DATA_TYPE :: ^STORAGE_PROTOCOL_ATA_DATA_TYPE; | |
| /* STORAGE_PROTOCOL_UFS_DATA_TYPE :: enum { */ | |
| STORAGE_PROTOCOL_UFS_DATA_TYPE :: _c.int; | |
| UfsDataTypeUnknown :: 0; | |
| UfsDataTypeQueryDescriptor :: UfsDataTypeUnknown + 1; | |
| UfsDataTypeMax :: UfsDataTypeQueryDescriptor + 1; | |
| /* } */ | |
| PSTORAGE_PROTOCOL_UFS_DATA_TYPE :: ^STORAGE_PROTOCOL_UFS_DATA_TYPE; | |
| STORAGE_PROTOCOL_SPECIFIC_DATA :: struct { | |
| ProtocolType : STORAGE_PROTOCOL_TYPE, | |
| DataType : DWORD, | |
| ProtocolDataRequestValue : DWORD, | |
| ProtocolDataRequestSubValue : DWORD, | |
| ProtocolDataOffset : DWORD, | |
| ProtocolDataLength : DWORD, | |
| FixedProtocolReturnData : DWORD, | |
| ProtocolDataRequestSubValue2 : DWORD, | |
| ProtocolDataRequestSubValue3 : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PSTORAGE_PROTOCOL_SPECIFIC_DATA :: ^STORAGE_PROTOCOL_SPECIFIC_DATA; | |
| STORAGE_PROTOCOL_SPECIFIC_DATA_EXT :: struct { | |
| ProtocolType : STORAGE_PROTOCOL_TYPE, | |
| DataType : DWORD, | |
| ProtocolDataValue : DWORD, | |
| ProtocolDataSubValue : DWORD, | |
| ProtocolDataOffset : DWORD, | |
| ProtocolDataLength : DWORD, | |
| FixedProtocolReturnData : DWORD, | |
| ProtocolDataSubValue2 : DWORD, | |
| ProtocolDataSubValue3 : DWORD, | |
| ProtocolDataSubValue4 : DWORD, | |
| ProtocolDataSubValue5 : DWORD, | |
| Reserved : [5]DWORD, | |
| }; | |
| PSTORAGE_PROTOCOL_SPECIFIC_DATA_EXT :: ^STORAGE_PROTOCOL_SPECIFIC_DATA_EXT; | |
| STORAGE_PROTOCOL_DATA_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| ProtocolSpecificData : STORAGE_PROTOCOL_SPECIFIC_DATA, | |
| }; | |
| PSTORAGE_PROTOCOL_DATA_DESCRIPTOR :: ^STORAGE_PROTOCOL_DATA_DESCRIPTOR; | |
| STORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| ProtocolSpecificData : STORAGE_PROTOCOL_SPECIFIC_DATA_EXT, | |
| }; | |
| PSTORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT :: ^STORAGE_PROTOCOL_DATA_DESCRIPTOR_EXT; | |
| STORAGE_TEMPERATURE_INFO :: struct { | |
| Index : WORD, | |
| Temperature : SHORT, | |
| OverThreshold : SHORT, | |
| UnderThreshold : SHORT, | |
| OverThresholdChangable : BOOLEAN, | |
| UnderThresholdChangable : BOOLEAN, | |
| EventGenerated : BOOLEAN, | |
| Reserved0 : BYTE, | |
| Reserved1 : DWORD, | |
| }; | |
| PSTORAGE_TEMPERATURE_INFO :: ^STORAGE_TEMPERATURE_INFO; | |
| STORAGE_TEMPERATURE_DATA_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| CriticalTemperature : SHORT, | |
| WarningTemperature : SHORT, | |
| InfoCount : WORD, | |
| Reserved0 : [2]BYTE, | |
| Reserved1 : [2]DWORD, | |
| TemperatureInfo : [1]STORAGE_TEMPERATURE_INFO, | |
| }; | |
| PSTORAGE_TEMPERATURE_DATA_DESCRIPTOR :: ^STORAGE_TEMPERATURE_DATA_DESCRIPTOR; | |
| STORAGE_TEMPERATURE_THRESHOLD :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : WORD, | |
| Index : WORD, | |
| Threshold : SHORT, | |
| OverThreshold : BOOLEAN, | |
| Reserved : BYTE, | |
| }; | |
| PSTORAGE_TEMPERATURE_THRESHOLD :: ^STORAGE_TEMPERATURE_THRESHOLD; | |
| /* STORAGE_DEVICE_FORM_FACTOR :: enum { */ | |
| STORAGE_DEVICE_FORM_FACTOR :: _c.int; | |
| FormFactorUnknown :: 0; | |
| FormFactor3_5 :: FormFactorUnknown + 1; | |
| FormFactor2_5 :: FormFactor3_5 + 1; | |
| FormFactor1_8 :: FormFactor2_5 + 1; | |
| FormFactor1_8Less :: FormFactor1_8 + 1; | |
| FormFactorEmbedded :: FormFactor1_8Less + 1; | |
| FormFactorMemoryCard :: FormFactorEmbedded + 1; | |
| FormFactormSata :: FormFactorMemoryCard + 1; | |
| FormFactorM_2 :: FormFactormSata + 1; | |
| FormFactorPCIeBoard :: FormFactorM_2 + 1; | |
| FormFactorDimm :: FormFactorPCIeBoard + 1; | |
| /* } */ | |
| PSTORAGE_DEVICE_FORM_FACTOR :: ^STORAGE_DEVICE_FORM_FACTOR; | |
| /* STORAGE_COMPONENT_HEALTH_STATUS :: enum { */ | |
| STORAGE_COMPONENT_HEALTH_STATUS :: _c.int; | |
| HealthStatusUnknown :: 0; | |
| HealthStatusNormal :: HealthStatusUnknown + 1; | |
| HealthStatusThrottled :: HealthStatusNormal + 1; | |
| HealthStatusWarning :: HealthStatusThrottled + 1; | |
| HealthStatusDisabled :: HealthStatusWarning + 1; | |
| HealthStatusFailed :: HealthStatusDisabled + 1; | |
| /* } */ | |
| PSTORAGE_COMPONENT_HEALTH_STATUS :: ^STORAGE_COMPONENT_HEALTH_STATUS; | |
| STORAGE_SPEC_VERSION :: struct #raw_union { | |
| s : struct { | |
| MinorVersion : struct #raw_union { | |
| s : struct { | |
| SubMinor : BYTE, | |
| Minor : BYTE, | |
| }, | |
| AsUshort : WORD, | |
| }, | |
| MajorVersion : WORD, | |
| }, | |
| AsUlong : DWORD, | |
| }; | |
| PSTORAGE_SPEC_VERSION :: ^STORAGE_SPEC_VERSION; | |
| STORAGE_PHYSICAL_DEVICE_DATA :: struct { | |
| DeviceId : DWORD, | |
| Role : DWORD, | |
| HealthStatus : STORAGE_COMPONENT_HEALTH_STATUS, | |
| CommandProtocol : STORAGE_PROTOCOL_TYPE, | |
| SpecVersion : STORAGE_SPEC_VERSION, | |
| FormFactor : STORAGE_DEVICE_FORM_FACTOR, | |
| Vendor : [8]BYTE, | |
| Model : [40]BYTE, | |
| FirmwareRevision : [16]BYTE, | |
| Capacity : DWORDLONG, | |
| PhysicalLocation : [32]BYTE, | |
| Reserved : [2]DWORD, | |
| }; | |
| PSTORAGE_PHYSICAL_DEVICE_DATA :: ^STORAGE_PHYSICAL_DEVICE_DATA; | |
| STORAGE_PHYSICAL_ADAPTER_DATA :: struct { | |
| AdapterId : DWORD, | |
| HealthStatus : STORAGE_COMPONENT_HEALTH_STATUS, | |
| CommandProtocol : STORAGE_PROTOCOL_TYPE, | |
| SpecVersion : STORAGE_SPEC_VERSION, | |
| Vendor : [8]BYTE, | |
| Model : [40]BYTE, | |
| FirmwareRevision : [16]BYTE, | |
| PhysicalLocation : [32]BYTE, | |
| ExpanderConnected : BOOLEAN, | |
| Reserved0 : [3]BYTE, | |
| Reserved1 : [3]DWORD, | |
| }; | |
| PSTORAGE_PHYSICAL_ADAPTER_DATA :: ^STORAGE_PHYSICAL_ADAPTER_DATA; | |
| STORAGE_PHYSICAL_NODE_DATA :: struct { | |
| NodeId : DWORD, | |
| AdapterCount : DWORD, | |
| AdapterDataLength : DWORD, | |
| AdapterDataOffset : DWORD, | |
| DeviceCount : DWORD, | |
| DeviceDataLength : DWORD, | |
| DeviceDataOffset : DWORD, | |
| Reserved : [3]DWORD, | |
| }; | |
| PSTORAGE_PHYSICAL_NODE_DATA :: ^STORAGE_PHYSICAL_NODE_DATA; | |
| STORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| NodeCount : DWORD, | |
| Reserved : DWORD, | |
| Node : [1]STORAGE_PHYSICAL_NODE_DATA, | |
| }; | |
| PSTORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR :: ^STORAGE_PHYSICAL_TOPOLOGY_DESCRIPTOR; | |
| STORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| LunMaxIoCount : DWORD, | |
| AdapterMaxIoCount : DWORD, | |
| }; | |
| PSTORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR :: ^STORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR; | |
| STORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Attributes : DWORD64, | |
| }; | |
| PSTORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR :: ^STORAGE_DEVICE_ATTRIBUTES_DESCRIPTOR; | |
| /* STORAGE_DISK_HEALTH_STATUS :: enum { */ | |
| STORAGE_DISK_HEALTH_STATUS :: _c.int; | |
| DiskHealthUnknown :: 0; | |
| DiskHealthUnhealthy :: DiskHealthUnknown + 1; | |
| DiskHealthWarning :: DiskHealthUnhealthy + 1; | |
| DiskHealthHealthy :: DiskHealthWarning + 1; | |
| DiskHealthMax :: DiskHealthHealthy + 1; | |
| /* } */ | |
| PSTORAGE_DISK_HEALTH_STATUS :: ^STORAGE_DISK_HEALTH_STATUS; | |
| /* STORAGE_DISK_OPERATIONAL_STATUS :: enum { */ | |
| STORAGE_DISK_OPERATIONAL_STATUS :: _c.int; | |
| DiskOpStatusNone :: 0; | |
| DiskOpStatusUnknown :: DiskOpStatusNone + 1; | |
| DiskOpStatusOk :: DiskOpStatusUnknown + 1; | |
| DiskOpStatusPredictingFailure :: DiskOpStatusOk + 1; | |
| DiskOpStatusInService :: DiskOpStatusPredictingFailure + 1; | |
| DiskOpStatusHardwareError :: DiskOpStatusInService + 1; | |
| DiskOpStatusNotUsable :: DiskOpStatusHardwareError + 1; | |
| DiskOpStatusTransientError :: DiskOpStatusNotUsable + 1; | |
| DiskOpStatusMissing :: DiskOpStatusTransientError + 1; | |
| /* } */ | |
| PSTORAGE_DISK_OPERATIONAL_STATUS :: ^STORAGE_DISK_OPERATIONAL_STATUS; | |
| /* STORAGE_OPERATIONAL_STATUS_REASON :: enum { */ | |
| STORAGE_OPERATIONAL_STATUS_REASON :: _c.int; | |
| DiskOpReasonUnknown :: 0; | |
| DiskOpReasonScsiSenseCode :: DiskOpReasonUnknown + 1; | |
| DiskOpReasonMedia :: DiskOpReasonScsiSenseCode + 1; | |
| DiskOpReasonIo :: DiskOpReasonMedia + 1; | |
| DiskOpReasonThresholdExceeded :: DiskOpReasonIo + 1; | |
| DiskOpReasonLostData :: DiskOpReasonThresholdExceeded + 1; | |
| DiskOpReasonEnergySource :: DiskOpReasonLostData + 1; | |
| DiskOpReasonConfiguration :: DiskOpReasonEnergySource + 1; | |
| DiskOpReasonDeviceController :: DiskOpReasonConfiguration + 1; | |
| DiskOpReasonMediaController :: DiskOpReasonDeviceController + 1; | |
| DiskOpReasonComponent :: DiskOpReasonMediaController + 1; | |
| DiskOpReasonNVDIMM_N :: DiskOpReasonComponent + 1; | |
| DiskOpReasonBackgroundOperation :: DiskOpReasonNVDIMM_N + 1; | |
| DiskOpReasonInvalidFirmware :: DiskOpReasonBackgroundOperation + 1; | |
| DiskOpReasonHealthCheck :: DiskOpReasonInvalidFirmware + 1; | |
| DiskOpReasonLostDataPersistence :: DiskOpReasonHealthCheck + 1; | |
| DiskOpReasonDisabledByPlatform :: DiskOpReasonLostDataPersistence + 1; | |
| DiskOpReasonLostWritePersistence :: DiskOpReasonDisabledByPlatform + 1; | |
| DiskOpReasonDataPersistenceLossImminent :: DiskOpReasonLostWritePersistence + 1; | |
| DiskOpReasonWritePersistenceLossImminent :: DiskOpReasonDataPersistenceLossImminent + 1; | |
| DiskOpReasonMax :: DiskOpReasonWritePersistenceLossImminent + 1; | |
| /* } */ | |
| PSTORAGE_OPERATIONAL_STATUS_REASON :: ^STORAGE_OPERATIONAL_STATUS_REASON; | |
| STORAGE_OPERATIONAL_REASON :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Reason : STORAGE_OPERATIONAL_STATUS_REASON, | |
| RawBytes : struct #raw_union { | |
| ScsiSenseKey : struct { | |
| SenseKey : BYTE, | |
| ASC : BYTE, | |
| ASCQ : BYTE, | |
| Reserved : BYTE, | |
| }, | |
| NVDIMM_N : struct { | |
| CriticalHealth : BYTE, | |
| ModuleHealth : [2]BYTE, | |
| ErrorThresholdStatus : BYTE, | |
| }, | |
| AsUlong : DWORD, | |
| }, | |
| }; | |
| PSTORAGE_OPERATIONAL_REASON :: ^STORAGE_OPERATIONAL_REASON; | |
| STORAGE_DEVICE_MANAGEMENT_STATUS :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Health : STORAGE_DISK_HEALTH_STATUS, | |
| NumberOfOperationalStatus : DWORD, | |
| NumberOfAdditionalReasons : DWORD, | |
| OperationalStatus : [16]STORAGE_DISK_OPERATIONAL_STATUS, | |
| AdditionalReasons : [1]STORAGE_OPERATIONAL_REASON, | |
| }; | |
| PSTORAGE_DEVICE_MANAGEMENT_STATUS :: ^STORAGE_DEVICE_MANAGEMENT_STATUS; | |
| STORAGE_ADAPTER_SERIAL_NUMBER :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| SerialNumber : [(128)]WCHAR, | |
| }; | |
| PSTORAGE_ADAPTER_SERIAL_NUMBER :: ^STORAGE_ADAPTER_SERIAL_NUMBER; | |
| /* STORAGE_ZONED_DEVICE_TYPES :: enum { */ | |
| STORAGE_ZONED_DEVICE_TYPES :: _c.int; | |
| ZonedDeviceTypeUnknown :: 0; | |
| ZonedDeviceTypeHostManaged :: ZonedDeviceTypeUnknown + 1; | |
| ZonedDeviceTypeHostAware :: ZonedDeviceTypeHostManaged + 1; | |
| ZonedDeviceTypeDeviceManaged :: ZonedDeviceTypeHostAware + 1; | |
| /* } */ | |
| PSTORAGE_ZONED_DEVICE_TYPES :: ^STORAGE_ZONED_DEVICE_TYPES; | |
| /* STORAGE_ZONE_TYPES :: enum { */ | |
| STORAGE_ZONE_TYPES :: _c.int; | |
| ZoneTypeUnknown :: 0; | |
| ZoneTypeConventional :: 1; | |
| ZoneTypeSequentialWriteRequired :: 2; | |
| ZoneTypeSequentialWritePreferred :: 3; | |
| ZoneTypeMax :: ZoneTypeSequentialWritePreferred + 1; | |
| /* } */ | |
| PSTORAGE_ZONE_TYPES :: ^STORAGE_ZONE_TYPES; | |
| STORAGE_ZONE_GROUP :: struct { | |
| ZoneCount : DWORD, | |
| ZoneType : STORAGE_ZONE_TYPES, | |
| ZoneSize : DWORDLONG, | |
| }; | |
| PSTORAGE_ZONE_GROUP :: ^STORAGE_ZONE_GROUP; | |
| STORAGE_ZONED_DEVICE_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| DeviceType : STORAGE_ZONED_DEVICE_TYPES, | |
| ZoneCount : DWORD, | |
| ZoneAttributes : struct #raw_union { | |
| SequentialRequiredZone : struct { | |
| MaxOpenZoneCount : DWORD, | |
| UnrestrictedRead : BOOLEAN, | |
| Reserved : [3]BYTE, | |
| }, | |
| SequentialPreferredZone : struct { | |
| OptimalOpenZoneCount : DWORD, | |
| Reserved : DWORD, | |
| }, | |
| }, | |
| ZoneGroupCount : DWORD, | |
| ZoneGroup : [1]STORAGE_ZONE_GROUP, | |
| }; | |
| PSTORAGE_ZONED_DEVICE_DESCRIPTOR :: ^STORAGE_ZONED_DEVICE_DESCRIPTOR; | |
| DEVICE_LOCATION :: struct { | |
| Socket : DWORD, | |
| Slot : DWORD, | |
| Adapter : DWORD, | |
| Port : DWORD, | |
| u : struct #raw_union { | |
| s : struct { | |
| Channel : DWORD, | |
| Device : DWORD, | |
| }, | |
| s2 : struct { | |
| Target : DWORD, | |
| Lun : DWORD, | |
| }, | |
| }, | |
| }; | |
| PDEVICE_LOCATION :: ^DEVICE_LOCATION; | |
| STORAGE_DEVICE_LOCATION_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Location : DEVICE_LOCATION, | |
| StringOffset : DWORD, | |
| }; | |
| PSTORAGE_DEVICE_LOCATION_DESCRIPTOR :: ^STORAGE_DEVICE_LOCATION_DESCRIPTOR; | |
| STORAGE_DEVICE_NUMA_PROPERTY :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| NumaNode : DWORD, | |
| }; | |
| PSTORAGE_DEVICE_NUMA_PROPERTY :: ^STORAGE_DEVICE_NUMA_PROPERTY; | |
| STORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| UnsafeShutdownCount : DWORD, | |
| }; | |
| PSTORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT :: ^STORAGE_DEVICE_UNSAFE_SHUTDOWN_COUNT; | |
| STORAGE_HW_ENDURANCE_INFO :: struct { | |
| ValidFields : DWORD, | |
| GroupId : DWORD, | |
| Flags : bit_field { | |
| Shared : 1, | |
| Reserved : 31, | |
| }, | |
| LifePercentage : DWORD, | |
| BytesReadCount : [16]BYTE, | |
| ByteWriteCount : [16]BYTE, | |
| }; | |
| PSTORAGE_HW_ENDURANCE_INFO :: ^STORAGE_HW_ENDURANCE_INFO; | |
| STORAGE_HW_ENDURANCE_DATA_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| EnduranceInfo : STORAGE_HW_ENDURANCE_INFO, | |
| }; | |
| PSTORAGE_HW_ENDURANCE_DATA_DESCRIPTOR :: ^STORAGE_HW_ENDURANCE_DATA_DESCRIPTOR; | |
| DEVICE_DATA_MANAGEMENT_SET_ACTION :: DWORD; | |
| DEVICE_DSM_ACTION :: DWORD; | |
| DEVICE_DATA_SET_RANGE :: struct { | |
| StartingOffset : LONGLONG, | |
| LengthInBytes : DWORDLONG, | |
| }; | |
| PDEVICE_DATA_SET_RANGE :: ^DEVICE_DATA_SET_RANGE; | |
| DEVICE_DSM_RANGE :: struct { | |
| StartingOffset : LONGLONG, | |
| LengthInBytes : DWORDLONG, | |
| }; | |
| PDEVICE_DSM_RANGE :: ^DEVICE_DSM_RANGE; | |
| DEVICE_MANAGE_DATA_SET_ATTRIBUTES :: struct { | |
| Size : DWORD, | |
| Action : DEVICE_DSM_ACTION, | |
| Flags : DWORD, | |
| ParameterBlockOffset : DWORD, | |
| ParameterBlockLength : DWORD, | |
| DataSetRangesOffset : DWORD, | |
| DataSetRangesLength : DWORD, | |
| }; | |
| PDEVICE_MANAGE_DATA_SET_ATTRIBUTES :: ^DEVICE_MANAGE_DATA_SET_ATTRIBUTES; | |
| DEVICE_DSM_INPUT :: struct { | |
| Size : DWORD, | |
| Action : DEVICE_DSM_ACTION, | |
| Flags : DWORD, | |
| ParameterBlockOffset : DWORD, | |
| ParameterBlockLength : DWORD, | |
| DataSetRangesOffset : DWORD, | |
| DataSetRangesLength : DWORD, | |
| }; | |
| PDEVICE_DSM_INPUT :: ^DEVICE_DSM_INPUT; | |
| DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT :: struct { | |
| Size : DWORD, | |
| Action : DEVICE_DSM_ACTION, | |
| Flags : DWORD, | |
| OperationStatus : DWORD, | |
| ExtendedError : DWORD, | |
| TargetDetailedError : DWORD, | |
| ReservedStatus : DWORD, | |
| OutputBlockOffset : DWORD, | |
| OutputBlockLength : DWORD, | |
| }; | |
| PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT :: ^DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT; | |
| DEVICE_DSM_OUTPUT :: struct { | |
| Size : DWORD, | |
| Action : DEVICE_DSM_ACTION, | |
| Flags : DWORD, | |
| OperationStatus : DWORD, | |
| ExtendedError : DWORD, | |
| TargetDetailedError : DWORD, | |
| ReservedStatus : DWORD, | |
| OutputBlockOffset : DWORD, | |
| OutputBlockLength : DWORD, | |
| }; | |
| PDEVICE_DSM_OUTPUT :: ^DEVICE_DSM_OUTPUT; | |
| DEVICE_DSM_DEFINITION :: struct { | |
| Action : DEVICE_DSM_ACTION, | |
| SingleRange : BOOLEAN, | |
| ParameterBlockAlignment : DWORD, | |
| ParameterBlockLength : DWORD, | |
| HasOutput : BOOLEAN, | |
| OutputBlockAlignment : DWORD, | |
| OutputBlockLength : DWORD, | |
| }; | |
| PDEVICE_DSM_DEFINITION :: ^DEVICE_DSM_DEFINITION; | |
| DEVICE_DSM_NOTIFICATION_PARAMETERS :: struct { | |
| Size : DWORD, | |
| Flags : DWORD, | |
| NumFileTypeIDs : DWORD, | |
| FileTypeID : [1]GUID, | |
| }; | |
| PDEVICE_DSM_NOTIFICATION_PARAMETERS :: ^DEVICE_DSM_NOTIFICATION_PARAMETERS; | |
| STORAGE_OFFLOAD_TOKEN :: struct { | |
| TokenType : [4]BYTE, | |
| Reserved : [2]BYTE, | |
| TokenIdLength : [2]BYTE, | |
| u : struct #raw_union { | |
| StorageOffloadZeroDataToken : struct { | |
| Reserved2 : [0x1F8]BYTE, | |
| }, | |
| Token : [0x1F8]BYTE, | |
| }, | |
| }; | |
| PSTORAGE_OFFLOAD_TOKEN :: ^STORAGE_OFFLOAD_TOKEN; | |
| DEVICE_DSM_OFFLOAD_READ_PARAMETERS :: struct { | |
| Flags : DWORD, | |
| TimeToLive : DWORD, | |
| Reserved : [2]DWORD, | |
| }; | |
| PDEVICE_DSM_OFFLOAD_READ_PARAMETERS :: ^DEVICE_DSM_OFFLOAD_READ_PARAMETERS; | |
| STORAGE_OFFLOAD_READ_OUTPUT :: struct { | |
| OffloadReadFlags : DWORD, | |
| Reserved : DWORD, | |
| LengthProtected : DWORDLONG, | |
| TokenLength : DWORD, | |
| Token : STORAGE_OFFLOAD_TOKEN, | |
| }; | |
| PSTORAGE_OFFLOAD_READ_OUTPUT :: ^STORAGE_OFFLOAD_READ_OUTPUT; | |
| DEVICE_DSM_OFFLOAD_WRITE_PARAMETERS :: struct { | |
| Flags : DWORD, | |
| Reserved : DWORD, | |
| TokenOffset : DWORDLONG, | |
| Token : STORAGE_OFFLOAD_TOKEN, | |
| }; | |
| PDEVICE_DSM_OFFLOAD_WRITE_PARAMETERS :: ^DEVICE_DSM_OFFLOAD_WRITE_PARAMETERS; | |
| STORAGE_OFFLOAD_WRITE_OUTPUT :: struct { | |
| OffloadWriteFlags : DWORD, | |
| Reserved : DWORD, | |
| LengthCopied : DWORDLONG, | |
| }; | |
| PSTORAGE_OFFLOAD_WRITE_OUTPUT :: ^STORAGE_OFFLOAD_WRITE_OUTPUT; | |
| DEVICE_DATA_SET_LBP_STATE_PARAMETERS :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| OutputVersion : DWORD, | |
| }; | |
| PDEVICE_DATA_SET_LBP_STATE_PARAMETERS :: ^DEVICE_DATA_SET_LBP_STATE_PARAMETERS; | |
| DEVICE_DSM_ALLOCATION_PARAMETERS :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| OutputVersion : DWORD, | |
| }; | |
| PDEVICE_DSM_ALLOCATION_PARAMETERS :: ^DEVICE_DSM_ALLOCATION_PARAMETERS; | |
| DEVICE_DATA_SET_LB_PROVISIONING_STATE :: struct { | |
| Size : DWORD, | |
| Version : DWORD, | |
| SlabSizeInBytes : DWORDLONG, | |
| SlabOffsetDeltaInBytes : DWORD, | |
| SlabAllocationBitMapBitCount : DWORD, | |
| SlabAllocationBitMapLength : DWORD, | |
| SlabAllocationBitMap : [1]DWORD, | |
| }; | |
| PDEVICE_DATA_SET_LB_PROVISIONING_STATE :: ^DEVICE_DATA_SET_LB_PROVISIONING_STATE; | |
| DEVICE_DSM_ALLOCATION_OUTPUT :: struct { | |
| Size : DWORD, | |
| Version : DWORD, | |
| SlabSizeInBytes : DWORDLONG, | |
| SlabOffsetDeltaInBytes : DWORD, | |
| SlabAllocationBitMapBitCount : DWORD, | |
| SlabAllocationBitMapLength : DWORD, | |
| SlabAllocationBitMap : [1]DWORD, | |
| }; | |
| PDEVICE_DSM_ALLOCATION_OUTPUT :: ^DEVICE_DSM_ALLOCATION_OUTPUT; | |
| DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 :: struct { | |
| Size : DWORD, | |
| Version : DWORD, | |
| SlabSizeInBytes : DWORDLONG, | |
| SlabOffsetDeltaInBytes : DWORDLONG, | |
| SlabAllocationBitMapBitCount : DWORD, | |
| SlabAllocationBitMapLength : DWORD, | |
| SlabAllocationBitMap : [1]DWORD, | |
| }; | |
| PDEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 :: ^DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2; | |
| DEVICE_DSM_ALLOCATION_OUTPUT2 :: struct { | |
| Size : DWORD, | |
| Version : DWORD, | |
| SlabSizeInBytes : DWORDLONG, | |
| SlabOffsetDeltaInBytes : DWORDLONG, | |
| SlabAllocationBitMapBitCount : DWORD, | |
| SlabAllocationBitMapLength : DWORD, | |
| SlabAllocationBitMap : [1]DWORD, | |
| }; | |
| PDEVICE_DSM_ALLOCATION_OUTPUT2 :: ^DEVICE_DSM_ALLOCATION_OUTPUT2; | |
| DEVICE_DATA_SET_REPAIR_PARAMETERS :: struct { | |
| NumberOfRepairCopies : DWORD, | |
| SourceCopy : DWORD, | |
| RepairCopies : [1]DWORD, | |
| }; | |
| PDEVICE_DATA_SET_REPAIR_PARAMETERS :: ^DEVICE_DATA_SET_REPAIR_PARAMETERS; | |
| DEVICE_DSM_REPAIR_PARAMETERS :: struct { | |
| NumberOfRepairCopies : DWORD, | |
| SourceCopy : DWORD, | |
| RepairCopies : [1]DWORD, | |
| }; | |
| PDEVICE_DSM_REPAIR_PARAMETERS :: ^DEVICE_DSM_REPAIR_PARAMETERS; | |
| DEVICE_DATA_SET_REPAIR_OUTPUT :: struct { | |
| ParityExtent : DEVICE_DSM_RANGE, | |
| }; | |
| PDEVICE_DATA_SET_REPAIR_OUTPUT :: ^DEVICE_DATA_SET_REPAIR_OUTPUT; | |
| DEVICE_DSM_REPAIR_OUTPUT :: struct { | |
| ParityExtent : DEVICE_DSM_RANGE, | |
| }; | |
| PDEVICE_DSM_REPAIR_OUTPUT :: ^DEVICE_DSM_REPAIR_OUTPUT; | |
| DEVICE_DATA_SET_SCRUB_OUTPUT :: struct { | |
| BytesProcessed : DWORDLONG, | |
| BytesRepaired : DWORDLONG, | |
| BytesFailed : DWORDLONG, | |
| }; | |
| PDEVICE_DATA_SET_SCRUB_OUTPUT :: ^DEVICE_DATA_SET_SCRUB_OUTPUT; | |
| DEVICE_DSM_SCRUB_OUTPUT :: struct { | |
| BytesProcessed : DWORDLONG, | |
| BytesRepaired : DWORDLONG, | |
| BytesFailed : DWORDLONG, | |
| }; | |
| PDEVICE_DSM_SCRUB_OUTPUT :: ^DEVICE_DSM_SCRUB_OUTPUT; | |
| DEVICE_DATA_SET_SCRUB_EX_OUTPUT :: struct { | |
| BytesProcessed : DWORDLONG, | |
| BytesRepaired : DWORDLONG, | |
| BytesFailed : DWORDLONG, | |
| ParityExtent : DEVICE_DSM_RANGE, | |
| }; | |
| PDEVICE_DATA_SET_SCRUB_EX_OUTPUT :: ^DEVICE_DATA_SET_SCRUB_EX_OUTPUT; | |
| DEVICE_DSM_SCRUB_OUTPUT2 :: struct { | |
| BytesProcessed : DWORDLONG, | |
| BytesRepaired : DWORDLONG, | |
| BytesFailed : DWORDLONG, | |
| ParityExtent : DEVICE_DSM_RANGE, | |
| }; | |
| PDEVICE_DSM_SCRUB_OUTPUT2 :: ^DEVICE_DSM_SCRUB_OUTPUT2; | |
| DEVICE_DSM_TIERING_QUERY_INPUT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| NumberOfTierIds : DWORD, | |
| TierIds : [1]GUID, | |
| }; | |
| PDEVICE_DSM_TIERING_QUERY_INPUT :: ^DEVICE_DSM_TIERING_QUERY_INPUT; | |
| DEVICE_DSM_TIERING_QUERY_PARAMETERS :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| NumberOfTierIds : DWORD, | |
| TierIds : [1]GUID, | |
| }; | |
| PDEVICE_DSM_TIERING_QUERY_PARAMETERS :: ^DEVICE_DSM_TIERING_QUERY_PARAMETERS; | |
| STORAGE_TIER_REGION :: struct { | |
| TierId : GUID, | |
| Offset : DWORDLONG, | |
| Length : DWORDLONG, | |
| }; | |
| PSTORAGE_TIER_REGION :: ^STORAGE_TIER_REGION; | |
| DEVICE_DSM_TIERING_QUERY_OUTPUT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| Reserved : DWORD, | |
| Alignment : DWORDLONG, | |
| TotalNumberOfRegions : DWORD, | |
| NumberOfRegionsReturned : DWORD, | |
| Regions : [1]STORAGE_TIER_REGION, | |
| }; | |
| PDEVICE_DSM_TIERING_QUERY_OUTPUT :: ^DEVICE_DSM_TIERING_QUERY_OUTPUT; | |
| DEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS :: struct { | |
| Size : DWORD, | |
| TargetPriority : BYTE, | |
| Reserved : [3]BYTE, | |
| }; | |
| PDEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS :: ^DEVICE_DSM_NVCACHE_CHANGE_PRIORITY_PARAMETERS; | |
| DEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT :: struct { | |
| TopologyRangeBytes : DWORDLONG, | |
| TopologyId : [16]BYTE, | |
| }; | |
| PDEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT :: ^DEVICE_DATA_SET_TOPOLOGY_ID_QUERY_OUTPUT; | |
| DEVICE_DSM_TOPOLOGY_ID_QUERY_OUTPUT :: struct { | |
| TopologyRangeBytes : DWORDLONG, | |
| TopologyId : [16]BYTE, | |
| }; | |
| PDEVICE_DSM_TOPOLOGY_ID_QUERY_OUTPUT :: ^DEVICE_DSM_TOPOLOGY_ID_QUERY_OUTPUT; | |
| DEVICE_STORAGE_ADDRESS_RANGE :: struct { | |
| StartAddress : LONGLONG, | |
| LengthInBytes : DWORDLONG, | |
| }; | |
| PDEVICE_STORAGE_ADDRESS_RANGE :: ^DEVICE_STORAGE_ADDRESS_RANGE; | |
| DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| TotalNumberOfRanges : DWORD, | |
| NumberOfRangesReturned : DWORD, | |
| Ranges : [1]DEVICE_STORAGE_ADDRESS_RANGE, | |
| }; | |
| PDEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT :: ^DEVICE_DSM_PHYSICAL_ADDRESSES_OUTPUT; | |
| DEVICE_DSM_REPORT_ZONES_PARAMETERS :: struct { | |
| Size : DWORD, | |
| ReportOption : BYTE, | |
| Partial : BYTE, | |
| Reserved : [2]BYTE, | |
| }; | |
| PDEVICE_DSM_REPORT_ZONES_PARAMETERS :: ^DEVICE_DSM_REPORT_ZONES_PARAMETERS; | |
| /* STORAGE_ZONES_ATTRIBUTES :: enum { */ | |
| STORAGE_ZONES_ATTRIBUTES :: _c.int; | |
| ZonesAttributeTypeAndLengthMayDifferent :: 0; | |
| ZonesAttributeTypeSameLengthSame :: 1; | |
| ZonesAttributeTypeSameLastZoneLengthDifferent :: 2; | |
| ZonesAttributeTypeMayDifferentLengthSame :: 3; | |
| /* } */ | |
| PSTORAGE_ZONES_ATTRIBUTES :: ^STORAGE_ZONES_ATTRIBUTES; | |
| /* STORAGE_ZONE_CONDITION :: enum { */ | |
| STORAGE_ZONE_CONDITION :: _c.int; | |
| ZoneConditionConventional :: 0x00; | |
| ZoneConditionEmpty :: 0x01; | |
| ZoneConditionImplicitlyOpened :: 0x02; | |
| ZoneConditionExplicitlyOpened :: 0x03; | |
| ZoneConditionClosed :: 0x04; | |
| ZoneConditionReadOnly :: 0x0D; | |
| ZoneConditionFull :: 0x0E; | |
| ZoneConditionOffline :: 0x0F; | |
| /* } */ | |
| PSTORAGE_ZONE_CONDITION :: ^STORAGE_ZONE_CONDITION; | |
| STORAGE_ZONE_DESCRIPTOR :: struct { | |
| Size : DWORD, | |
| ZoneType : STORAGE_ZONE_TYPES, | |
| ZoneCondition : STORAGE_ZONE_CONDITION, | |
| ResetWritePointerRecommend : BOOLEAN, | |
| Reserved0 : [3]BYTE, | |
| ZoneSize : DWORDLONG, | |
| WritePointerOffset : DWORDLONG, | |
| }; | |
| PSTORAGE_ZONE_DESCRIPTOR :: ^STORAGE_ZONE_DESCRIPTOR; | |
| DEVICE_DSM_REPORT_ZONES_DATA :: struct { | |
| Size : DWORD, | |
| ZoneCount : DWORD, | |
| Attributes : STORAGE_ZONES_ATTRIBUTES, | |
| Reserved0 : DWORD, | |
| ZoneDescriptors : [1]STORAGE_ZONE_DESCRIPTOR, | |
| }; | |
| PDEVICE_DSM_REPORT_ZONES_DATA :: ^DEVICE_DSM_REPORT_ZONES_DATA; | |
| DEVICE_DSM_REPORT_ZONES_OUTPUT :: struct { | |
| Size : DWORD, | |
| ZoneCount : DWORD, | |
| Attributes : STORAGE_ZONES_ATTRIBUTES, | |
| Reserved0 : DWORD, | |
| ZoneDescriptors : [1]STORAGE_ZONE_DESCRIPTOR, | |
| }; | |
| PDEVICE_DSM_REPORT_ZONES_OUTPUT :: ^DEVICE_DSM_REPORT_ZONES_OUTPUT; | |
| DEVICE_STORAGE_RANGE_ATTRIBUTES :: struct { | |
| LengthInBytes : DWORDLONG, | |
| using _ : struct #raw_union { | |
| AllFlags : DWORD, | |
| using _ : bit_field { | |
| IsRangeBad : 1, | |
| }, | |
| }, | |
| Reserved : DWORD, | |
| }; | |
| PDEVICE_STORAGE_RANGE_ATTRIBUTES :: ^DEVICE_STORAGE_RANGE_ATTRIBUTES; | |
| DEVICE_DSM_RANGE_ERROR_INFO :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| TotalNumberOfRanges : DWORD, | |
| NumberOfRangesReturned : DWORD, | |
| Ranges : [1]DEVICE_STORAGE_RANGE_ATTRIBUTES, | |
| }; | |
| PDEVICE_DSM_RANGE_ERROR_INFO :: ^DEVICE_DSM_RANGE_ERROR_INFO; | |
| DEVICE_DSM_RANGE_ERROR_OUTPUT :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| TotalNumberOfRanges : DWORD, | |
| NumberOfRangesReturned : DWORD, | |
| Ranges : [1]DEVICE_STORAGE_RANGE_ATTRIBUTES, | |
| }; | |
| PDEVICE_DSM_RANGE_ERROR_OUTPUT :: ^DEVICE_DSM_RANGE_ERROR_OUTPUT; | |
| DEVICE_DSM_LOST_QUERY_PARAMETERS :: struct { | |
| Version : DWORD, | |
| Granularity : DWORDLONG, | |
| }; | |
| PDEVICE_DSM_LOST_QUERY_PARAMETERS :: ^DEVICE_DSM_LOST_QUERY_PARAMETERS; | |
| DEVICE_DSM_LOST_QUERY_OUTPUT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Alignment : DWORDLONG, | |
| NumberOfBits : DWORD, | |
| BitMap : [1]DWORD, | |
| }; | |
| PDEVICE_DSM_LOST_QUERY_OUTPUT :: ^DEVICE_DSM_LOST_QUERY_OUTPUT; | |
| DEVICE_DSM_FREE_SPACE_OUTPUT :: struct { | |
| Version : DWORD, | |
| FreeSpace : DWORDLONG, | |
| }; | |
| PDEVICE_DSM_FREE_SPACE_OUTPUT :: ^DEVICE_DSM_FREE_SPACE_OUTPUT; | |
| DEVICE_DSM_CONVERSION_OUTPUT :: struct { | |
| Version : DWORD, | |
| Source : GUID, | |
| }; | |
| PDEVICE_DSM_CONVERSION_OUTPUT :: ^DEVICE_DSM_CONVERSION_OUTPUT; | |
| STORAGE_GET_BC_PROPERTIES_OUTPUT :: struct { | |
| MaximumRequestsPerPeriod : DWORD, | |
| MinimumPeriod : DWORD, | |
| MaximumRequestSize : DWORDLONG, | |
| EstimatedTimePerRequest : DWORD, | |
| NumOutStandingRequests : DWORD, | |
| RequestSize : DWORDLONG, | |
| }; | |
| PSTORAGE_GET_BC_PROPERTIES_OUTPUT :: ^STORAGE_GET_BC_PROPERTIES_OUTPUT; | |
| STORAGE_ALLOCATE_BC_STREAM_INPUT :: struct { | |
| Version : DWORD, | |
| RequestsPerPeriod : DWORD, | |
| Period : DWORD, | |
| RetryFailures : BOOLEAN, | |
| Discardable : BOOLEAN, | |
| Reserved1 : [2]BOOLEAN, | |
| AccessType : DWORD, | |
| AccessMode : DWORD, | |
| }; | |
| PSTORAGE_ALLOCATE_BC_STREAM_INPUT :: ^STORAGE_ALLOCATE_BC_STREAM_INPUT; | |
| STORAGE_ALLOCATE_BC_STREAM_OUTPUT :: struct { | |
| RequestSize : DWORDLONG, | |
| NumOutStandingRequests : DWORD, | |
| }; | |
| PSTORAGE_ALLOCATE_BC_STREAM_OUTPUT :: ^STORAGE_ALLOCATE_BC_STREAM_OUTPUT; | |
| STORAGE_PRIORITY_HINT_SUPPORT :: struct { | |
| SupportFlags : DWORD, | |
| }; | |
| PSTORAGE_PRIORITY_HINT_SUPPORT :: ^STORAGE_PRIORITY_HINT_SUPPORT; | |
| /* STORAGE_DIAGNOSTIC_LEVEL :: enum { */ | |
| STORAGE_DIAGNOSTIC_LEVEL :: _c.int; | |
| StorageDiagnosticLevelDefault :: 0; | |
| StorageDiagnosticLevelMax :: StorageDiagnosticLevelDefault + 1; | |
| /* } */ | |
| PSTORAGE_DIAGNOSTIC_LEVEL :: ^STORAGE_DIAGNOSTIC_LEVEL; | |
| /* STORAGE_DIAGNOSTIC_TARGET_TYPE :: enum { */ | |
| STORAGE_DIAGNOSTIC_TARGET_TYPE :: _c.int; | |
| StorageDiagnosticTargetTypeUndefined :: 0; | |
| StorageDiagnosticTargetTypePort :: StorageDiagnosticTargetTypeUndefined + 1; | |
| StorageDiagnosticTargetTypeMiniport :: StorageDiagnosticTargetTypePort + 1; | |
| StorageDiagnosticTargetTypeHbaFirmware :: StorageDiagnosticTargetTypeMiniport + 1; | |
| StorageDiagnosticTargetTypeMax :: StorageDiagnosticTargetTypeHbaFirmware + 1; | |
| /* } */ | |
| PSTORAGE_DIAGNOSTIC_TARGET_TYPE :: ^STORAGE_DIAGNOSTIC_TARGET_TYPE; | |
| STORAGE_DIAGNOSTIC_REQUEST :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Reserved : DWORD, | |
| TargetType : STORAGE_DIAGNOSTIC_TARGET_TYPE, | |
| Level : STORAGE_DIAGNOSTIC_LEVEL, | |
| }; | |
| PSTORAGE_DIAGNOSTIC_REQUEST :: ^STORAGE_DIAGNOSTIC_REQUEST; | |
| STORAGE_DIAGNOSTIC_DATA :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| ProviderId : GUID, | |
| BufferSize : DWORD, | |
| Reserved : DWORD, | |
| DiagnosticDataBuffer : [1]BYTE, | |
| }; | |
| PSTORAGE_DIAGNOSTIC_DATA :: ^STORAGE_DIAGNOSTIC_DATA; | |
| PHYSICAL_ELEMENT_STATUS_REQUEST :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| StartingElement : DWORD, | |
| Filter : BYTE, | |
| ReportType : BYTE, | |
| Reserved : [2]BYTE, | |
| }; | |
| PPHYSICAL_ELEMENT_STATUS_REQUEST :: ^PHYSICAL_ELEMENT_STATUS_REQUEST; | |
| PHYSICAL_ELEMENT_STATUS_DESCRIPTOR :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| ElementIdentifier : DWORD, | |
| PhysicalElementType : BYTE, | |
| PhysicalElementHealth : BYTE, | |
| Reserved1 : [2]BYTE, | |
| AssociatedCapacity : DWORDLONG, | |
| Reserved2 : [4]DWORD, | |
| }; | |
| PPHYSICAL_ELEMENT_STATUS_DESCRIPTOR :: ^PHYSICAL_ELEMENT_STATUS_DESCRIPTOR; | |
| PHYSICAL_ELEMENT_STATUS :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| DescriptorCount : DWORD, | |
| ReturnedDescriptorCount : DWORD, | |
| ElementIdentifierBeingDepoped : DWORD, | |
| Reserved : DWORD, | |
| Descriptors : [1]PHYSICAL_ELEMENT_STATUS_DESCRIPTOR, | |
| }; | |
| PPHYSICAL_ELEMENT_STATUS :: ^PHYSICAL_ELEMENT_STATUS; | |
| REMOVE_ELEMENT_AND_TRUNCATE_REQUEST :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| RequestCapacity : DWORDLONG, | |
| ElementIdentifier : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PREMOVE_ELEMENT_AND_TRUNCATE_REQUEST :: ^REMOVE_ELEMENT_AND_TRUNCATE_REQUEST; | |
| STORAGE_READ_CAPACITY :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| BlockLength : DWORD, | |
| NumberOfBlocks : LARGE_INTEGER, | |
| DiskLength : LARGE_INTEGER, | |
| }; | |
| PSTORAGE_READ_CAPACITY :: ^STORAGE_READ_CAPACITY; | |
| /* WRITE_CACHE_TYPE :: enum { */ | |
| WRITE_CACHE_TYPE :: _c.int; | |
| WriteCacheTypeUnknown :: 0; | |
| WriteCacheTypeNone :: WriteCacheTypeUnknown + 1; | |
| WriteCacheTypeWriteBack :: WriteCacheTypeNone + 1; | |
| WriteCacheTypeWriteThrough :: WriteCacheTypeWriteBack + 1; | |
| /* } */ | |
| ; | |
| /* WRITE_CACHE_ENABLE :: enum { */ | |
| WRITE_CACHE_ENABLE :: _c.int; | |
| WriteCacheEnableUnknown :: 0; | |
| WriteCacheDisabled :: WriteCacheEnableUnknown + 1; | |
| WriteCacheEnabled :: WriteCacheDisabled + 1; | |
| /* } */ | |
| ; | |
| /* WRITE_CACHE_CHANGE :: enum { */ | |
| WRITE_CACHE_CHANGE :: _c.int; | |
| WriteCacheChangeUnknown :: 0; | |
| WriteCacheNotChangeable :: WriteCacheChangeUnknown + 1; | |
| WriteCacheChangeable :: WriteCacheNotChangeable + 1; | |
| /* } */ | |
| ; | |
| /* WRITE_THROUGH :: enum { */ | |
| WRITE_THROUGH :: _c.int; | |
| WriteThroughUnknown :: 0; | |
| WriteThroughNotSupported :: WriteThroughUnknown + 1; | |
| WriteThroughSupported :: WriteThroughNotSupported + 1; | |
| /* } */ | |
| ; | |
| STORAGE_WRITE_CACHE_PROPERTY :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| WriteCacheType : WRITE_CACHE_TYPE, | |
| WriteCacheEnabled : WRITE_CACHE_ENABLE, | |
| WriteCacheChangeable : WRITE_CACHE_CHANGE, | |
| WriteThroughSupported : WRITE_THROUGH, | |
| FlushCacheSupported : BOOLEAN, | |
| UserDefinedPowerProtection : BOOLEAN, | |
| NVCacheEnabled : BOOLEAN, | |
| }; | |
| PSTORAGE_WRITE_CACHE_PROPERTY :: ^STORAGE_WRITE_CACHE_PROPERTY; | |
| /* DEVICEDUMP_COLLECTION_TYPEIDE_NOTIFICATION_TYPE :: enum { */ | |
| DEVICEDUMP_COLLECTION_TYPEIDE_NOTIFICATION_TYPE :: _c.int; | |
| TCCollectionBugCheck :: 1; | |
| TCCollectionApplicationRequested :: TCCollectionBugCheck + 1; | |
| TCCollectionDeviceRequested :: TCCollectionApplicationRequested + 1; | |
| /* } */ | |
| PDEVICEDUMP_COLLECTION_TYPE :: ^DEVICEDUMP_COLLECTION_TYPEIDE_NOTIFICATION_TYPE; | |
| DEVICEDUMP_SUBSECTION_POINTER :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| dwOffset : DWORD, | |
| }; | |
| PDEVICEDUMP_SUBSECTION_POINTER :: ^DEVICEDUMP_SUBSECTION_POINTER; | |
| DEVICEDUMP_STRUCTURE_VERSION :: struct { | |
| dwSignature : DWORD, | |
| dwVersion : DWORD, | |
| dwSize : DWORD, | |
| }; | |
| PDEVICEDUMP_STRUCTURE_VERSION :: ^DEVICEDUMP_STRUCTURE_VERSION; | |
| DEVICEDUMP_SECTION_HEADER :: struct { | |
| guidDeviceDataId : GUID, | |
| sOrganizationID : [16]BYTE, | |
| dwFirmwareRevision : DWORD, | |
| sModelNumber : [32]BYTE, | |
| szDeviceManufacturingID : [32]BYTE, | |
| dwFlags : DWORD, | |
| bRestrictedPrivateDataVersion : DWORD, | |
| dwFirmwareIssueId : DWORD, | |
| szIssueDescriptionString : [132]BYTE, | |
| }; | |
| PDEVICEDUMP_SECTION_HEADER :: ^DEVICEDUMP_SECTION_HEADER; | |
| GP_LOG_PAGE_DESCRIPTOR :: struct { | |
| LogAddress : WORD, | |
| LogSectors : WORD, | |
| }; | |
| PGP_LOG_PAGE_DESCRIPTOR :: ^GP_LOG_PAGE_DESCRIPTOR; | |
| DEVICEDUMP_PUBLIC_SUBSECTION :: struct { | |
| dwFlags : DWORD, | |
| GPLogTable : [16]GP_LOG_PAGE_DESCRIPTOR, | |
| szDescription : [16]CHAR, | |
| bData : [1]BYTE, | |
| }; | |
| PDEVICEDUMP_PUBLIC_SUBSECTION :: ^DEVICEDUMP_PUBLIC_SUBSECTION; | |
| DEVICEDUMP_RESTRICTED_SUBSECTION :: struct { | |
| bData : [1]BYTE, | |
| }; | |
| PDEVICEDUMP_RESTRICTED_SUBSECTION :: ^DEVICEDUMP_RESTRICTED_SUBSECTION; | |
| DEVICEDUMP_PRIVATE_SUBSECTION :: struct { | |
| dwFlags : DWORD, | |
| GPLogId : GP_LOG_PAGE_DESCRIPTOR, | |
| bData : [1]BYTE, | |
| }; | |
| PDEVICEDUMP_PRIVATE_SUBSECTION :: ^DEVICEDUMP_PRIVATE_SUBSECTION; | |
| DEVICEDUMP_STORAGEDEVICE_DATA :: struct { | |
| Descriptor : DEVICEDUMP_STRUCTURE_VERSION, | |
| SectionHeader : DEVICEDUMP_SECTION_HEADER, | |
| dwBufferSize : DWORD, | |
| dwReasonForCollection : DWORD, | |
| PublicData : DEVICEDUMP_SUBSECTION_POINTER, | |
| RestrictedData : DEVICEDUMP_SUBSECTION_POINTER, | |
| PrivateData : DEVICEDUMP_SUBSECTION_POINTER, | |
| }; | |
| PDEVICEDUMP_STORAGEDEVICE_DATA :: ^DEVICEDUMP_STORAGEDEVICE_DATA; | |
| DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD :: struct { | |
| Cdb : [16]BYTE, | |
| Command : [16]BYTE, | |
| StartTime : DWORDLONG, | |
| EndTime : DWORDLONG, | |
| OperationStatus : DWORD, | |
| OperationError : DWORD, | |
| StackSpecific : struct #raw_union { | |
| ExternalStack : struct { | |
| dwReserved : DWORD, | |
| }, | |
| AtaPort : struct { | |
| dwAtaPortSpecific : DWORD, | |
| }, | |
| StorPort : struct { | |
| SrbTag : DWORD, | |
| }, | |
| }, | |
| }; | |
| PDEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD :: ^DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD; | |
| DEVICEDUMP_STORAGESTACK_PUBLIC_DUMP :: struct { | |
| Descriptor : DEVICEDUMP_STRUCTURE_VERSION, | |
| dwReasonForCollection : DWORD, | |
| cDriverName : [16]BYTE, | |
| uiNumRecords : DWORD, | |
| RecordArray : [1]DEVICEDUMP_STORAGESTACK_PUBLIC_STATE_RECORD, | |
| }; | |
| PDEVICEDUMP_STORAGESTACK_PUBLIC_DUMP :: ^DEVICEDUMP_STORAGESTACK_PUBLIC_DUMP; | |
| STORAGE_IDLE_POWER :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| using _ : bit_field { | |
| WakeCapableHint : 1, | |
| D3ColdSupported : 1, | |
| Reserved : 30, | |
| }, | |
| D3IdleTimeout : DWORD, | |
| }; | |
| PSTORAGE_IDLE_POWER :: ^STORAGE_IDLE_POWER; | |
| /* STORAGE_POWERUP_REASON_TYPE :: enum { */ | |
| STORAGE_POWERUP_REASON_TYPE :: _c.int; | |
| StoragePowerupUnknown :: 0; | |
| StoragePowerupIO :: StoragePowerupUnknown + 1; | |
| StoragePowerupDeviceAttention :: StoragePowerupIO + 1; | |
| /* } */ | |
| PSTORAGE_POWERUP_REASON_TYPE :: ^STORAGE_POWERUP_REASON_TYPE; | |
| STORAGE_IDLE_POWERUP_REASON :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| PowerupReason : STORAGE_POWERUP_REASON_TYPE, | |
| }; | |
| PSTORAGE_IDLE_POWERUP_REASON :: ^STORAGE_IDLE_POWERUP_REASON; | |
| /* STORAGE_DEVICE_POWER_CAP_UNITS :: enum { */ | |
| STORAGE_DEVICE_POWER_CAP_UNITS :: _c.int; | |
| StorageDevicePowerCapUnitsPercent :: 0; | |
| StorageDevicePowerCapUnitsMilliwatts :: StorageDevicePowerCapUnitsPercent + 1; | |
| /* } */ | |
| PSTORAGE_DEVICE_POWER_CAP_UNITS :: ^STORAGE_DEVICE_POWER_CAP_UNITS; | |
| STORAGE_DEVICE_POWER_CAP :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Units : STORAGE_DEVICE_POWER_CAP_UNITS, | |
| MaxPower : DWORDLONG, | |
| }; | |
| PSTORAGE_DEVICE_POWER_CAP :: ^STORAGE_DEVICE_POWER_CAP; | |
| STORAGE_RPMB_DATA_FRAME :: struct { | |
| Stuff : [196]BYTE, | |
| KeyOrMAC : [32]BYTE, | |
| Data : [256]BYTE, | |
| Nonce : [16]BYTE, | |
| WriteCounter : [4]BYTE, | |
| Address : [2]BYTE, | |
| BlockCount : [2]BYTE, | |
| OperationResult : [2]BYTE, | |
| RequestOrResponseType : [2]BYTE, | |
| }; | |
| PSTORAGE_RPMB_DATA_FRAME :: ^STORAGE_RPMB_DATA_FRAME; | |
| /* STORAGE_RPMB_COMMAND_TYPE :: enum { */ | |
| STORAGE_RPMB_COMMAND_TYPE :: _c.int; | |
| StorRpmbProgramAuthKey :: 0x00000001; | |
| StorRpmbQueryWriteCounter :: 0x00000002; | |
| StorRpmbAuthenticatedWrite :: 0x00000003; | |
| StorRpmbAuthenticatedRead :: 0x00000004; | |
| StorRpmbReadResultRequest :: 0x00000005; | |
| StorRpmbAuthenticatedDeviceConfigWrite :: 0x00000006; | |
| StorRpmbAuthenticatedDeviceConfigRead :: 0x00000007; | |
| /* } */ | |
| PSTORAGE_RPMB_COMMAND_TYPE :: ^STORAGE_RPMB_COMMAND_TYPE; | |
| STORAGE_EVENT_NOTIFICATION :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Events : DWORDLONG, | |
| }; | |
| PSTORAGE_EVENT_NOTIFICATION :: ^STORAGE_EVENT_NOTIFICATION; | |
| /* STORAGE_COUNTER_TYPE :: enum { */ | |
| STORAGE_COUNTER_TYPE :: _c.int; | |
| StorageCounterTypeUnknown :: 0; | |
| StorageCounterTypeTemperatureCelsius :: StorageCounterTypeUnknown + 1; | |
| StorageCounterTypeTemperatureCelsiusMax :: StorageCounterTypeTemperatureCelsius + 1; | |
| StorageCounterTypeReadErrorsTotal :: StorageCounterTypeTemperatureCelsiusMax + 1; | |
| StorageCounterTypeReadErrorsCorrected :: StorageCounterTypeReadErrorsTotal + 1; | |
| StorageCounterTypeReadErrorsUncorrected :: StorageCounterTypeReadErrorsCorrected + 1; | |
| StorageCounterTypeWriteErrorsTotal :: StorageCounterTypeReadErrorsUncorrected + 1; | |
| StorageCounterTypeWriteErrorsCorrected :: StorageCounterTypeWriteErrorsTotal + 1; | |
| StorageCounterTypeWriteErrorsUncorrected :: StorageCounterTypeWriteErrorsCorrected + 1; | |
| StorageCounterTypeManufactureDate :: StorageCounterTypeWriteErrorsUncorrected + 1; | |
| StorageCounterTypeStartStopCycleCount :: StorageCounterTypeManufactureDate + 1; | |
| StorageCounterTypeStartStopCycleCountMax :: StorageCounterTypeStartStopCycleCount + 1; | |
| StorageCounterTypeLoadUnloadCycleCount :: StorageCounterTypeStartStopCycleCountMax + 1; | |
| StorageCounterTypeLoadUnloadCycleCountMax :: StorageCounterTypeLoadUnloadCycleCount + 1; | |
| StorageCounterTypeWearPercentage :: StorageCounterTypeLoadUnloadCycleCountMax + 1; | |
| StorageCounterTypeWearPercentageWarning :: StorageCounterTypeWearPercentage + 1; | |
| StorageCounterTypeWearPercentageMax :: StorageCounterTypeWearPercentageWarning + 1; | |
| StorageCounterTypePowerOnHours :: StorageCounterTypeWearPercentageMax + 1; | |
| StorageCounterTypeReadLatency100NSMax :: StorageCounterTypePowerOnHours + 1; | |
| StorageCounterTypeWriteLatency100NSMax :: StorageCounterTypeReadLatency100NSMax + 1; | |
| StorageCounterTypeFlushLatency100NSMax :: StorageCounterTypeWriteLatency100NSMax + 1; | |
| StorageCounterTypeMax :: StorageCounterTypeFlushLatency100NSMax + 1; | |
| /* } */ | |
| PSTORAGE_COUNTER_TYPE :: ^STORAGE_COUNTER_TYPE; | |
| STORAGE_COUNTER :: struct { | |
| Type : STORAGE_COUNTER_TYPE, | |
| Value : struct #raw_union { | |
| ManufactureDate : struct { | |
| Week : DWORD, | |
| Year : DWORD, | |
| }, | |
| AsUlonglong : DWORDLONG, | |
| }, | |
| }; | |
| PSTORAGE_COUNTER :: ^STORAGE_COUNTER; | |
| STORAGE_COUNTERS :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| NumberOfCounters : DWORD, | |
| Counters : [1]STORAGE_COUNTER, | |
| }; | |
| PSTORAGE_COUNTERS :: ^STORAGE_COUNTERS; | |
| STORAGE_HW_FIRMWARE_INFO_QUERY :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PSTORAGE_HW_FIRMWARE_INFO_QUERY :: ^STORAGE_HW_FIRMWARE_INFO_QUERY; | |
| STORAGE_HW_FIRMWARE_SLOT_INFO :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| SlotNumber : BYTE, | |
| using _ : bit_field { | |
| ReadOnly : 1, | |
| Reserved0 : 7, | |
| }, | |
| Reserved1 : [6]BYTE, | |
| Revision : [16]BYTE, | |
| }; | |
| PSTORAGE_HW_FIRMWARE_SLOT_INFO :: ^STORAGE_HW_FIRMWARE_SLOT_INFO; | |
| STORAGE_HW_FIRMWARE_INFO :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| using _ : bit_field { | |
| SupportUpgrade : 1, | |
| Reserved0 : 7, | |
| }, | |
| SlotCount : BYTE, | |
| ActiveSlot : BYTE, | |
| PendingActivateSlot : BYTE, | |
| FirmwareShared : BOOLEAN, | |
| Reserved : [3]BYTE, | |
| ImagePayloadAlignment : DWORD, | |
| ImagePayloadMaxSize : DWORD, | |
| Slot : [1]STORAGE_HW_FIRMWARE_SLOT_INFO, | |
| }; | |
| PSTORAGE_HW_FIRMWARE_INFO :: ^STORAGE_HW_FIRMWARE_INFO; | |
| STORAGE_HW_FIRMWARE_DOWNLOAD :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| Slot : BYTE, | |
| Reserved : [3]BYTE, | |
| Offset : DWORDLONG, | |
| BufferSize : DWORDLONG, | |
| ImageBuffer : [1]BYTE, | |
| }; | |
| PSTORAGE_HW_FIRMWARE_DOWNLOAD :: ^STORAGE_HW_FIRMWARE_DOWNLOAD; | |
| STORAGE_HW_FIRMWARE_DOWNLOAD_V2 :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| Slot : BYTE, | |
| Reserved : [3]BYTE, | |
| Offset : DWORDLONG, | |
| BufferSize : DWORDLONG, | |
| ImageSize : DWORD, | |
| Reserved2 : DWORD, | |
| ImageBuffer : [1]BYTE, | |
| }; | |
| PSTORAGE_HW_FIRMWARE_DOWNLOAD_V2 :: ^STORAGE_HW_FIRMWARE_DOWNLOAD_V2; | |
| STORAGE_HW_FIRMWARE_ACTIVATE :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| Slot : BYTE, | |
| Reserved0 : [3]BYTE, | |
| }; | |
| PSTORAGE_HW_FIRMWARE_ACTIVATE :: ^STORAGE_HW_FIRMWARE_ACTIVATE; | |
| STORAGE_PROTOCOL_COMMAND :: struct { | |
| Version : DWORD, | |
| Length : DWORD, | |
| ProtocolType : STORAGE_PROTOCOL_TYPE, | |
| Flags : DWORD, | |
| ReturnStatus : DWORD, | |
| ErrorCode : DWORD, | |
| CommandLength : DWORD, | |
| ErrorInfoLength : DWORD, | |
| DataToDeviceTransferLength : DWORD, | |
| DataFromDeviceTransferLength : DWORD, | |
| TimeOutValue : DWORD, | |
| ErrorInfoOffset : DWORD, | |
| DataToDeviceBufferOffset : DWORD, | |
| DataFromDeviceBufferOffset : DWORD, | |
| CommandSpecific : DWORD, | |
| Reserved0 : DWORD, | |
| FixedProtocolReturnData : DWORD, | |
| Reserved1 : [3]DWORD, | |
| Command : [1]BYTE, | |
| }; | |
| PSTORAGE_PROTOCOL_COMMAND :: ^STORAGE_PROTOCOL_COMMAND; | |
| /* STORAGE_ATTRIBUTE_MGMT_ACTION :: enum { */ | |
| STORAGE_ATTRIBUTE_MGMT_ACTION :: _c.int; | |
| StorAttributeMgmt_ClearAttribute :: 0; | |
| StorAttributeMgmt_SetAttribute :: 1; | |
| StorAttributeMgmt_ResetAttribute :: 2; | |
| /* } */ | |
| PSTORAGE_ATTRIBUTE_MGMT_ACTION :: ^STORAGE_ATTRIBUTE_MGMT_ACTION; | |
| STORAGE_ATTRIBUTE_MGMT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Action : STORAGE_ATTRIBUTE_MGMT_ACTION, | |
| Attribute : DWORD, | |
| }; | |
| PSTORAGE_ATTRIBUTE_MGMT :: ^STORAGE_ATTRIBUTE_MGMT; | |
| SCM_PD_HEALTH_NOTIFICATION_DATA :: struct { | |
| DeviceGuid : GUID, | |
| }; | |
| PSCM_PD_HEALTH_NOTIFICATION_DATA :: ^SCM_PD_HEALTH_NOTIFICATION_DATA; | |
| SCM_LOGICAL_DEVICE_INSTANCE :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| DeviceGuid : GUID, | |
| SymbolicLink : [256]WCHAR, | |
| }; | |
| PSCM_LOGICAL_DEVICE_INSTANCE :: ^SCM_LOGICAL_DEVICE_INSTANCE; | |
| SCM_LOGICAL_DEVICES :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| DeviceCount : DWORD, | |
| Devices : [1]SCM_LOGICAL_DEVICE_INSTANCE, | |
| }; | |
| PSCM_LOGICAL_DEVICES :: ^SCM_LOGICAL_DEVICES; | |
| SCM_PHYSICAL_DEVICE_INSTANCE :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| NfitHandle : DWORD, | |
| SymbolicLink : [256]WCHAR, | |
| }; | |
| PSCM_PHYSICAL_DEVICE_INSTANCE :: ^SCM_PHYSICAL_DEVICE_INSTANCE; | |
| SCM_PHYSICAL_DEVICES :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| DeviceCount : DWORD, | |
| Devices : [1]SCM_PHYSICAL_DEVICE_INSTANCE, | |
| }; | |
| PSCM_PHYSICAL_DEVICES :: ^SCM_PHYSICAL_DEVICES; | |
| /* SCM_REGION_FLAG :: enum { */ | |
| SCM_REGION_FLAG :: _c.int; | |
| ScmRegionFlagNone :: 0x0; | |
| ScmRegionFlagLabel :: 0x1; | |
| /* } */ | |
| PSCM_REGION_FLAG :: ^SCM_REGION_FLAG; | |
| SCM_REGION :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| NfitHandle : DWORD, | |
| LogicalDeviceGuid : GUID, | |
| AddressRangeType : GUID, | |
| AssociatedId : DWORD, | |
| Length : DWORD64, | |
| StartingDPA : DWORD64, | |
| BaseSPA : DWORD64, | |
| SPAOffset : DWORD64, | |
| RegionOffset : DWORD64, | |
| }; | |
| PSCM_REGION :: ^SCM_REGION; | |
| SCM_REGIONS :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| RegionCount : DWORD, | |
| Regions : [1]SCM_REGION, | |
| }; | |
| PSCM_REGIONS :: ^SCM_REGIONS; | |
| SCM_INTERLEAVED_PD_INFO :: struct { | |
| DeviceHandle : DWORD, | |
| DeviceGuid : GUID, | |
| }; | |
| PSCM_INTERLEAVED_PD_INFO :: ^SCM_INTERLEAVED_PD_INFO; | |
| SCM_LD_INTERLEAVE_SET_INFO :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| InterleaveSetSize : DWORD, | |
| InterleaveSet : [1]SCM_INTERLEAVED_PD_INFO, | |
| }; | |
| PSCM_LD_INTERLEAVE_SET_INFO :: ^SCM_LD_INTERLEAVE_SET_INFO; | |
| /* SCM_PD_QUERY_TYPE :: enum { */ | |
| SCM_PD_QUERY_TYPE :: _c.int; | |
| ScmPhysicalDeviceQuery_Descriptor :: 0; | |
| ScmPhysicalDeviceQuery_IsSupported :: ScmPhysicalDeviceQuery_Descriptor + 1; | |
| ScmPhysicalDeviceQuery_Max :: ScmPhysicalDeviceQuery_IsSupported + 1; | |
| /* } */ | |
| PSCM_PD_QUERY_TYPE :: ^SCM_PD_QUERY_TYPE; | |
| /* SCM_PD_PROPERTY_ID :: enum { */ | |
| SCM_PD_PROPERTY_ID :: _c.int; | |
| ScmPhysicalDeviceProperty_DeviceInfo :: 0; | |
| ScmPhysicalDeviceProperty_ManagementStatus :: ScmPhysicalDeviceProperty_DeviceInfo + 1; | |
| ScmPhysicalDeviceProperty_FirmwareInfo :: ScmPhysicalDeviceProperty_ManagementStatus + 1; | |
| ScmPhysicalDeviceProperty_LocationString :: ScmPhysicalDeviceProperty_FirmwareInfo + 1; | |
| ScmPhysicalDeviceProperty_DeviceSpecificInfo :: ScmPhysicalDeviceProperty_LocationString + 1; | |
| ScmPhysicalDeviceProperty_DeviceHandle :: ScmPhysicalDeviceProperty_DeviceSpecificInfo + 1; | |
| ScmPhysicalDeviceProperty_Max :: ScmPhysicalDeviceProperty_DeviceHandle + 1; | |
| /* } */ | |
| PSCM_PD_PROPERTY_ID :: ^SCM_PD_PROPERTY_ID; | |
| SCM_PD_PROPERTY_QUERY :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| PropertyId : SCM_PD_PROPERTY_ID, | |
| QueryType : SCM_PD_QUERY_TYPE, | |
| AdditionalParameters : [1]BYTE, | |
| }; | |
| PSCM_PD_PROPERTY_QUERY :: ^SCM_PD_PROPERTY_QUERY; | |
| SCM_PD_DESCRIPTOR_HEADER :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| }; | |
| PSCM_PD_DESCRIPTOR_HEADER :: ^SCM_PD_DESCRIPTOR_HEADER; | |
| SCM_PD_DEVICE_HANDLE :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| DeviceGuid : GUID, | |
| DeviceHandle : DWORD, | |
| }; | |
| PSCM_PD_DEVICE_HANDLE :: ^SCM_PD_DEVICE_HANDLE; | |
| SCM_PD_DEVICE_INFO :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| DeviceGuid : GUID, | |
| UnsafeShutdownCount : DWORD, | |
| PersistentMemorySizeInBytes : DWORD64, | |
| VolatileMemorySizeInBytes : DWORD64, | |
| TotalMemorySizeInBytes : DWORD64, | |
| SlotNumber : DWORD, | |
| DeviceHandle : DWORD, | |
| PhysicalId : WORD, | |
| NumberOfFormatInterfaceCodes : BYTE, | |
| FormatInterfaceCodes : [8]WORD, | |
| VendorId : DWORD, | |
| ProductId : DWORD, | |
| SubsystemDeviceId : DWORD, | |
| SubsystemVendorId : DWORD, | |
| ManufacturingLocation : BYTE, | |
| ManufacturingWeek : BYTE, | |
| ManufacturingYear : BYTE, | |
| SerialNumber4Byte : DWORD, | |
| SerialNumberLengthInChars : DWORD, | |
| SerialNumber : [1]CHAR, | |
| }; | |
| PSCM_PD_DEVICE_INFO :: ^SCM_PD_DEVICE_INFO; | |
| SCM_PD_DEVICE_SPECIFIC_PROPERTY :: struct { | |
| Name : [128]WCHAR, | |
| Value : LONGLONG, | |
| }; | |
| PSCM_PD_DEVICE_SPECIFIC_PROPERTY :: ^SCM_PD_DEVICE_SPECIFIC_PROPERTY; | |
| SCM_PD_DEVICE_SPECIFIC_INFO :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| NumberOfProperties : DWORD, | |
| DeviceSpecificProperties : [1]SCM_PD_DEVICE_SPECIFIC_PROPERTY, | |
| }; | |
| PSCM_PD_DEVICE_SPECIFIC_INFO :: ^SCM_PD_DEVICE_SPECIFIC_INFO; | |
| SCM_PD_FIRMWARE_SLOT_INFO :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| SlotNumber : BYTE, | |
| using _ : bit_field { | |
| ReadOnly : 1, | |
| Reserved0 : 7, | |
| }, | |
| Reserved1 : [6]BYTE, | |
| Revision : [32]BYTE, | |
| }; | |
| PSCM_PD_FIRMWARE_SLOT_INFO :: ^SCM_PD_FIRMWARE_SLOT_INFO; | |
| SCM_PD_FIRMWARE_INFO :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| ActiveSlot : BYTE, | |
| NextActiveSlot : BYTE, | |
| SlotCount : BYTE, | |
| Slots : [1]SCM_PD_FIRMWARE_SLOT_INFO, | |
| }; | |
| PSCM_PD_FIRMWARE_INFO :: ^SCM_PD_FIRMWARE_INFO; | |
| /* SCM_PD_HEALTH_STATUS :: enum { */ | |
| SCM_PD_HEALTH_STATUS :: _c.int; | |
| ScmPhysicalDeviceHealth_Unknown :: 0; | |
| ScmPhysicalDeviceHealth_Unhealthy :: ScmPhysicalDeviceHealth_Unknown + 1; | |
| ScmPhysicalDeviceHealth_Warning :: ScmPhysicalDeviceHealth_Unhealthy + 1; | |
| ScmPhysicalDeviceHealth_Healthy :: ScmPhysicalDeviceHealth_Warning + 1; | |
| ScmPhysicalDeviceHealth_Max :: ScmPhysicalDeviceHealth_Healthy + 1; | |
| /* } */ | |
| PSCM_PD_HEALTH_STATUS :: ^SCM_PD_HEALTH_STATUS; | |
| /* SCM_PD_OPERATIONAL_STATUS :: enum { */ | |
| SCM_PD_OPERATIONAL_STATUS :: _c.int; | |
| ScmPhysicalDeviceOpStatus_Unknown :: 0; | |
| ScmPhysicalDeviceOpStatus_Ok :: ScmPhysicalDeviceOpStatus_Unknown + 1; | |
| ScmPhysicalDeviceOpStatus_PredictingFailure :: ScmPhysicalDeviceOpStatus_Ok + 1; | |
| ScmPhysicalDeviceOpStatus_InService :: ScmPhysicalDeviceOpStatus_PredictingFailure + 1; | |
| ScmPhysicalDeviceOpStatus_HardwareError :: ScmPhysicalDeviceOpStatus_InService + 1; | |
| ScmPhysicalDeviceOpStatus_NotUsable :: ScmPhysicalDeviceOpStatus_HardwareError + 1; | |
| ScmPhysicalDeviceOpStatus_TransientError :: ScmPhysicalDeviceOpStatus_NotUsable + 1; | |
| ScmPhysicalDeviceOpStatus_Missing :: ScmPhysicalDeviceOpStatus_TransientError + 1; | |
| ScmPhysicalDeviceOpStatus_Max :: ScmPhysicalDeviceOpStatus_Missing + 1; | |
| /* } */ | |
| PSCM_PD_OPERATIONAL_STATUS :: ^SCM_PD_OPERATIONAL_STATUS; | |
| /* SCM_PD_OPERATIONAL_STATUS_REASON :: enum { */ | |
| SCM_PD_OPERATIONAL_STATUS_REASON :: _c.int; | |
| ScmPhysicalDeviceOpReason_Unknown :: 0; | |
| ScmPhysicalDeviceOpReason_Media :: ScmPhysicalDeviceOpReason_Unknown + 1; | |
| ScmPhysicalDeviceOpReason_ThresholdExceeded :: ScmPhysicalDeviceOpReason_Media + 1; | |
| ScmPhysicalDeviceOpReason_LostData :: ScmPhysicalDeviceOpReason_ThresholdExceeded + 1; | |
| ScmPhysicalDeviceOpReason_EnergySource :: ScmPhysicalDeviceOpReason_LostData + 1; | |
| ScmPhysicalDeviceOpReason_Configuration :: ScmPhysicalDeviceOpReason_EnergySource + 1; | |
| ScmPhysicalDeviceOpReason_DeviceController :: ScmPhysicalDeviceOpReason_Configuration + 1; | |
| ScmPhysicalDeviceOpReason_MediaController :: ScmPhysicalDeviceOpReason_DeviceController + 1; | |
| ScmPhysicalDeviceOpReason_Component :: ScmPhysicalDeviceOpReason_MediaController + 1; | |
| ScmPhysicalDeviceOpReason_BackgroundOperation :: ScmPhysicalDeviceOpReason_Component + 1; | |
| ScmPhysicalDeviceOpReason_InvalidFirmware :: ScmPhysicalDeviceOpReason_BackgroundOperation + 1; | |
| ScmPhysicalDeviceOpReason_HealthCheck :: ScmPhysicalDeviceOpReason_InvalidFirmware + 1; | |
| ScmPhysicalDeviceOpReason_LostDataPersistence :: ScmPhysicalDeviceOpReason_HealthCheck + 1; | |
| ScmPhysicalDeviceOpReason_DisabledByPlatform :: ScmPhysicalDeviceOpReason_LostDataPersistence + 1; | |
| ScmPhysicalDeviceOpReason_PermanentError :: ScmPhysicalDeviceOpReason_DisabledByPlatform + 1; | |
| ScmPhysicalDeviceOpReason_LostWritePersistence :: ScmPhysicalDeviceOpReason_PermanentError + 1; | |
| ScmPhysicalDeviceOpReason_FatalError :: ScmPhysicalDeviceOpReason_LostWritePersistence + 1; | |
| ScmPhysicalDeviceOpReason_DataPersistenceLossImminent :: ScmPhysicalDeviceOpReason_FatalError + 1; | |
| ScmPhysicalDeviceOpReason_WritePersistenceLossImminent :: ScmPhysicalDeviceOpReason_DataPersistenceLossImminent + 1; | |
| ScmPhysicalDeviceOpReason_MediaRemainingSpareBlock :: ScmPhysicalDeviceOpReason_WritePersistenceLossImminent + 1; | |
| ScmPhysicalDeviceOpReason_PerformanceDegradation :: ScmPhysicalDeviceOpReason_MediaRemainingSpareBlock + 1; | |
| ScmPhysicalDeviceOpReason_ExcessiveTemperature :: ScmPhysicalDeviceOpReason_PerformanceDegradation + 1; | |
| ScmPhysicalDeviceOpReason_Max :: ScmPhysicalDeviceOpReason_ExcessiveTemperature + 1; | |
| /* } */ | |
| PSCM_PD_OPERATIONAL_STATUS_REASON :: ^SCM_PD_OPERATIONAL_STATUS_REASON; | |
| SCM_PD_MANAGEMENT_STATUS :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Health : SCM_PD_HEALTH_STATUS, | |
| NumberOfOperationalStatus : DWORD, | |
| NumberOfAdditionalReasons : DWORD, | |
| OperationalStatus : [16]SCM_PD_OPERATIONAL_STATUS, | |
| AdditionalReasons : [1]SCM_PD_OPERATIONAL_STATUS_REASON, | |
| }; | |
| PSCM_PD_MANAGEMENT_STATUS :: ^SCM_PD_MANAGEMENT_STATUS; | |
| SCM_PD_LOCATION_STRING :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Location : [1]WCHAR, | |
| }; | |
| PSCM_PD_LOCATION_STRING :: ^SCM_PD_LOCATION_STRING; | |
| SCM_PD_FIRMWARE_DOWNLOAD :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| Slot : BYTE, | |
| Reserved : [3]BYTE, | |
| Offset : DWORD64, | |
| FirmwareImageSizeInBytes : DWORD, | |
| FirmwareImage : [1]BYTE, | |
| }; | |
| PSCM_PD_FIRMWARE_DOWNLOAD :: ^SCM_PD_FIRMWARE_DOWNLOAD; | |
| SCM_PD_FIRMWARE_ACTIVATE :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| Slot : BYTE, | |
| }; | |
| PSCM_PD_FIRMWARE_ACTIVATE :: ^SCM_PD_FIRMWARE_ACTIVATE; | |
| SCM_PD_PASSTHROUGH_INPUT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| ProtocolGuid : GUID, | |
| DataSize : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PSCM_PD_PASSTHROUGH_INPUT :: ^SCM_PD_PASSTHROUGH_INPUT; | |
| SCM_PD_PASSTHROUGH_OUTPUT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| ProtocolGuid : GUID, | |
| DataSize : DWORD, | |
| Data : [1]BYTE, | |
| }; | |
| PSCM_PD_PASSTHROUGH_OUTPUT :: ^SCM_PD_PASSTHROUGH_OUTPUT; | |
| SCM_PD_PASSTHROUGH_INVDIMM_INPUT :: struct { | |
| Opcode : DWORD, | |
| OpcodeParametersLength : DWORD, | |
| OpcodeParameters : [1]BYTE, | |
| }; | |
| PSCM_PD_PASSTHROUGH_INVDIMM_INPUT :: ^SCM_PD_PASSTHROUGH_INVDIMM_INPUT; | |
| SCM_PD_PASSTHROUGH_INVDIMM_OUTPUT :: struct { | |
| GeneralStatus : WORD, | |
| ExtendedStatus : WORD, | |
| OutputDataLength : DWORD, | |
| OutputData : [1]BYTE, | |
| }; | |
| PSCM_PD_PASSTHROUGH_INVDIMM_OUTPUT :: ^SCM_PD_PASSTHROUGH_INVDIMM_OUTPUT; | |
| SCM_PD_REINITIALIZE_MEDIA_INPUT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Options : bit_field { | |
| Overwrite : 1, | |
| }, | |
| }; | |
| PSCM_PD_REINITIALIZE_MEDIA_INPUT :: ^SCM_PD_REINITIALIZE_MEDIA_INPUT; | |
| /* SCM_PD_MEDIA_REINITIALIZATION_STATUS :: enum { */ | |
| SCM_PD_MEDIA_REINITIALIZATION_STATUS :: _c.int; | |
| ScmPhysicalDeviceReinit_Success :: 0; | |
| ScmPhysicalDeviceReinit_RebootNeeded :: ScmPhysicalDeviceReinit_Success + 1; | |
| ScmPhysicalDeviceReinit_ColdBootNeeded :: ScmPhysicalDeviceReinit_RebootNeeded + 1; | |
| ScmPhysicalDeviceReinit_Max :: ScmPhysicalDeviceReinit_ColdBootNeeded + 1; | |
| /* } */ | |
| PSCM_PD_MEDIA_REINITIALIZATION_STATUS :: ^SCM_PD_MEDIA_REINITIALIZATION_STATUS; | |
| SCM_PD_REINITIALIZE_MEDIA_OUTPUT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Status : SCM_PD_MEDIA_REINITIALIZATION_STATUS, | |
| }; | |
| PSCM_PD_REINITIALIZE_MEDIA_OUTPUT :: ^SCM_PD_REINITIALIZE_MEDIA_OUTPUT; | |
| /* MEDIA_TYPE :: enum { */ | |
| MEDIA_TYPE :: _c.int; | |
| Unknown :: 0; | |
| F5_1Pt2_512 :: Unknown + 1; | |
| F3_1Pt44_512 :: F5_1Pt2_512 + 1; | |
| F3_2Pt88_512 :: F3_1Pt44_512 + 1; | |
| F3_20Pt8_512 :: F3_2Pt88_512 + 1; | |
| F3_720_512 :: F3_20Pt8_512 + 1; | |
| F5_360_512 :: F3_720_512 + 1; | |
| F5_320_512 :: F5_360_512 + 1; | |
| F5_320_1024 :: F5_320_512 + 1; | |
| F5_180_512 :: F5_320_1024 + 1; | |
| F5_160_512 :: F5_180_512 + 1; | |
| RemovableMedia :: F5_160_512 + 1; | |
| FixedMedia :: RemovableMedia + 1; | |
| F3_120M_512 :: FixedMedia + 1; | |
| F3_640_512 :: F3_120M_512 + 1; | |
| F5_640_512 :: F3_640_512 + 1; | |
| F5_720_512 :: F5_640_512 + 1; | |
| F3_1Pt2_512 :: F5_720_512 + 1; | |
| F3_1Pt23_1024 :: F3_1Pt2_512 + 1; | |
| F5_1Pt23_1024 :: F3_1Pt23_1024 + 1; | |
| F3_128Mb_512 :: F5_1Pt23_1024 + 1; | |
| F3_230Mb_512 :: F3_128Mb_512 + 1; | |
| F8_256_128 :: F3_230Mb_512 + 1; | |
| F3_200Mb_512 :: F8_256_128 + 1; | |
| F3_240M_512 :: F3_200Mb_512 + 1; | |
| F3_32M_512 :: F3_240M_512 + 1; | |
| /* } */ | |
| PMEDIA_TYPE :: ^MEDIA_TYPE; | |
| FORMAT_PARAMETERS :: struct { | |
| MediaType : MEDIA_TYPE, | |
| StartCylinderNumber : DWORD, | |
| EndCylinderNumber : DWORD, | |
| StartHeadNumber : DWORD, | |
| EndHeadNumber : DWORD, | |
| }; | |
| PFORMAT_PARAMETERS :: ^FORMAT_PARAMETERS; | |
| BAD_TRACK_NUMBER :: WORD; | |
| PBAD_TRACK_NUMBER :: ^WORD; | |
| FORMAT_EX_PARAMETERS :: struct { | |
| MediaType : MEDIA_TYPE, | |
| StartCylinderNumber : DWORD, | |
| EndCylinderNumber : DWORD, | |
| StartHeadNumber : DWORD, | |
| EndHeadNumber : DWORD, | |
| FormatGapLength : WORD, | |
| SectorsPerTrack : WORD, | |
| SectorNumber : [1]WORD, | |
| }; | |
| PFORMAT_EX_PARAMETERS :: ^FORMAT_EX_PARAMETERS; | |
| DISK_GEOMETRY :: struct { | |
| Cylinders : LARGE_INTEGER, | |
| MediaType : MEDIA_TYPE, | |
| TracksPerCylinder : DWORD, | |
| SectorsPerTrack : DWORD, | |
| BytesPerSector : DWORD, | |
| }; | |
| PDISK_GEOMETRY :: ^DISK_GEOMETRY; | |
| PARTITION_INFORMATION :: struct { | |
| StartingOffset : LARGE_INTEGER, | |
| PartitionLength : LARGE_INTEGER, | |
| HiddenSectors : DWORD, | |
| PartitionNumber : DWORD, | |
| PartitionType : BYTE, | |
| BootIndicator : BOOLEAN, | |
| RecognizedPartition : BOOLEAN, | |
| RewritePartition : BOOLEAN, | |
| }; | |
| PPARTITION_INFORMATION :: ^PARTITION_INFORMATION; | |
| SET_PARTITION_INFORMATION :: struct { | |
| PartitionType : BYTE, | |
| }; | |
| PSET_PARTITION_INFORMATION :: ^SET_PARTITION_INFORMATION; | |
| DRIVE_LAYOUT_INFORMATION :: struct { | |
| PartitionCount : DWORD, | |
| Signature : DWORD, | |
| PartitionEntry : [1]PARTITION_INFORMATION, | |
| }; | |
| PDRIVE_LAYOUT_INFORMATION :: ^DRIVE_LAYOUT_INFORMATION; | |
| VERIFY_INFORMATION :: struct { | |
| StartingOffset : LARGE_INTEGER, | |
| Length : DWORD, | |
| }; | |
| PVERIFY_INFORMATION :: ^VERIFY_INFORMATION; | |
| REASSIGN_BLOCKS :: struct { | |
| Reserved : WORD, | |
| Count : WORD, | |
| BlockNumber : [1]DWORD, | |
| }; | |
| PREASSIGN_BLOCKS :: ^REASSIGN_BLOCKS; | |
| REASSIGN_BLOCKS_EX :: struct { | |
| Reserved : WORD, | |
| Count : WORD, | |
| BlockNumber : [1]LARGE_INTEGER, | |
| }; | |
| PREASSIGN_BLOCKS_EX :: ^REASSIGN_BLOCKS_EX; | |
| /* PARTITION_STYLE :: enum { */ | |
| PARTITION_STYLE :: _c.int; | |
| PARTITION_STYLE_MBR :: 0; | |
| PARTITION_STYLE_GPT :: PARTITION_STYLE_MBR + 1; | |
| PARTITION_STYLE_RAW :: PARTITION_STYLE_GPT + 1; | |
| /* } */ | |
| ; | |
| PARTITION_INFORMATION_GPT :: struct { | |
| PartitionType : GUID, | |
| PartitionId : GUID, | |
| Attributes : DWORD64, | |
| Name : [36]WCHAR, | |
| }; | |
| PPARTITION_INFORMATION_GPT :: ^PARTITION_INFORMATION_GPT; | |
| PARTITION_INFORMATION_MBR :: struct { | |
| PartitionType : BYTE, | |
| BootIndicator : BOOLEAN, | |
| RecognizedPartition : BOOLEAN, | |
| HiddenSectors : DWORD, | |
| PartitionId : GUID, | |
| }; | |
| PPARTITION_INFORMATION_MBR :: ^PARTITION_INFORMATION_MBR; | |
| SET_PARTITION_INFORMATION_MBR :: SET_PARTITION_INFORMATION; | |
| SET_PARTITION_INFORMATION_GPT :: PARTITION_INFORMATION_GPT; | |
| SET_PARTITION_INFORMATION_EX :: struct { | |
| PartitionStyle : PARTITION_STYLE, | |
| u : struct #raw_union { | |
| Mbr : SET_PARTITION_INFORMATION_MBR, | |
| Gpt : SET_PARTITION_INFORMATION_GPT, | |
| }, | |
| }; | |
| PSET_PARTITION_INFORMATION_EX :: ^SET_PARTITION_INFORMATION_EX; | |
| CREATE_DISK_GPT :: struct { | |
| DiskId : GUID, | |
| MaxPartitionCount : DWORD, | |
| }; | |
| PCREATE_DISK_GPT :: ^CREATE_DISK_GPT; | |
| CREATE_DISK_MBR :: struct { | |
| Signature : DWORD, | |
| }; | |
| PCREATE_DISK_MBR :: ^CREATE_DISK_MBR; | |
| CREATE_DISK :: struct { | |
| PartitionStyle : PARTITION_STYLE, | |
| u : struct #raw_union { | |
| Mbr : CREATE_DISK_MBR, | |
| Gpt : CREATE_DISK_GPT, | |
| }, | |
| }; | |
| PCREATE_DISK :: ^CREATE_DISK; | |
| GET_LENGTH_INFORMATION :: struct { | |
| Length : LARGE_INTEGER, | |
| }; | |
| PGET_LENGTH_INFORMATION :: ^GET_LENGTH_INFORMATION; | |
| PARTITION_INFORMATION_EX :: struct { | |
| PartitionStyle : PARTITION_STYLE, | |
| StartingOffset : LARGE_INTEGER, | |
| PartitionLength : LARGE_INTEGER, | |
| PartitionNumber : DWORD, | |
| RewritePartition : BOOLEAN, | |
| IsServicePartition : BOOLEAN, | |
| u : struct #raw_union { | |
| Mbr : PARTITION_INFORMATION_MBR, | |
| Gpt : PARTITION_INFORMATION_GPT, | |
| }, | |
| }; | |
| PPARTITION_INFORMATION_EX :: ^PARTITION_INFORMATION_EX; | |
| DRIVE_LAYOUT_INFORMATION_GPT :: struct { | |
| DiskId : GUID, | |
| StartingUsableOffset : LARGE_INTEGER, | |
| UsableLength : LARGE_INTEGER, | |
| MaxPartitionCount : DWORD, | |
| }; | |
| PDRIVE_LAYOUT_INFORMATION_GPT :: ^DRIVE_LAYOUT_INFORMATION_GPT; | |
| DRIVE_LAYOUT_INFORMATION_MBR :: struct { | |
| Signature : DWORD, | |
| CheckSum : DWORD, | |
| }; | |
| PDRIVE_LAYOUT_INFORMATION_MBR :: ^DRIVE_LAYOUT_INFORMATION_MBR; | |
| DRIVE_LAYOUT_INFORMATION_EX :: struct { | |
| PartitionStyle : DWORD, | |
| PartitionCount : DWORD, | |
| u : struct #raw_union { | |
| Mbr : DRIVE_LAYOUT_INFORMATION_MBR, | |
| Gpt : DRIVE_LAYOUT_INFORMATION_GPT, | |
| }, | |
| PartitionEntry : [1]PARTITION_INFORMATION_EX, | |
| }; | |
| PDRIVE_LAYOUT_INFORMATION_EX :: ^DRIVE_LAYOUT_INFORMATION_EX; | |
| /* DETECTION_TYPE :: enum { */ | |
| DETECTION_TYPE :: _c.int; | |
| DetectNone :: 0; | |
| DetectInt13 :: DetectNone + 1; | |
| DetectExInt13 :: DetectInt13 + 1; | |
| /* } */ | |
| ; | |
| DISK_INT13_INFO :: struct { | |
| DriveSelect : WORD, | |
| MaxCylinders : DWORD, | |
| SectorsPerTrack : WORD, | |
| MaxHeads : WORD, | |
| NumberDrives : WORD, | |
| }; | |
| PDISK_INT13_INFO :: ^DISK_INT13_INFO; | |
| DISK_EX_INT13_INFO :: struct { | |
| ExBufferSize : WORD, | |
| ExFlags : WORD, | |
| ExCylinders : DWORD, | |
| ExHeads : DWORD, | |
| ExSectorsPerTrack : DWORD, | |
| ExSectorsPerDrive : DWORD64, | |
| ExSectorSize : WORD, | |
| ExReserved : WORD, | |
| }; | |
| PDISK_EX_INT13_INFO :: ^DISK_EX_INT13_INFO; | |
| DISK_DETECTION_INFO :: struct { | |
| SizeOfDetectInfo : DWORD, | |
| DetectionType : DETECTION_TYPE, | |
| u : struct #raw_union { | |
| s : struct { | |
| Int13 : DISK_INT13_INFO, | |
| ExInt13 : DISK_EX_INT13_INFO, | |
| }, | |
| }, | |
| }; | |
| PDISK_DETECTION_INFO :: ^DISK_DETECTION_INFO; | |
| DISK_PARTITION_INFO :: struct { | |
| SizeOfPartitionInfo : DWORD, | |
| PartitionStyle : PARTITION_STYLE, | |
| u : struct #raw_union { | |
| Mbr : struct { | |
| Signature : DWORD, | |
| CheckSum : DWORD, | |
| }, | |
| Gpt : struct { | |
| DiskId : GUID, | |
| }, | |
| }, | |
| }; | |
| PDISK_PARTITION_INFO :: ^DISK_PARTITION_INFO; | |
| DISK_GEOMETRY_EX :: struct { | |
| Geometry : DISK_GEOMETRY, | |
| DiskSize : LARGE_INTEGER, | |
| Data : [1]BYTE, | |
| }; | |
| PDISK_GEOMETRY_EX :: ^DISK_GEOMETRY_EX; | |
| DISK_CONTROLLER_NUMBER :: struct { | |
| ControllerNumber : DWORD, | |
| DiskNumber : DWORD, | |
| }; | |
| PDISK_CONTROLLER_NUMBER :: ^DISK_CONTROLLER_NUMBER; | |
| /* DISK_CACHE_RETENTION_PRIORITY :: enum { */ | |
| DISK_CACHE_RETENTION_PRIORITY :: _c.int; | |
| EqualPriority :: 0; | |
| KeepPrefetchedData :: EqualPriority + 1; | |
| KeepReadData :: KeepPrefetchedData + 1; | |
| /* } */ | |
| ; | |
| DISK_CACHE_INFORMATION :: struct { | |
| ParametersSavable : BOOLEAN, | |
| ReadCacheEnabled : BOOLEAN, | |
| WriteCacheEnabled : BOOLEAN, | |
| ReadRetentionPriority : DISK_CACHE_RETENTION_PRIORITY, | |
| WriteRetentionPriority : DISK_CACHE_RETENTION_PRIORITY, | |
| DisablePrefetchTransferLength : WORD, | |
| PrefetchScalar : BOOLEAN, | |
| u : struct #raw_union { | |
| ScalarPrefetch : struct { | |
| Minimum : WORD, | |
| Maximum : WORD, | |
| MaximumBlocks : WORD, | |
| }, | |
| BlockPrefetch : struct { | |
| Minimum : WORD, | |
| Maximum : WORD, | |
| }, | |
| }, | |
| }; | |
| PDISK_CACHE_INFORMATION :: ^DISK_CACHE_INFORMATION; | |
| DISK_GROW_PARTITION :: struct { | |
| PartitionNumber : DWORD, | |
| BytesToGrow : LARGE_INTEGER, | |
| }; | |
| PDISK_GROW_PARTITION :: ^DISK_GROW_PARTITION; | |
| HISTOGRAM_BUCKET :: struct { | |
| Reads : DWORD, | |
| Writes : DWORD, | |
| }; | |
| PHISTOGRAM_BUCKET :: ^HISTOGRAM_BUCKET; | |
| DISK_HISTOGRAM :: struct { | |
| DiskSize : LARGE_INTEGER, | |
| Start : LARGE_INTEGER, | |
| End : LARGE_INTEGER, | |
| Average : LARGE_INTEGER, | |
| AverageRead : LARGE_INTEGER, | |
| AverageWrite : LARGE_INTEGER, | |
| Granularity : DWORD, | |
| Size : DWORD, | |
| ReadCount : DWORD, | |
| WriteCount : DWORD, | |
| Histogram : PHISTOGRAM_BUCKET, | |
| }; | |
| PDISK_HISTOGRAM :: ^DISK_HISTOGRAM; | |
| DISK_PERFORMANCE :: struct { | |
| BytesRead : LARGE_INTEGER, | |
| BytesWritten : LARGE_INTEGER, | |
| ReadTime : LARGE_INTEGER, | |
| WriteTime : LARGE_INTEGER, | |
| IdleTime : LARGE_INTEGER, | |
| ReadCount : DWORD, | |
| WriteCount : DWORD, | |
| QueueDepth : DWORD, | |
| SplitCount : DWORD, | |
| QueryTime : LARGE_INTEGER, | |
| StorageDeviceNumber : DWORD, | |
| StorageManagerName : [8]WCHAR, | |
| }; | |
| PDISK_PERFORMANCE :: ^DISK_PERFORMANCE; | |
| DISK_RECORD :: struct { | |
| ByteOffset : LARGE_INTEGER, | |
| StartTime : LARGE_INTEGER, | |
| EndTime : LARGE_INTEGER, | |
| VirtualAddress : PVOID, | |
| NumberOfBytes : DWORD, | |
| DeviceNumber : BYTE, | |
| ReadRequest : BOOLEAN, | |
| }; | |
| PDISK_RECORD :: ^DISK_RECORD; | |
| DISK_LOGGING :: struct { | |
| Function : BYTE, | |
| BufferAddress : PVOID, | |
| BufferSize : DWORD, | |
| }; | |
| PDISK_LOGGING :: ^DISK_LOGGING; | |
| /* BIN_TYPES :: enum { */ | |
| BIN_TYPES :: _c.int; | |
| RequestSize :: 0; | |
| RequestLocation :: RequestSize + 1; | |
| /* } */ | |
| ; | |
| BIN_RANGE :: struct { | |
| StartValue : LARGE_INTEGER, | |
| Length : LARGE_INTEGER, | |
| }; | |
| PBIN_RANGE :: ^BIN_RANGE; | |
| PERF_BIN :: struct { | |
| NumberOfBins : DWORD, | |
| TypeOfBin : DWORD, | |
| BinsRanges : [1]BIN_RANGE, | |
| }; | |
| PPERF_BIN :: ^PERF_BIN; | |
| BIN_COUNT :: struct { | |
| BinRange : BIN_RANGE, | |
| BinCount : DWORD, | |
| }; | |
| PBIN_COUNT :: ^BIN_COUNT; | |
| BIN_RESULTS :: struct { | |
| NumberOfBins : DWORD, | |
| BinCounts : [1]BIN_COUNT, | |
| }; | |
| PBIN_RESULTS :: ^BIN_RESULTS; | |
| GETVERSIONINPARAMS :: struct { | |
| bVersion : BYTE, | |
| bRevision : BYTE, | |
| bReserved : BYTE, | |
| bIDEDeviceMap : BYTE, | |
| fCapabilities : DWORD, | |
| dwReserved : [4]DWORD, | |
| }; | |
| PGETVERSIONINPARAMS :: ^GETVERSIONINPARAMS; | |
| LPGETVERSIONINPARAMS :: ^GETVERSIONINPARAMS; | |
| IDEREGS :: struct { | |
| bFeaturesReg : BYTE, | |
| bSectorCountReg : BYTE, | |
| bSectorNumberReg : BYTE, | |
| bCylLowReg : BYTE, | |
| bCylHighReg : BYTE, | |
| bDriveHeadReg : BYTE, | |
| bCommandReg : BYTE, | |
| bReserved : BYTE, | |
| }; | |
| PIDEREGS :: ^IDEREGS; | |
| LPIDEREGS :: ^IDEREGS; | |
| SENDCMDINPARAMS :: struct { | |
| cBufferSize : DWORD, | |
| irDriveRegs : IDEREGS, | |
| bDriveNumber : BYTE, | |
| bReserved : [3]BYTE, | |
| dwReserved : [4]DWORD, | |
| bBuffer : [1]BYTE, | |
| }; | |
| PSENDCMDINPARAMS :: ^SENDCMDINPARAMS; | |
| LPSENDCMDINPARAMS :: ^SENDCMDINPARAMS; | |
| DRIVERSTATUS :: struct { | |
| bDriverError : BYTE, | |
| bIDEError : BYTE, | |
| bReserved : [2]BYTE, | |
| dwReserved : [2]DWORD, | |
| }; | |
| PDRIVERSTATUS :: ^DRIVERSTATUS; | |
| LPDRIVERSTATUS :: ^DRIVERSTATUS; | |
| SENDCMDOUTPARAMS :: struct { | |
| cBufferSize : DWORD, | |
| DriverStatus : DRIVERSTATUS, | |
| bBuffer : [1]BYTE, | |
| }; | |
| PSENDCMDOUTPARAMS :: ^SENDCMDOUTPARAMS; | |
| LPSENDCMDOUTPARAMS :: ^SENDCMDOUTPARAMS; | |
| GET_DISK_ATTRIBUTES :: struct { | |
| Version : DWORD, | |
| Reserved1 : DWORD, | |
| Attributes : DWORDLONG, | |
| }; | |
| PGET_DISK_ATTRIBUTES :: ^GET_DISK_ATTRIBUTES; | |
| SET_DISK_ATTRIBUTES :: struct { | |
| Version : DWORD, | |
| Persist : BOOLEAN, | |
| Reserved1 : [3]BYTE, | |
| Attributes : DWORDLONG, | |
| AttributesMask : DWORDLONG, | |
| Reserved2 : [4]DWORD, | |
| }; | |
| PSET_DISK_ATTRIBUTES :: ^SET_DISK_ATTRIBUTES; | |
| /* ELEMENT_TYPE :: enum { */ | |
| ELEMENT_TYPE :: _c.int; | |
| AllElements :: 0; | |
| ChangerTransport :: AllElements + 1; | |
| ChangerSlot :: ChangerTransport + 1; | |
| ChangerIEPort :: ChangerSlot + 1; | |
| ChangerDrive :: ChangerIEPort + 1; | |
| ChangerDoor :: ChangerDrive + 1; | |
| ChangerKeypad :: ChangerDoor + 1; | |
| ChangerMaxElement :: ChangerKeypad + 1; | |
| /* } */ | |
| PELEMENT_TYPE :: ^ELEMENT_TYPE; | |
| CHANGER_ELEMENT :: struct { | |
| ElementType : ELEMENT_TYPE, | |
| ElementAddress : DWORD, | |
| }; | |
| PCHANGER_ELEMENT :: ^CHANGER_ELEMENT; | |
| CHANGER_ELEMENT_LIST :: struct { | |
| Element : CHANGER_ELEMENT, | |
| NumberOfElements : DWORD, | |
| }; | |
| PCHANGER_ELEMENT_LIST :: ^CHANGER_ELEMENT_LIST; | |
| GET_CHANGER_PARAMETERS :: struct { | |
| Size : DWORD, | |
| NumberTransportElements : WORD, | |
| NumberStorageElements : WORD, | |
| NumberCleanerSlots : WORD, | |
| NumberIEElements : WORD, | |
| NumberDataTransferElements : WORD, | |
| NumberOfDoors : WORD, | |
| FirstSlotNumber : WORD, | |
| FirstDriveNumber : WORD, | |
| FirstTransportNumber : WORD, | |
| FirstIEPortNumber : WORD, | |
| FirstCleanerSlotAddress : WORD, | |
| MagazineSize : WORD, | |
| DriveCleanTimeout : DWORD, | |
| Features0 : DWORD, | |
| Features1 : DWORD, | |
| MoveFromTransport : BYTE, | |
| MoveFromSlot : BYTE, | |
| MoveFromIePort : BYTE, | |
| MoveFromDrive : BYTE, | |
| ExchangeFromTransport : BYTE, | |
| ExchangeFromSlot : BYTE, | |
| ExchangeFromIePort : BYTE, | |
| ExchangeFromDrive : BYTE, | |
| LockUnlockCapabilities : BYTE, | |
| PositionCapabilities : BYTE, | |
| Reserved1 : [2]BYTE, | |
| Reserved2 : [2]DWORD, | |
| }; | |
| PGET_CHANGER_PARAMETERS :: ^GET_CHANGER_PARAMETERS; | |
| CHANGER_PRODUCT_DATA :: struct { | |
| VendorId : [8]BYTE, | |
| ProductId : [16]BYTE, | |
| Revision : [4]BYTE, | |
| SerialNumber : [32]BYTE, | |
| DeviceType : BYTE, | |
| }; | |
| PCHANGER_PRODUCT_DATA :: ^CHANGER_PRODUCT_DATA; | |
| CHANGER_SET_ACCESS :: struct { | |
| Element : CHANGER_ELEMENT, | |
| Control : DWORD, | |
| }; | |
| PCHANGER_SET_ACCESS :: ^CHANGER_SET_ACCESS; | |
| CHANGER_READ_ELEMENT_STATUS :: struct { | |
| ElementList : CHANGER_ELEMENT_LIST, | |
| VolumeTagInfo : BOOLEAN, | |
| }; | |
| PCHANGER_READ_ELEMENT_STATUS :: ^CHANGER_READ_ELEMENT_STATUS; | |
| CHANGER_ELEMENT_STATUS :: struct { | |
| Element : CHANGER_ELEMENT, | |
| SrcElementAddress : CHANGER_ELEMENT, | |
| Flags : DWORD, | |
| ExceptionCode : DWORD, | |
| TargetId : BYTE, | |
| Lun : BYTE, | |
| Reserved : WORD, | |
| PrimaryVolumeID : [36]BYTE, | |
| AlternateVolumeID : [36]BYTE, | |
| }; | |
| PCHANGER_ELEMENT_STATUS :: ^CHANGER_ELEMENT_STATUS; | |
| CHANGER_ELEMENT_STATUS_EX :: struct { | |
| Element : CHANGER_ELEMENT, | |
| SrcElementAddress : CHANGER_ELEMENT, | |
| Flags : DWORD, | |
| ExceptionCode : DWORD, | |
| TargetId : BYTE, | |
| Lun : BYTE, | |
| Reserved : WORD, | |
| PrimaryVolumeID : [36]BYTE, | |
| AlternateVolumeID : [36]BYTE, | |
| VendorIdentification : [8]BYTE, | |
| ProductIdentification : [16]BYTE, | |
| SerialNumber : [32]BYTE, | |
| }; | |
| PCHANGER_ELEMENT_STATUS_EX :: ^CHANGER_ELEMENT_STATUS_EX; | |
| CHANGER_INITIALIZE_ELEMENT_STATUS :: struct { | |
| ElementList : CHANGER_ELEMENT_LIST, | |
| BarCodeScan : BOOLEAN, | |
| }; | |
| PCHANGER_INITIALIZE_ELEMENT_STATUS :: ^CHANGER_INITIALIZE_ELEMENT_STATUS; | |
| CHANGER_SET_POSITION :: struct { | |
| Transport : CHANGER_ELEMENT, | |
| Destination : CHANGER_ELEMENT, | |
| Flip : BOOLEAN, | |
| }; | |
| PCHANGER_SET_POSITION :: ^CHANGER_SET_POSITION; | |
| CHANGER_EXCHANGE_MEDIUM :: struct { | |
| Transport : CHANGER_ELEMENT, | |
| Source : CHANGER_ELEMENT, | |
| Destination1 : CHANGER_ELEMENT, | |
| Destination2 : CHANGER_ELEMENT, | |
| Flip1 : BOOLEAN, | |
| Flip2 : BOOLEAN, | |
| }; | |
| PCHANGER_EXCHANGE_MEDIUM :: ^CHANGER_EXCHANGE_MEDIUM; | |
| CHANGER_MOVE_MEDIUM :: struct { | |
| Transport : CHANGER_ELEMENT, | |
| Source : CHANGER_ELEMENT, | |
| Destination : CHANGER_ELEMENT, | |
| Flip : BOOLEAN, | |
| }; | |
| PCHANGER_MOVE_MEDIUM :: ^CHANGER_MOVE_MEDIUM; | |
| CHANGER_SEND_VOLUME_TAG_INFORMATION :: struct { | |
| StartingElement : CHANGER_ELEMENT, | |
| ActionCode : DWORD, | |
| VolumeIDTemplate : [40]BYTE, | |
| }; | |
| PCHANGER_SEND_VOLUME_TAG_INFORMATION :: ^CHANGER_SEND_VOLUME_TAG_INFORMATION; | |
| READ_ELEMENT_ADDRESS_INFO :: struct { | |
| NumberOfElements : DWORD, | |
| ElementStatus : [1]CHANGER_ELEMENT_STATUS, | |
| }; | |
| PREAD_ELEMENT_ADDRESS_INFO :: ^READ_ELEMENT_ADDRESS_INFO; | |
| /* CHANGER_DEVICE_PROBLEM_TYPE :: enum { */ | |
| CHANGER_DEVICE_PROBLEM_TYPE :: _c.int; | |
| DeviceProblemNone :: 0; | |
| DeviceProblemHardware :: DeviceProblemNone + 1; | |
| DeviceProblemCHMError :: DeviceProblemHardware + 1; | |
| DeviceProblemDoorOpen :: DeviceProblemCHMError + 1; | |
| DeviceProblemCalibrationError :: DeviceProblemDoorOpen + 1; | |
| DeviceProblemTargetFailure :: DeviceProblemCalibrationError + 1; | |
| DeviceProblemCHMMoveError :: DeviceProblemTargetFailure + 1; | |
| DeviceProblemCHMZeroError :: DeviceProblemCHMMoveError + 1; | |
| DeviceProblemCartridgeInsertError :: DeviceProblemCHMZeroError + 1; | |
| DeviceProblemPositionError :: DeviceProblemCartridgeInsertError + 1; | |
| DeviceProblemSensorError :: DeviceProblemPositionError + 1; | |
| DeviceProblemCartridgeEjectError :: DeviceProblemSensorError + 1; | |
| DeviceProblemGripperError :: DeviceProblemCartridgeEjectError + 1; | |
| DeviceProblemDriveError :: DeviceProblemGripperError + 1; | |
| /* } */ | |
| PCHANGER_DEVICE_PROBLEM_TYPE :: ^CHANGER_DEVICE_PROBLEM_TYPE; | |
| PATHNAME_BUFFER :: struct { | |
| PathNameLength : DWORD, | |
| Name : [1]WCHAR, | |
| }; | |
| PPATHNAME_BUFFER :: ^PATHNAME_BUFFER; | |
| FSCTL_QUERY_FAT_BPB_BUFFER :: struct { | |
| First0x24BytesOfBootSector : [0x24]BYTE, | |
| }; | |
| PFSCTL_QUERY_FAT_BPB_BUFFER :: ^FSCTL_QUERY_FAT_BPB_BUFFER; | |
| NTFS_VOLUME_DATA_BUFFER :: struct { | |
| VolumeSerialNumber : LARGE_INTEGER, | |
| NumberSectors : LARGE_INTEGER, | |
| TotalClusters : LARGE_INTEGER, | |
| FreeClusters : LARGE_INTEGER, | |
| TotalReserved : LARGE_INTEGER, | |
| BytesPerSector : DWORD, | |
| BytesPerCluster : DWORD, | |
| BytesPerFileRecordSegment : DWORD, | |
| ClustersPerFileRecordSegment : DWORD, | |
| MftValidDataLength : LARGE_INTEGER, | |
| MftStartLcn : LARGE_INTEGER, | |
| Mft2StartLcn : LARGE_INTEGER, | |
| MftZoneStart : LARGE_INTEGER, | |
| MftZoneEnd : LARGE_INTEGER, | |
| }; | |
| PNTFS_VOLUME_DATA_BUFFER :: ^NTFS_VOLUME_DATA_BUFFER; | |
| NTFS_EXTENDED_VOLUME_DATA :: struct { | |
| ByteCount : DWORD, | |
| MajorVersion : WORD, | |
| MinorVersion : WORD, | |
| BytesPerPhysicalSector : DWORD, | |
| LfsMajorVersion : WORD, | |
| LfsMinorVersion : WORD, | |
| MaxDeviceTrimExtentCount : DWORD, | |
| MaxDeviceTrimByteCount : DWORD, | |
| MaxVolumeTrimExtentCount : DWORD, | |
| MaxVolumeTrimByteCount : DWORD, | |
| }; | |
| PNTFS_EXTENDED_VOLUME_DATA :: ^NTFS_EXTENDED_VOLUME_DATA; | |
| REFS_VOLUME_DATA_BUFFER :: struct { | |
| ByteCount : DWORD, | |
| MajorVersion : DWORD, | |
| MinorVersion : DWORD, | |
| BytesPerPhysicalSector : DWORD, | |
| VolumeSerialNumber : LARGE_INTEGER, | |
| NumberSectors : LARGE_INTEGER, | |
| TotalClusters : LARGE_INTEGER, | |
| FreeClusters : LARGE_INTEGER, | |
| TotalReserved : LARGE_INTEGER, | |
| BytesPerSector : DWORD, | |
| BytesPerCluster : DWORD, | |
| MaximumSizeOfResidentFile : LARGE_INTEGER, | |
| Reserved : [10]LARGE_INTEGER, | |
| }; | |
| PREFS_VOLUME_DATA_BUFFER :: ^REFS_VOLUME_DATA_BUFFER; | |
| STARTING_LCN_INPUT_BUFFER :: struct { | |
| StartingLcn : LARGE_INTEGER, | |
| }; | |
| PSTARTING_LCN_INPUT_BUFFER :: ^STARTING_LCN_INPUT_BUFFER; | |
| STARTING_LCN_INPUT_BUFFER_EX :: struct { | |
| StartingLcn : LARGE_INTEGER, | |
| Flags : DWORD, | |
| }; | |
| PSTARTING_LCN_INPUT_BUFFER_EX :: ^STARTING_LCN_INPUT_BUFFER_EX; | |
| VOLUME_BITMAP_BUFFER :: struct { | |
| StartingLcn : LARGE_INTEGER, | |
| BitmapSize : LARGE_INTEGER, | |
| Buffer : [1]BYTE, | |
| }; | |
| PVOLUME_BITMAP_BUFFER :: ^VOLUME_BITMAP_BUFFER; | |
| STARTING_VCN_INPUT_BUFFER :: struct { | |
| StartingVcn : LARGE_INTEGER, | |
| }; | |
| PSTARTING_VCN_INPUT_BUFFER :: ^STARTING_VCN_INPUT_BUFFER; | |
| RETRIEVAL_POINTERS_BUFFER :: struct { | |
| ExtentCount : DWORD, | |
| StartingVcn : LARGE_INTEGER, | |
| Extents : [1]struct { | |
| NextVcn : LARGE_INTEGER, | |
| Lcn : LARGE_INTEGER, | |
| }, | |
| }; | |
| PRETRIEVAL_POINTERS_BUFFER :: ^RETRIEVAL_POINTERS_BUFFER; | |
| RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER :: struct { | |
| ExtentCount : DWORD, | |
| StartingVcn : LARGE_INTEGER, | |
| Extents : [1]struct { | |
| NextVcn : LARGE_INTEGER, | |
| Lcn : LARGE_INTEGER, | |
| ReferenceCount : DWORD, | |
| }, | |
| }; | |
| PRETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER :: ^RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER; | |
| RETRIEVAL_POINTER_COUNT :: struct { | |
| ExtentCount : DWORD, | |
| }; | |
| PRETRIEVAL_POINTER_COUNT :: ^RETRIEVAL_POINTER_COUNT; | |
| NTFS_FILE_RECORD_INPUT_BUFFER :: struct { | |
| FileReferenceNumber : LARGE_INTEGER, | |
| }; | |
| PNTFS_FILE_RECORD_INPUT_BUFFER :: ^NTFS_FILE_RECORD_INPUT_BUFFER; | |
| NTFS_FILE_RECORD_OUTPUT_BUFFER :: struct { | |
| FileReferenceNumber : LARGE_INTEGER, | |
| FileRecordLength : DWORD, | |
| FileRecordBuffer : [1]BYTE, | |
| }; | |
| PNTFS_FILE_RECORD_OUTPUT_BUFFER :: ^NTFS_FILE_RECORD_OUTPUT_BUFFER; | |
| MOVE_FILE_DATA :: struct { | |
| FileHandle : HANDLE, | |
| StartingVcn : LARGE_INTEGER, | |
| StartingLcn : LARGE_INTEGER, | |
| ClusterCount : DWORD, | |
| }; | |
| PMOVE_FILE_DATA :: ^MOVE_FILE_DATA; | |
| MOVE_FILE_RECORD_DATA :: struct { | |
| FileHandle : HANDLE, | |
| SourceFileRecord : LARGE_INTEGER, | |
| TargetFileRecord : LARGE_INTEGER, | |
| }; | |
| PMOVE_FILE_RECORD_DATA :: ^MOVE_FILE_RECORD_DATA; | |
| MOVE_FILE_DATA32 :: struct { | |
| FileHandle : UINT32, | |
| StartingVcn : LARGE_INTEGER, | |
| StartingLcn : LARGE_INTEGER, | |
| ClusterCount : DWORD, | |
| }; | |
| PMOVE_FILE_DATA32 :: ^MOVE_FILE_DATA32; | |
| FIND_BY_SID_DATA :: struct { | |
| Restart : DWORD, | |
| Sid : SID, | |
| }; | |
| PFIND_BY_SID_DATA :: ^FIND_BY_SID_DATA; | |
| FIND_BY_SID_OUTPUT :: struct { | |
| NextEntryOffset : DWORD, | |
| FileIndex : DWORD, | |
| FileNameLength : DWORD, | |
| FileName : [1]WCHAR, | |
| }; | |
| PFIND_BY_SID_OUTPUT :: ^FIND_BY_SID_OUTPUT; | |
| MFT_ENUM_DATA_V0 :: struct { | |
| StartFileReferenceNumber : DWORDLONG, | |
| LowUsn : USN, | |
| HighUsn : USN, | |
| }; | |
| PMFT_ENUM_DATA_V0 :: ^MFT_ENUM_DATA_V0; | |
| MFT_ENUM_DATA_V1 :: struct { | |
| StartFileReferenceNumber : DWORDLONG, | |
| LowUsn : USN, | |
| HighUsn : USN, | |
| MinMajorVersion : WORD, | |
| MaxMajorVersion : WORD, | |
| }; | |
| PMFT_ENUM_DATA_V1 :: ^MFT_ENUM_DATA_V1; | |
| MFT_ENUM_DATA :: MFT_ENUM_DATA_V1; | |
| PMFT_ENUM_DATA :: ^MFT_ENUM_DATA_V1; | |
| CREATE_USN_JOURNAL_DATA :: struct { | |
| MaximumSize : DWORDLONG, | |
| AllocationDelta : DWORDLONG, | |
| }; | |
| PCREATE_USN_JOURNAL_DATA :: ^CREATE_USN_JOURNAL_DATA; | |
| READ_FILE_USN_DATA :: struct { | |
| MinMajorVersion : WORD, | |
| MaxMajorVersion : WORD, | |
| }; | |
| PREAD_FILE_USN_DATA :: ^READ_FILE_USN_DATA; | |
| READ_USN_JOURNAL_DATA_V0 :: struct { | |
| StartUsn : USN, | |
| ReasonMask : DWORD, | |
| ReturnOnlyOnClose : DWORD, | |
| Timeout : DWORDLONG, | |
| BytesToWaitFor : DWORDLONG, | |
| UsnJournalID : DWORDLONG, | |
| }; | |
| PREAD_USN_JOURNAL_DATA_V0 :: ^READ_USN_JOURNAL_DATA_V0; | |
| READ_USN_JOURNAL_DATA_V1 :: struct { | |
| StartUsn : USN, | |
| ReasonMask : DWORD, | |
| ReturnOnlyOnClose : DWORD, | |
| Timeout : DWORDLONG, | |
| BytesToWaitFor : DWORDLONG, | |
| UsnJournalID : DWORDLONG, | |
| MinMajorVersion : WORD, | |
| MaxMajorVersion : WORD, | |
| }; | |
| PREAD_USN_JOURNAL_DATA_V1 :: ^READ_USN_JOURNAL_DATA_V1; | |
| READ_USN_JOURNAL_DATA :: READ_USN_JOURNAL_DATA_V1; | |
| PREAD_USN_JOURNAL_DATA :: ^READ_USN_JOURNAL_DATA_V1; | |
| USN_TRACK_MODIFIED_RANGES :: struct { | |
| Flags : DWORD, | |
| Unused : DWORD, | |
| ChunkSize : DWORDLONG, | |
| FileSizeThreshold : LONGLONG, | |
| }; | |
| PUSN_TRACK_MODIFIED_RANGES :: ^USN_TRACK_MODIFIED_RANGES; | |
| USN_RANGE_TRACK_OUTPUT :: struct { | |
| Usn : USN, | |
| }; | |
| PUSN_RANGE_TRACK_OUTPUT :: ^USN_RANGE_TRACK_OUTPUT; | |
| USN_RECORD_V2 :: struct { | |
| RecordLength : DWORD, | |
| MajorVersion : WORD, | |
| MinorVersion : WORD, | |
| FileReferenceNumber : DWORDLONG, | |
| ParentFileReferenceNumber : DWORDLONG, | |
| Usn : USN, | |
| TimeStamp : LARGE_INTEGER, | |
| Reason : DWORD, | |
| SourceInfo : DWORD, | |
| SecurityId : DWORD, | |
| FileAttributes : DWORD, | |
| FileNameLength : WORD, | |
| FileNameOffset : WORD, | |
| FileName : [1]WCHAR, | |
| }; | |
| PUSN_RECORD_V2 :: ^USN_RECORD_V2; | |
| USN_RECORD_V3 :: struct { | |
| RecordLength : DWORD, | |
| MajorVersion : WORD, | |
| MinorVersion : WORD, | |
| FileReferenceNumber : FILE_ID_128, | |
| ParentFileReferenceNumber : FILE_ID_128, | |
| Usn : USN, | |
| TimeStamp : LARGE_INTEGER, | |
| Reason : DWORD, | |
| SourceInfo : DWORD, | |
| SecurityId : DWORD, | |
| FileAttributes : DWORD, | |
| FileNameLength : WORD, | |
| FileNameOffset : WORD, | |
| FileName : [1]WCHAR, | |
| }; | |
| PUSN_RECORD_V3 :: ^USN_RECORD_V3; | |
| USN_RECORD :: USN_RECORD_V2; | |
| PUSN_RECORD :: ^USN_RECORD_V2; | |
| USN_RECORD_COMMON_HEADER :: struct { | |
| RecordLength : DWORD, | |
| MajorVersion : WORD, | |
| MinorVersion : WORD, | |
| }; | |
| PUSN_RECORD_COMMON_HEADER :: ^USN_RECORD_COMMON_HEADER; | |
| USN_RECORD_EXTENT :: struct { | |
| Offset : LONGLONG, | |
| Length : LONGLONG, | |
| }; | |
| PUSN_RECORD_EXTENT :: ^USN_RECORD_EXTENT; | |
| USN_RECORD_V4 :: struct { | |
| Header : USN_RECORD_COMMON_HEADER, | |
| FileReferenceNumber : FILE_ID_128, | |
| ParentFileReferenceNumber : FILE_ID_128, | |
| Usn : USN, | |
| Reason : DWORD, | |
| SourceInfo : DWORD, | |
| RemainingExtents : DWORD, | |
| NumberOfExtents : WORD, | |
| ExtentSize : WORD, | |
| Extents : [1]USN_RECORD_EXTENT, | |
| }; | |
| PUSN_RECORD_V4 :: ^USN_RECORD_V4; | |
| USN_RECORD_UNION :: struct #raw_union { | |
| Header : USN_RECORD_COMMON_HEADER, | |
| V2 : USN_RECORD_V2, | |
| V3 : USN_RECORD_V3, | |
| V4 : USN_RECORD_V4, | |
| }; | |
| PUSN_RECORD_UNION :: ^USN_RECORD_UNION; | |
| USN_JOURNAL_DATA_V0 :: struct { | |
| UsnJournalID : DWORDLONG, | |
| FirstUsn : USN, | |
| NextUsn : USN, | |
| LowestValidUsn : USN, | |
| MaxUsn : USN, | |
| MaximumSize : DWORDLONG, | |
| AllocationDelta : DWORDLONG, | |
| }; | |
| PUSN_JOURNAL_DATA_V0 :: ^USN_JOURNAL_DATA_V0; | |
| USN_JOURNAL_DATA_V1 :: struct { | |
| UsnJournalID : DWORDLONG, | |
| FirstUsn : USN, | |
| NextUsn : USN, | |
| LowestValidUsn : USN, | |
| MaxUsn : USN, | |
| MaximumSize : DWORDLONG, | |
| AllocationDelta : DWORDLONG, | |
| MinSupportedMajorVersion : WORD, | |
| MaxSupportedMajorVersion : WORD, | |
| }; | |
| PUSN_JOURNAL_DATA_V1 :: ^USN_JOURNAL_DATA_V1; | |
| USN_JOURNAL_DATA_V2 :: struct { | |
| UsnJournalID : DWORDLONG, | |
| FirstUsn : USN, | |
| NextUsn : USN, | |
| LowestValidUsn : USN, | |
| MaxUsn : USN, | |
| MaximumSize : DWORDLONG, | |
| AllocationDelta : DWORDLONG, | |
| MinSupportedMajorVersion : WORD, | |
| MaxSupportedMajorVersion : WORD, | |
| Flags : DWORD, | |
| RangeTrackChunkSize : DWORDLONG, | |
| RangeTrackFileSizeThreshold : LONGLONG, | |
| }; | |
| PUSN_JOURNAL_DATA_V2 :: ^USN_JOURNAL_DATA_V2; | |
| USN_JOURNAL_DATA :: USN_JOURNAL_DATA_V1; | |
| PUSN_JOURNAL_DATA :: ^USN_JOURNAL_DATA_V1; | |
| DELETE_USN_JOURNAL_DATA :: struct { | |
| UsnJournalID : DWORDLONG, | |
| DeleteFlags : DWORD, | |
| }; | |
| PDELETE_USN_JOURNAL_DATA :: ^DELETE_USN_JOURNAL_DATA; | |
| MARK_HANDLE_INFO :: struct { | |
| u : struct #raw_union { | |
| UsnSourceInfo : DWORD, | |
| CopyNumber : DWORD, | |
| }, | |
| VolumeHandle : HANDLE, | |
| HandleInfo : DWORD, | |
| }; | |
| PMARK_HANDLE_INFO :: ^MARK_HANDLE_INFO; | |
| MARK_HANDLE_INFO32 :: struct { | |
| u : struct #raw_union { | |
| UsnSourceInfo : DWORD, | |
| CopyNumber : DWORD, | |
| }, | |
| VolumeHandle : UINT32, | |
| HandleInfo : DWORD, | |
| }; | |
| PMARK_HANDLE_INFO32 :: ^MARK_HANDLE_INFO32; | |
| BULK_SECURITY_TEST_DATA :: struct { | |
| DesiredAccess : ACCESS_MASK, | |
| SecurityIds : [1]DWORD, | |
| }; | |
| PBULK_SECURITY_TEST_DATA :: ^BULK_SECURITY_TEST_DATA; | |
| FILE_PREFETCH :: struct { | |
| Type : DWORD, | |
| Count : DWORD, | |
| Prefetch : [1]DWORDLONG, | |
| }; | |
| PFILE_PREFETCH :: ^FILE_PREFETCH; | |
| FILE_PREFETCH_EX :: struct { | |
| Type : DWORD, | |
| Count : DWORD, | |
| Context : PVOID, | |
| Prefetch : [1]DWORDLONG, | |
| }; | |
| PFILE_PREFETCH_EX :: ^FILE_PREFETCH_EX; | |
| FILESYSTEM_STATISTICS :: struct { | |
| FileSystemType : WORD, | |
| Version : WORD, | |
| SizeOfCompleteStructure : DWORD, | |
| UserFileReads : DWORD, | |
| UserFileReadBytes : DWORD, | |
| UserDiskReads : DWORD, | |
| UserFileWrites : DWORD, | |
| UserFileWriteBytes : DWORD, | |
| UserDiskWrites : DWORD, | |
| MetaDataReads : DWORD, | |
| MetaDataReadBytes : DWORD, | |
| MetaDataDiskReads : DWORD, | |
| MetaDataWrites : DWORD, | |
| MetaDataWriteBytes : DWORD, | |
| MetaDataDiskWrites : DWORD, | |
| }; | |
| PFILESYSTEM_STATISTICS :: ^FILESYSTEM_STATISTICS; | |
| FAT_STATISTICS :: struct { | |
| CreateHits : DWORD, | |
| SuccessfulCreates : DWORD, | |
| FailedCreates : DWORD, | |
| NonCachedReads : DWORD, | |
| NonCachedReadBytes : DWORD, | |
| NonCachedWrites : DWORD, | |
| NonCachedWriteBytes : DWORD, | |
| NonCachedDiskReads : DWORD, | |
| NonCachedDiskWrites : DWORD, | |
| }; | |
| PFAT_STATISTICS :: ^FAT_STATISTICS; | |
| EXFAT_STATISTICS :: struct { | |
| CreateHits : DWORD, | |
| SuccessfulCreates : DWORD, | |
| FailedCreates : DWORD, | |
| NonCachedReads : DWORD, | |
| NonCachedReadBytes : DWORD, | |
| NonCachedWrites : DWORD, | |
| NonCachedWriteBytes : DWORD, | |
| NonCachedDiskReads : DWORD, | |
| NonCachedDiskWrites : DWORD, | |
| }; | |
| PEXFAT_STATISTICS :: ^EXFAT_STATISTICS; | |
| NTFS_STATISTICS :: struct { | |
| LogFileFullExceptions : DWORD, | |
| OtherExceptions : DWORD, | |
| MftReads : DWORD, | |
| MftReadBytes : DWORD, | |
| MftWrites : DWORD, | |
| MftWriteBytes : DWORD, | |
| MftWritesUserLevel : struct { | |
| Write : WORD, | |
| Create : WORD, | |
| SetInfo : WORD, | |
| Flush : WORD, | |
| }, | |
| MftWritesFlushForLogFileFull : WORD, | |
| MftWritesLazyWriter : WORD, | |
| MftWritesUserRequest : WORD, | |
| Mft2Writes : DWORD, | |
| Mft2WriteBytes : DWORD, | |
| Mft2WritesUserLevel : struct { | |
| Write : WORD, | |
| Create : WORD, | |
| SetInfo : WORD, | |
| Flush : WORD, | |
| }, | |
| Mft2WritesFlushForLogFileFull : WORD, | |
| Mft2WritesLazyWriter : WORD, | |
| Mft2WritesUserRequest : WORD, | |
| RootIndexReads : DWORD, | |
| RootIndexReadBytes : DWORD, | |
| RootIndexWrites : DWORD, | |
| RootIndexWriteBytes : DWORD, | |
| BitmapReads : DWORD, | |
| BitmapReadBytes : DWORD, | |
| BitmapWrites : DWORD, | |
| BitmapWriteBytes : DWORD, | |
| BitmapWritesFlushForLogFileFull : WORD, | |
| BitmapWritesLazyWriter : WORD, | |
| BitmapWritesUserRequest : WORD, | |
| BitmapWritesUserLevel : struct { | |
| Write : WORD, | |
| Create : WORD, | |
| SetInfo : WORD, | |
| }, | |
| MftBitmapReads : DWORD, | |
| MftBitmapReadBytes : DWORD, | |
| MftBitmapWrites : DWORD, | |
| MftBitmapWriteBytes : DWORD, | |
| MftBitmapWritesFlushForLogFileFull : WORD, | |
| MftBitmapWritesLazyWriter : WORD, | |
| MftBitmapWritesUserRequest : WORD, | |
| MftBitmapWritesUserLevel : struct { | |
| Write : WORD, | |
| Create : WORD, | |
| SetInfo : WORD, | |
| Flush : WORD, | |
| }, | |
| UserIndexReads : DWORD, | |
| UserIndexReadBytes : DWORD, | |
| UserIndexWrites : DWORD, | |
| UserIndexWriteBytes : DWORD, | |
| LogFileReads : DWORD, | |
| LogFileReadBytes : DWORD, | |
| LogFileWrites : DWORD, | |
| LogFileWriteBytes : DWORD, | |
| Allocate : struct { | |
| Calls : DWORD, | |
| Clusters : DWORD, | |
| Hints : DWORD, | |
| RunsReturned : DWORD, | |
| HintsHonored : DWORD, | |
| HintsClusters : DWORD, | |
| Cache : DWORD, | |
| CacheClusters : DWORD, | |
| CacheMiss : DWORD, | |
| CacheMissClusters : DWORD, | |
| }, | |
| DiskResourcesExhausted : DWORD, | |
| }; | |
| PNTFS_STATISTICS :: ^NTFS_STATISTICS; | |
| FILESYSTEM_STATISTICS_EX :: struct { | |
| FileSystemType : WORD, | |
| Version : WORD, | |
| SizeOfCompleteStructure : DWORD, | |
| UserFileReads : DWORDLONG, | |
| UserFileReadBytes : DWORDLONG, | |
| UserDiskReads : DWORDLONG, | |
| UserFileWrites : DWORDLONG, | |
| UserFileWriteBytes : DWORDLONG, | |
| UserDiskWrites : DWORDLONG, | |
| MetaDataReads : DWORDLONG, | |
| MetaDataReadBytes : DWORDLONG, | |
| MetaDataDiskReads : DWORDLONG, | |
| MetaDataWrites : DWORDLONG, | |
| MetaDataWriteBytes : DWORDLONG, | |
| MetaDataDiskWrites : DWORDLONG, | |
| }; | |
| PFILESYSTEM_STATISTICS_EX :: ^FILESYSTEM_STATISTICS_EX; | |
| NTFS_STATISTICS_EX :: struct { | |
| LogFileFullExceptions : DWORD, | |
| OtherExceptions : DWORD, | |
| MftReads : DWORDLONG, | |
| MftReadBytes : DWORDLONG, | |
| MftWrites : DWORDLONG, | |
| MftWriteBytes : DWORDLONG, | |
| MftWritesUserLevel : struct { | |
| Write : DWORD, | |
| Create : DWORD, | |
| SetInfo : DWORD, | |
| Flush : DWORD, | |
| }, | |
| MftWritesFlushForLogFileFull : DWORD, | |
| MftWritesLazyWriter : DWORD, | |
| MftWritesUserRequest : DWORD, | |
| Mft2Writes : DWORDLONG, | |
| Mft2WriteBytes : DWORDLONG, | |
| Mft2WritesUserLevel : struct { | |
| Write : DWORD, | |
| Create : DWORD, | |
| SetInfo : DWORD, | |
| Flush : DWORD, | |
| }, | |
| Mft2WritesFlushForLogFileFull : DWORD, | |
| Mft2WritesLazyWriter : DWORD, | |
| Mft2WritesUserRequest : DWORD, | |
| RootIndexReads : DWORDLONG, | |
| RootIndexReadBytes : DWORDLONG, | |
| RootIndexWrites : DWORDLONG, | |
| RootIndexWriteBytes : DWORDLONG, | |
| BitmapReads : DWORDLONG, | |
| BitmapReadBytes : DWORDLONG, | |
| BitmapWrites : DWORDLONG, | |
| BitmapWriteBytes : DWORDLONG, | |
| BitmapWritesFlushForLogFileFull : DWORD, | |
| BitmapWritesLazyWriter : DWORD, | |
| BitmapWritesUserRequest : DWORD, | |
| BitmapWritesUserLevel : struct { | |
| Write : DWORD, | |
| Create : DWORD, | |
| SetInfo : DWORD, | |
| Flush : DWORD, | |
| }, | |
| MftBitmapReads : DWORDLONG, | |
| MftBitmapReadBytes : DWORDLONG, | |
| MftBitmapWrites : DWORDLONG, | |
| MftBitmapWriteBytes : DWORDLONG, | |
| MftBitmapWritesFlushForLogFileFull : DWORD, | |
| MftBitmapWritesLazyWriter : DWORD, | |
| MftBitmapWritesUserRequest : DWORD, | |
| MftBitmapWritesUserLevel : struct { | |
| Write : DWORD, | |
| Create : DWORD, | |
| SetInfo : DWORD, | |
| Flush : DWORD, | |
| }, | |
| UserIndexReads : DWORDLONG, | |
| UserIndexReadBytes : DWORDLONG, | |
| UserIndexWrites : DWORDLONG, | |
| UserIndexWriteBytes : DWORDLONG, | |
| LogFileReads : DWORDLONG, | |
| LogFileReadBytes : DWORDLONG, | |
| LogFileWrites : DWORDLONG, | |
| LogFileWriteBytes : DWORDLONG, | |
| Allocate : struct { | |
| Calls : DWORD, | |
| RunsReturned : DWORD, | |
| Hints : DWORD, | |
| HintsHonored : DWORD, | |
| Cache : DWORD, | |
| CacheMiss : DWORD, | |
| Clusters : DWORDLONG, | |
| HintsClusters : DWORDLONG, | |
| CacheClusters : DWORDLONG, | |
| CacheMissClusters : DWORDLONG, | |
| }, | |
| DiskResourcesExhausted : DWORD, | |
| VolumeTrimCount : DWORDLONG, | |
| VolumeTrimTime : DWORDLONG, | |
| VolumeTrimByteCount : DWORDLONG, | |
| FileLevelTrimCount : DWORDLONG, | |
| FileLevelTrimTime : DWORDLONG, | |
| FileLevelTrimByteCount : DWORDLONG, | |
| VolumeTrimSkippedCount : DWORDLONG, | |
| VolumeTrimSkippedByteCount : DWORDLONG, | |
| NtfsFillStatInfoFromMftRecordCalledCount : DWORDLONG, | |
| NtfsFillStatInfoFromMftRecordBailedBecauseOfAttributeListCount : DWORDLONG, | |
| NtfsFillStatInfoFromMftRecordBailedBecauseOfNonResReparsePointCount : DWORDLONG, | |
| }; | |
| PNTFS_STATISTICS_EX :: ^NTFS_STATISTICS_EX; | |
| FILE_OBJECTID_BUFFER :: struct { | |
| ObjectId : [16]BYTE, | |
| u : struct #raw_union { | |
| s : struct { | |
| BirthVolumeId : [16]BYTE, | |
| BirthObjectId : [16]BYTE, | |
| DomainId : [16]BYTE, | |
| }, | |
| ExtendedInfo : [48]BYTE, | |
| }, | |
| }; | |
| PFILE_OBJECTID_BUFFER :: ^FILE_OBJECTID_BUFFER; | |
| FILE_SET_SPARSE_BUFFER :: struct { | |
| SetSparse : BOOLEAN, | |
| }; | |
| PFILE_SET_SPARSE_BUFFER :: ^FILE_SET_SPARSE_BUFFER; | |
| FILE_ZERO_DATA_INFORMATION :: struct { | |
| FileOffset : LARGE_INTEGER, | |
| BeyondFinalZero : LARGE_INTEGER, | |
| }; | |
| PFILE_ZERO_DATA_INFORMATION :: ^FILE_ZERO_DATA_INFORMATION; | |
| FILE_ZERO_DATA_INFORMATION_EX :: struct { | |
| FileOffset : LARGE_INTEGER, | |
| BeyondFinalZero : LARGE_INTEGER, | |
| Flags : DWORD, | |
| }; | |
| PFILE_ZERO_DATA_INFORMATION_EX :: ^FILE_ZERO_DATA_INFORMATION_EX; | |
| FILE_ALLOCATED_RANGE_BUFFER :: struct { | |
| FileOffset : LARGE_INTEGER, | |
| Length : LARGE_INTEGER, | |
| }; | |
| PFILE_ALLOCATED_RANGE_BUFFER :: ^FILE_ALLOCATED_RANGE_BUFFER; | |
| ENCRYPTION_BUFFER :: struct { | |
| EncryptionOperation : DWORD, | |
| Private : [1]BYTE, | |
| }; | |
| PENCRYPTION_BUFFER :: ^ENCRYPTION_BUFFER; | |
| DECRYPTION_STATUS_BUFFER :: struct { | |
| NoEncryptedStreams : BOOLEAN, | |
| }; | |
| PDECRYPTION_STATUS_BUFFER :: ^DECRYPTION_STATUS_BUFFER; | |
| REQUEST_RAW_ENCRYPTED_DATA :: struct { | |
| FileOffset : LONGLONG, | |
| Length : DWORD, | |
| }; | |
| PREQUEST_RAW_ENCRYPTED_DATA :: ^REQUEST_RAW_ENCRYPTED_DATA; | |
| ENCRYPTED_DATA_INFO :: struct { | |
| StartingFileOffset : DWORDLONG, | |
| OutputBufferOffset : DWORD, | |
| BytesWithinFileSize : DWORD, | |
| BytesWithinValidDataLength : DWORD, | |
| CompressionFormat : WORD, | |
| DataUnitShift : BYTE, | |
| ChunkShift : BYTE, | |
| ClusterShift : BYTE, | |
| EncryptionFormat : BYTE, | |
| NumberOfDataBlocks : WORD, | |
| DataBlockSize : [1]DWORD, | |
| }; | |
| PENCRYPTED_DATA_INFO :: ^ENCRYPTED_DATA_INFO; | |
| EXTENDED_ENCRYPTED_DATA_INFO :: struct { | |
| ExtendedCode : DWORD, | |
| Length : DWORD, | |
| Flags : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PEXTENDED_ENCRYPTED_DATA_INFO :: ^EXTENDED_ENCRYPTED_DATA_INFO; | |
| PLEX_READ_DATA_REQUEST :: struct { | |
| ByteOffset : LARGE_INTEGER, | |
| ByteLength : DWORD, | |
| PlexNumber : DWORD, | |
| }; | |
| PPLEX_READ_DATA_REQUEST :: ^PLEX_READ_DATA_REQUEST; | |
| SI_COPYFILE :: struct { | |
| SourceFileNameLength : DWORD, | |
| DestinationFileNameLength : DWORD, | |
| Flags : DWORD, | |
| FileNameBuffer : [1]WCHAR, | |
| }; | |
| PSI_COPYFILE :: ^SI_COPYFILE; | |
| FILE_MAKE_COMPATIBLE_BUFFER :: struct { | |
| CloseDisc : BOOLEAN, | |
| }; | |
| PFILE_MAKE_COMPATIBLE_BUFFER :: ^FILE_MAKE_COMPATIBLE_BUFFER; | |
| FILE_SET_DEFECT_MGMT_BUFFER :: struct { | |
| Disable : BOOLEAN, | |
| }; | |
| PFILE_SET_DEFECT_MGMT_BUFFER :: ^FILE_SET_DEFECT_MGMT_BUFFER; | |
| FILE_QUERY_SPARING_BUFFER :: struct { | |
| SparingUnitBytes : DWORD, | |
| SoftwareSparing : BOOLEAN, | |
| TotalSpareBlocks : DWORD, | |
| FreeSpareBlocks : DWORD, | |
| }; | |
| PFILE_QUERY_SPARING_BUFFER :: ^FILE_QUERY_SPARING_BUFFER; | |
| FILE_QUERY_ON_DISK_VOL_INFO_BUFFER :: struct { | |
| DirectoryCount : LARGE_INTEGER, | |
| FileCount : LARGE_INTEGER, | |
| FsFormatMajVersion : WORD, | |
| FsFormatMinVersion : WORD, | |
| FsFormatName : [12]WCHAR, | |
| FormatTime : LARGE_INTEGER, | |
| LastUpdateTime : LARGE_INTEGER, | |
| CopyrightInfo : [34]WCHAR, | |
| AbstractInfo : [34]WCHAR, | |
| FormattingImplementationInfo : [34]WCHAR, | |
| LastModifyingImplementationInfo : [34]WCHAR, | |
| }; | |
| PFILE_QUERY_ON_DISK_VOL_INFO_BUFFER :: ^FILE_QUERY_ON_DISK_VOL_INFO_BUFFER; | |
| CLSN :: DWORDLONG; | |
| FILE_INITIATE_REPAIR_OUTPUT_BUFFER :: struct { | |
| Hint1 : DWORDLONG, | |
| Hint2 : DWORDLONG, | |
| Clsn : CLSN, | |
| Status : DWORD, | |
| }; | |
| PFILE_INITIATE_REPAIR_OUTPUT_BUFFER :: ^FILE_INITIATE_REPAIR_OUTPUT_BUFFER; | |
| /* SHRINK_VOLUME_REQUEST_TYPES :: enum { */ | |
| SHRINK_VOLUME_REQUEST_TYPES :: _c.int; | |
| ShrinkPrepare :: 1; | |
| ShrinkCommit :: ShrinkPrepare + 1; | |
| ShrinkAbort :: ShrinkCommit + 1; | |
| /* } */ | |
| PSHRINK_VOLUME_REQUEST_TYPES :: ^SHRINK_VOLUME_REQUEST_TYPES; | |
| SHRINK_VOLUME_INFORMATION :: struct { | |
| ShrinkRequestType : SHRINK_VOLUME_REQUEST_TYPES, | |
| Flags : DWORDLONG, | |
| NewNumberOfSectors : LONGLONG, | |
| }; | |
| PSHRINK_VOLUME_INFORMATION :: ^SHRINK_VOLUME_INFORMATION; | |
| TXFS_MODIFY_RM :: struct { | |
| Flags : DWORD, | |
| LogContainerCountMax : DWORD, | |
| LogContainerCountMin : DWORD, | |
| LogContainerCount : DWORD, | |
| LogGrowthIncrement : DWORD, | |
| LogAutoShrinkPercentage : DWORD, | |
| Reserved : DWORDLONG, | |
| LoggingMode : WORD, | |
| }; | |
| PTXFS_MODIFY_RM :: ^TXFS_MODIFY_RM; | |
| TXFS_QUERY_RM_INFORMATION :: struct { | |
| BytesRequired : DWORD, | |
| TailLsn : DWORDLONG, | |
| CurrentLsn : DWORDLONG, | |
| ArchiveTailLsn : DWORDLONG, | |
| LogContainerSize : DWORDLONG, | |
| HighestVirtualClock : LARGE_INTEGER, | |
| LogContainerCount : DWORD, | |
| LogContainerCountMax : DWORD, | |
| LogContainerCountMin : DWORD, | |
| LogGrowthIncrement : DWORD, | |
| LogAutoShrinkPercentage : DWORD, | |
| Flags : DWORD, | |
| LoggingMode : WORD, | |
| Reserved : WORD, | |
| RmState : DWORD, | |
| LogCapacity : DWORDLONG, | |
| LogFree : DWORDLONG, | |
| TopsSize : DWORDLONG, | |
| TopsUsed : DWORDLONG, | |
| TransactionCount : DWORDLONG, | |
| OnePCCount : DWORDLONG, | |
| TwoPCCount : DWORDLONG, | |
| NumberLogFileFull : DWORDLONG, | |
| OldestTransactionAge : DWORDLONG, | |
| RMName : GUID, | |
| TmLogPathOffset : DWORD, | |
| }; | |
| PTXFS_QUERY_RM_INFORMATION :: ^TXFS_QUERY_RM_INFORMATION; | |
| TXFS_ROLLFORWARD_REDO_INFORMATION :: struct { | |
| LastVirtualClock : LARGE_INTEGER, | |
| LastRedoLsn : DWORDLONG, | |
| HighestRecoveryLsn : DWORDLONG, | |
| Flags : DWORD, | |
| }; | |
| PTXFS_ROLLFORWARD_REDO_INFORMATION :: ^TXFS_ROLLFORWARD_REDO_INFORMATION; | |
| TXFS_START_RM_INFORMATION :: struct { | |
| Flags : DWORD, | |
| LogContainerSize : DWORDLONG, | |
| LogContainerCountMin : DWORD, | |
| LogContainerCountMax : DWORD, | |
| LogGrowthIncrement : DWORD, | |
| LogAutoShrinkPercentage : DWORD, | |
| TmLogPathOffset : DWORD, | |
| TmLogPathLength : WORD, | |
| LoggingMode : WORD, | |
| LogPathLength : WORD, | |
| Reserved : WORD, | |
| LogPath : [1]WCHAR, | |
| }; | |
| PTXFS_START_RM_INFORMATION :: ^TXFS_START_RM_INFORMATION; | |
| TXFS_GET_METADATA_INFO_OUT :: struct { | |
| TxfFileId : struct { | |
| LowPart : LONGLONG, | |
| HighPart : LONGLONG, | |
| }, | |
| LockingTransaction : GUID, | |
| LastLsn : DWORDLONG, | |
| TransactionState : DWORD, | |
| }; | |
| PTXFS_GET_METADATA_INFO_OUT :: ^TXFS_GET_METADATA_INFO_OUT; | |
| TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY :: struct { | |
| Offset : DWORDLONG, | |
| NameFlags : DWORD, | |
| FileId : LONGLONG, | |
| Reserved1 : DWORD, | |
| Reserved2 : DWORD, | |
| Reserved3 : LONGLONG, | |
| FileName : [1]WCHAR, | |
| }; | |
| PTXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY :: ^TXFS_LIST_TRANSACTION_LOCKED_FILES_ENTRY; | |
| TXFS_LIST_TRANSACTION_LOCKED_FILES :: struct { | |
| KtmTransaction : GUID, | |
| NumberOfFiles : DWORDLONG, | |
| BufferSizeRequired : DWORDLONG, | |
| Offset : DWORDLONG, | |
| }; | |
| PTXFS_LIST_TRANSACTION_LOCKED_FILES :: ^TXFS_LIST_TRANSACTION_LOCKED_FILES; | |
| TXFS_LIST_TRANSACTIONS_ENTRY :: struct { | |
| TransactionId : GUID, | |
| TransactionState : DWORD, | |
| Reserved1 : DWORD, | |
| Reserved2 : DWORD, | |
| Reserved3 : LONGLONG, | |
| }; | |
| PTXFS_LIST_TRANSACTIONS_ENTRY :: ^TXFS_LIST_TRANSACTIONS_ENTRY; | |
| TXFS_LIST_TRANSACTIONS :: struct { | |
| NumberOfTransactions : DWORDLONG, | |
| BufferSizeRequired : DWORDLONG, | |
| }; | |
| PTXFS_LIST_TRANSACTIONS :: ^TXFS_LIST_TRANSACTIONS; | |
| TXFS_READ_BACKUP_INFORMATION_OUT :: struct { | |
| u : struct #raw_union { | |
| BufferLength : DWORD, | |
| Buffer : [1]BYTE, | |
| }, | |
| }; | |
| PTXFS_READ_BACKUP_INFORMATION_OUT :: ^TXFS_READ_BACKUP_INFORMATION_OUT; | |
| TXFS_WRITE_BACKUP_INFORMATION :: struct { | |
| Buffer : [1]BYTE, | |
| }; | |
| PTXFS_WRITE_BACKUP_INFORMATION :: ^TXFS_WRITE_BACKUP_INFORMATION; | |
| TXFS_GET_TRANSACTED_VERSION :: struct { | |
| ThisBaseVersion : DWORD, | |
| LatestVersion : DWORD, | |
| ThisMiniVersion : WORD, | |
| FirstMiniVersion : WORD, | |
| LatestMiniVersion : WORD, | |
| }; | |
| PTXFS_GET_TRANSACTED_VERSION :: ^TXFS_GET_TRANSACTED_VERSION; | |
| TXFS_SAVEPOINT_INFORMATION :: struct { | |
| KtmTransaction : HANDLE, | |
| ActionCode : DWORD, | |
| SavepointId : DWORD, | |
| }; | |
| PTXFS_SAVEPOINT_INFORMATION :: ^TXFS_SAVEPOINT_INFORMATION; | |
| TXFS_CREATE_MINIVERSION_INFO :: struct { | |
| StructureVersion : WORD, | |
| StructureLength : WORD, | |
| BaseVersion : DWORD, | |
| MiniVersion : WORD, | |
| }; | |
| PTXFS_CREATE_MINIVERSION_INFO :: ^TXFS_CREATE_MINIVERSION_INFO; | |
| TXFS_TRANSACTION_ACTIVE_INFO :: struct { | |
| TransactionsActiveAtSnapshot : BOOLEAN, | |
| }; | |
| PTXFS_TRANSACTION_ACTIVE_INFO :: ^TXFS_TRANSACTION_ACTIVE_INFO; | |
| BOOT_AREA_INFO :: struct { | |
| BootSectorCount : DWORD, | |
| BootSectors : [2]struct { | |
| Offset : LARGE_INTEGER, | |
| }, | |
| }; | |
| PBOOT_AREA_INFO :: ^BOOT_AREA_INFO; | |
| RETRIEVAL_POINTER_BASE :: struct { | |
| FileAreaOffset : LARGE_INTEGER, | |
| }; | |
| PRETRIEVAL_POINTER_BASE :: ^RETRIEVAL_POINTER_BASE; | |
| FILE_FS_PERSISTENT_VOLUME_INFORMATION :: struct { | |
| VolumeFlags : DWORD, | |
| FlagMask : DWORD, | |
| Version : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PFILE_FS_PERSISTENT_VOLUME_INFORMATION :: ^FILE_FS_PERSISTENT_VOLUME_INFORMATION; | |
| FILE_SYSTEM_RECOGNITION_INFORMATION :: struct { | |
| FileSystem : [9]CHAR, | |
| }; | |
| PFILE_SYSTEM_RECOGNITION_INFORMATION :: ^FILE_SYSTEM_RECOGNITION_INFORMATION; | |
| REQUEST_OPLOCK_INPUT_BUFFER :: struct { | |
| StructureVersion : WORD, | |
| StructureLength : WORD, | |
| RequestedOplockLevel : DWORD, | |
| Flags : DWORD, | |
| }; | |
| PREQUEST_OPLOCK_INPUT_BUFFER :: ^REQUEST_OPLOCK_INPUT_BUFFER; | |
| REQUEST_OPLOCK_OUTPUT_BUFFER :: struct { | |
| StructureVersion : WORD, | |
| StructureLength : WORD, | |
| OriginalOplockLevel : DWORD, | |
| NewOplockLevel : DWORD, | |
| Flags : DWORD, | |
| AccessMode : ACCESS_MASK, | |
| ShareMode : WORD, | |
| }; | |
| PREQUEST_OPLOCK_OUTPUT_BUFFER :: ^REQUEST_OPLOCK_OUTPUT_BUFFER; | |
| VIRTUAL_STORAGE_TYPE :: struct { | |
| DeviceId : DWORD, | |
| VendorId : GUID, | |
| }; | |
| PVIRTUAL_STORAGE_TYPE :: ^VIRTUAL_STORAGE_TYPE; | |
| STORAGE_QUERY_DEPENDENT_VOLUME_REQUEST :: struct { | |
| RequestLevel : DWORD, | |
| RequestFlags : DWORD, | |
| }; | |
| PSTORAGE_QUERY_DEPENDENT_VOLUME_REQUEST :: ^STORAGE_QUERY_DEPENDENT_VOLUME_REQUEST; | |
| STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY :: struct { | |
| EntryLength : DWORD, | |
| DependencyTypeFlags : DWORD, | |
| ProviderSpecificFlags : DWORD, | |
| VirtualStorageType : VIRTUAL_STORAGE_TYPE, | |
| }; | |
| PSTORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY :: ^STORAGE_QUERY_DEPENDENT_VOLUME_LEV1_ENTRY; | |
| STORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY :: struct { | |
| EntryLength : DWORD, | |
| DependencyTypeFlags : DWORD, | |
| ProviderSpecificFlags : DWORD, | |
| VirtualStorageType : VIRTUAL_STORAGE_TYPE, | |
| AncestorLevel : DWORD, | |
| HostVolumeNameOffset : DWORD, | |
| HostVolumeNameSize : DWORD, | |
| DependentVolumeNameOffset : DWORD, | |
| DependentVolumeNameSize : DWORD, | |
| RelativePathOffset : DWORD, | |
| RelativePathSize : DWORD, | |
| DependentDeviceNameOffset : DWORD, | |
| DependentDeviceNameSize : DWORD, | |
| }; | |
| PSTORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY :: ^STORAGE_QUERY_DEPENDENT_VOLUME_LEV2_ENTRY; | |
| SD_CHANGE_MACHINE_SID_INPUT :: struct { | |
| CurrentMachineSIDOffset : WORD, | |
| CurrentMachineSIDLength : WORD, | |
| NewMachineSIDOffset : WORD, | |
| NewMachineSIDLength : WORD, | |
| }; | |
| PSD_CHANGE_MACHINE_SID_INPUT :: ^SD_CHANGE_MACHINE_SID_INPUT; | |
| SD_CHANGE_MACHINE_SID_OUTPUT :: struct { | |
| NumSDChangedSuccess : DWORDLONG, | |
| NumSDChangedFail : DWORDLONG, | |
| NumSDUnused : DWORDLONG, | |
| NumSDTotal : DWORDLONG, | |
| NumMftSDChangedSuccess : DWORDLONG, | |
| NumMftSDChangedFail : DWORDLONG, | |
| NumMftSDTotal : DWORDLONG, | |
| }; | |
| PSD_CHANGE_MACHINE_SID_OUTPUT :: ^SD_CHANGE_MACHINE_SID_OUTPUT; | |
| SD_QUERY_STATS_INPUT :: struct { | |
| Reserved : DWORD, | |
| }; | |
| PSD_QUERY_STATS_INPUT :: ^SD_QUERY_STATS_INPUT; | |
| SD_QUERY_STATS_OUTPUT :: struct { | |
| SdsStreamSize : DWORDLONG, | |
| SdsAllocationSize : DWORDLONG, | |
| SiiStreamSize : DWORDLONG, | |
| SiiAllocationSize : DWORDLONG, | |
| SdhStreamSize : DWORDLONG, | |
| SdhAllocationSize : DWORDLONG, | |
| NumSDTotal : DWORDLONG, | |
| NumSDUnused : DWORDLONG, | |
| }; | |
| PSD_QUERY_STATS_OUTPUT :: ^SD_QUERY_STATS_OUTPUT; | |
| SD_ENUM_SDS_INPUT :: struct { | |
| StartingOffset : DWORDLONG, | |
| MaxSDEntriesToReturn : DWORDLONG, | |
| }; | |
| PSD_ENUM_SDS_INPUT :: ^SD_ENUM_SDS_INPUT; | |
| SD_ENUM_SDS_ENTRY :: struct { | |
| Hash : DWORD, | |
| SecurityId : DWORD, | |
| Offset : DWORDLONG, | |
| Length : DWORD, | |
| Descriptor : [1]BYTE, | |
| }; | |
| PSD_ENUM_SDS_ENTRY :: ^SD_ENUM_SDS_ENTRY; | |
| SD_ENUM_SDS_OUTPUT :: struct { | |
| NextOffset : DWORDLONG, | |
| NumSDEntriesReturned : DWORDLONG, | |
| NumSDBytesReturned : DWORDLONG, | |
| SDEntry : [1]SD_ENUM_SDS_ENTRY, | |
| }; | |
| PSD_ENUM_SDS_OUTPUT :: ^SD_ENUM_SDS_OUTPUT; | |
| SD_GLOBAL_CHANGE_INPUT :: struct { | |
| Flags : DWORD, | |
| ChangeType : DWORD, | |
| u : struct #raw_union { | |
| SdChange : SD_CHANGE_MACHINE_SID_INPUT, | |
| SdQueryStats : SD_QUERY_STATS_INPUT, | |
| SdEnumSds : SD_ENUM_SDS_INPUT, | |
| }, | |
| }; | |
| PSD_GLOBAL_CHANGE_INPUT :: ^SD_GLOBAL_CHANGE_INPUT; | |
| SD_GLOBAL_CHANGE_OUTPUT :: struct { | |
| Flags : DWORD, | |
| ChangeType : DWORD, | |
| u : struct #raw_union { | |
| SdChange : SD_CHANGE_MACHINE_SID_OUTPUT, | |
| SdQueryStats : SD_QUERY_STATS_OUTPUT, | |
| SdEnumSds : SD_ENUM_SDS_OUTPUT, | |
| }, | |
| }; | |
| PSD_GLOBAL_CHANGE_OUTPUT :: ^SD_GLOBAL_CHANGE_OUTPUT; | |
| LOOKUP_STREAM_FROM_CLUSTER_INPUT :: struct { | |
| Flags : DWORD, | |
| NumberOfClusters : DWORD, | |
| Cluster : [1]LARGE_INTEGER, | |
| }; | |
| PLOOKUP_STREAM_FROM_CLUSTER_INPUT :: ^LOOKUP_STREAM_FROM_CLUSTER_INPUT; | |
| LOOKUP_STREAM_FROM_CLUSTER_OUTPUT :: struct { | |
| Offset : DWORD, | |
| NumberOfMatches : DWORD, | |
| BufferSizeRequired : DWORD, | |
| }; | |
| PLOOKUP_STREAM_FROM_CLUSTER_OUTPUT :: ^LOOKUP_STREAM_FROM_CLUSTER_OUTPUT; | |
| LOOKUP_STREAM_FROM_CLUSTER_ENTRY :: struct { | |
| OffsetToNext : DWORD, | |
| Flags : DWORD, | |
| Reserved : LARGE_INTEGER, | |
| Cluster : LARGE_INTEGER, | |
| FileName : [1]WCHAR, | |
| }; | |
| PLOOKUP_STREAM_FROM_CLUSTER_ENTRY :: ^LOOKUP_STREAM_FROM_CLUSTER_ENTRY; | |
| FILE_TYPE_NOTIFICATION_INPUT :: struct { | |
| Flags : DWORD, | |
| NumFileTypeIDs : DWORD, | |
| FileTypeID : [1]GUID, | |
| }; | |
| PFILE_TYPE_NOTIFICATION_INPUT :: ^FILE_TYPE_NOTIFICATION_INPUT; | |
| CSV_MGMT_LOCK :: struct { | |
| Flags : DWORD, | |
| }; | |
| PCSV_MGMT_LOCK :: ^CSV_MGMT_LOCK; | |
| CSV_NAMESPACE_INFO :: struct { | |
| Version : DWORD, | |
| DeviceNumber : DWORD, | |
| StartingOffset : LARGE_INTEGER, | |
| SectorSize : DWORD, | |
| }; | |
| PCSV_NAMESPACE_INFO :: ^CSV_NAMESPACE_INFO; | |
| /* CSV_CONTROL_OP :: enum { */ | |
| CSV_CONTROL_OP :: _c.int; | |
| CsvControlStartRedirectFile :: 0x02; | |
| CsvControlStopRedirectFile :: 0x03; | |
| CsvControlQueryRedirectState :: 0x04; | |
| CsvControlQueryFileRevision :: 0x06; | |
| CsvControlQueryMdsPath :: 0x08; | |
| CsvControlQueryFileRevisionFileId128 :: 0x09; | |
| CsvControlQueryVolumeRedirectState :: 0x0a; | |
| CsvControlEnableUSNRangeModificationTracking :: 0x0d; | |
| CsvControlMarkHandleLocalVolumeMount :: 0x0e; | |
| CsvControlUnmarkHandleLocalVolumeMount :: 0x0f; | |
| CsvControlGetCsvFsMdsPathV2 :: 0x12; | |
| CsvControlDisableCaching :: 0x13; | |
| CsvControlEnableCaching :: 0x14; | |
| /* } */ | |
| PCSV_CONTROL_OP :: ^CSV_CONTROL_OP; | |
| CSV_CONTROL_PARAM :: struct { | |
| Operation : CSV_CONTROL_OP, | |
| Unused : LONGLONG, | |
| }; | |
| PCSV_CONTROL_PARAM :: ^CSV_CONTROL_PARAM; | |
| CSV_QUERY_REDIRECT_STATE :: struct { | |
| MdsNodeId : DWORD, | |
| DsNodeId : DWORD, | |
| FileRedirected : BOOLEAN, | |
| }; | |
| PCSV_QUERY_REDIRECT_STATE :: ^CSV_QUERY_REDIRECT_STATE; | |
| CSV_QUERY_FILE_REVISION :: struct { | |
| FileId : LONGLONG, | |
| FileRevision : [3]LONGLONG, | |
| }; | |
| PCSV_QUERY_FILE_REVISION :: ^CSV_QUERY_FILE_REVISION; | |
| CSV_QUERY_FILE_REVISION_FILE_ID_128 :: struct { | |
| FileId : FILE_ID_128, | |
| FileRevision : [3]LONGLONG, | |
| }; | |
| PCSV_QUERY_FILE_REVISION_FILE_ID_128 :: ^CSV_QUERY_FILE_REVISION_FILE_ID_128; | |
| CSV_QUERY_MDS_PATH :: struct { | |
| MdsNodeId : DWORD, | |
| DsNodeId : DWORD, | |
| PathLength : DWORD, | |
| Path : [1]WCHAR, | |
| }; | |
| PCSV_QUERY_MDS_PATH :: ^CSV_QUERY_MDS_PATH; | |
| /* CSVFS_DISK_CONNECTIVITY :: enum { */ | |
| CSVFS_DISK_CONNECTIVITY :: _c.int; | |
| CsvFsDiskConnectivityNone :: 0; | |
| CsvFsDiskConnectivityMdsNodeOnly :: 1; | |
| CsvFsDiskConnectivitySubsetOfNodes :: 2; | |
| CsvFsDiskConnectivityAllNodes :: 3; | |
| /* } */ | |
| PCSVFS_DISK_CONNECTIVITY :: ^CSVFS_DISK_CONNECTIVITY; | |
| CSV_QUERY_VOLUME_REDIRECT_STATE :: struct { | |
| MdsNodeId : DWORD, | |
| DsNodeId : DWORD, | |
| IsDiskConnected : BOOLEAN, | |
| ClusterEnableDirectIo : BOOLEAN, | |
| DiskConnectivity : CSVFS_DISK_CONNECTIVITY, | |
| }; | |
| PCSV_QUERY_VOLUME_REDIRECT_STATE :: ^CSV_QUERY_VOLUME_REDIRECT_STATE; | |
| CSV_QUERY_MDS_PATH_V2 :: struct { | |
| Version : LONGLONG, | |
| RequiredSize : DWORD, | |
| MdsNodeId : DWORD, | |
| DsNodeId : DWORD, | |
| Flags : DWORD, | |
| DiskConnectivity : CSVFS_DISK_CONNECTIVITY, | |
| VolumeId : GUID, | |
| IpAddressOffset : DWORD, | |
| IpAddressLength : DWORD, | |
| PathOffset : DWORD, | |
| PathLength : DWORD, | |
| }; | |
| PCSV_QUERY_MDS_PATH_V2 :: ^CSV_QUERY_MDS_PATH_V2; | |
| CSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT :: struct { | |
| VetoedFromAltitudeIntegral : DWORDLONG, | |
| VetoedFromAltitudeDecimal : DWORDLONG, | |
| Reason : [256]WCHAR, | |
| }; | |
| PCSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT :: ^CSV_QUERY_VETO_FILE_DIRECT_IO_OUTPUT; | |
| /* STORAGE_RESERVE_ID :: enum { */ | |
| STORAGE_RESERVE_ID :: _c.int; | |
| StorageReserveIdNone :: 0; | |
| StorageReserveIdHard :: StorageReserveIdNone + 1; | |
| StorageReserveIdSoft :: StorageReserveIdHard + 1; | |
| StorageReserveIdUpdateScratch :: StorageReserveIdSoft + 1; | |
| StorageReserveIdMax :: StorageReserveIdUpdateScratch + 1; | |
| /* } */ | |
| PSTORAGE_RESERVE_ID :: ^STORAGE_RESERVE_ID; | |
| CSV_IS_OWNED_BY_CSVFS :: struct { | |
| OwnedByCSVFS : BOOLEAN, | |
| }; | |
| PCSV_IS_OWNED_BY_CSVFS :: ^CSV_IS_OWNED_BY_CSVFS; | |
| FILE_LEVEL_TRIM_RANGE :: struct { | |
| Offset : DWORDLONG, | |
| Length : DWORDLONG, | |
| }; | |
| PFILE_LEVEL_TRIM_RANGE :: ^FILE_LEVEL_TRIM_RANGE; | |
| FILE_LEVEL_TRIM :: struct { | |
| Key : DWORD, | |
| NumRanges : DWORD, | |
| Ranges : [1]FILE_LEVEL_TRIM_RANGE, | |
| }; | |
| PFILE_LEVEL_TRIM :: ^FILE_LEVEL_TRIM; | |
| FILE_LEVEL_TRIM_OUTPUT :: struct { | |
| NumRangesProcessed : DWORD, | |
| }; | |
| PFILE_LEVEL_TRIM_OUTPUT :: ^FILE_LEVEL_TRIM_OUTPUT; | |
| /* QUERY_FILE_LAYOUT_FILTER_TYPE :: enum { */ | |
| QUERY_FILE_LAYOUT_FILTER_TYPE :: _c.int; | |
| QUERY_FILE_LAYOUT_FILTER_TYPE_NONE :: 0; | |
| QUERY_FILE_LAYOUT_FILTER_TYPE_CLUSTERS :: 1; | |
| QUERY_FILE_LAYOUT_FILTER_TYPE_FILEID :: 2; | |
| QUERY_FILE_LAYOUT_FILTER_TYPE_STORAGE_RESERVE_ID :: 3; | |
| QUERY_FILE_LAYOUT_NUM_FILTER_TYPES :: QUERY_FILE_LAYOUT_FILTER_TYPE_STORAGE_RESERVE_ID + 1; | |
| /* } */ | |
| ; | |
| CLUSTER_RANGE :: struct { | |
| StartingCluster : LARGE_INTEGER, | |
| ClusterCount : LARGE_INTEGER, | |
| }; | |
| PCLUSTER_RANGE :: ^CLUSTER_RANGE; | |
| FILE_REFERENCE_RANGE :: struct { | |
| StartingFileReferenceNumber : DWORDLONG, | |
| EndingFileReferenceNumber : DWORDLONG, | |
| }; | |
| PFILE_REFERENCE_RANGE :: ^FILE_REFERENCE_RANGE; | |
| QUERY_FILE_LAYOUT_INPUT :: struct { | |
| u : struct #raw_union { | |
| FilterEntryCount : DWORD, | |
| NumberOfPairs : DWORD, | |
| }, | |
| Flags : DWORD, | |
| FilterType : QUERY_FILE_LAYOUT_FILTER_TYPE, | |
| Reserved : DWORD, | |
| Filter : struct #raw_union { | |
| ClusterRanges : [1]CLUSTER_RANGE, | |
| FileReferenceRanges : [1]FILE_REFERENCE_RANGE, | |
| StorageReserveIds : [1]STORAGE_RESERVE_ID, | |
| }, | |
| }; | |
| PQUERY_FILE_LAYOUT_INPUT :: ^QUERY_FILE_LAYOUT_INPUT; | |
| QUERY_FILE_LAYOUT_OUTPUT :: struct { | |
| FileEntryCount : DWORD, | |
| FirstFileOffset : DWORD, | |
| Flags : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PQUERY_FILE_LAYOUT_OUTPUT :: ^QUERY_FILE_LAYOUT_OUTPUT; | |
| FILE_LAYOUT_ENTRY :: struct { | |
| Version : DWORD, | |
| NextFileOffset : DWORD, | |
| Flags : DWORD, | |
| FileAttributes : DWORD, | |
| FileReferenceNumber : DWORDLONG, | |
| FirstNameOffset : DWORD, | |
| FirstStreamOffset : DWORD, | |
| ExtraInfoOffset : DWORD, | |
| ExtraInfoLength : DWORD, | |
| }; | |
| PFILE_LAYOUT_ENTRY :: ^FILE_LAYOUT_ENTRY; | |
| FILE_LAYOUT_NAME_ENTRY :: struct { | |
| NextNameOffset : DWORD, | |
| Flags : DWORD, | |
| ParentFileReferenceNumber : DWORDLONG, | |
| FileNameLength : DWORD, | |
| Reserved : DWORD, | |
| FileName : [1]WCHAR, | |
| }; | |
| PFILE_LAYOUT_NAME_ENTRY :: ^FILE_LAYOUT_NAME_ENTRY; | |
| FILE_LAYOUT_INFO_ENTRY :: struct { | |
| BasicInformation : struct { | |
| CreationTime : LARGE_INTEGER, | |
| LastAccessTime : LARGE_INTEGER, | |
| LastWriteTime : LARGE_INTEGER, | |
| ChangeTime : LARGE_INTEGER, | |
| FileAttributes : DWORD, | |
| }, | |
| OwnerId : DWORD, | |
| SecurityId : DWORD, | |
| Usn : USN, | |
| StorageReserveId : STORAGE_RESERVE_ID, | |
| }; | |
| PFILE_LAYOUT_INFO_ENTRY :: ^FILE_LAYOUT_INFO_ENTRY; | |
| STREAM_LAYOUT_ENTRY :: struct { | |
| Version : DWORD, | |
| NextStreamOffset : DWORD, | |
| Flags : DWORD, | |
| ExtentInformationOffset : DWORD, | |
| AllocationSize : LARGE_INTEGER, | |
| EndOfFile : LARGE_INTEGER, | |
| StreamInformationOffset : DWORD, | |
| AttributeTypeCode : DWORD, | |
| AttributeFlags : DWORD, | |
| StreamIdentifierLength : DWORD, | |
| StreamIdentifier : [1]WCHAR, | |
| }; | |
| PSTREAM_LAYOUT_ENTRY :: ^STREAM_LAYOUT_ENTRY; | |
| STREAM_EXTENT_ENTRY :: struct { | |
| Flags : DWORD, | |
| ExtentInformation : struct #raw_union { | |
| RetrievalPointers : RETRIEVAL_POINTERS_BUFFER, | |
| }, | |
| }; | |
| PSTREAM_EXTENT_ENTRY :: ^STREAM_EXTENT_ENTRY; | |
| FSCTL_GET_INTEGRITY_INFORMATION_BUFFER :: struct { | |
| ChecksumAlgorithm : WORD, | |
| Reserved : WORD, | |
| Flags : DWORD, | |
| ChecksumChunkSizeInBytes : DWORD, | |
| ClusterSizeInBytes : DWORD, | |
| }; | |
| PFSCTL_GET_INTEGRITY_INFORMATION_BUFFER :: ^FSCTL_GET_INTEGRITY_INFORMATION_BUFFER; | |
| FSCTL_SET_INTEGRITY_INFORMATION_BUFFER :: struct { | |
| ChecksumAlgorithm : WORD, | |
| Reserved : WORD, | |
| Flags : DWORD, | |
| }; | |
| PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER :: ^FSCTL_SET_INTEGRITY_INFORMATION_BUFFER; | |
| FSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX :: struct { | |
| EnableIntegrity : BYTE, | |
| KeepIntegrityStateUnchanged : BYTE, | |
| Reserved : WORD, | |
| Flags : DWORD, | |
| Version : BYTE, | |
| Reserved2 : [7]BYTE, | |
| }; | |
| PFSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX :: ^FSCTL_SET_INTEGRITY_INFORMATION_BUFFER_EX; | |
| FSCTL_OFFLOAD_READ_INPUT :: struct { | |
| Size : DWORD, | |
| Flags : DWORD, | |
| TokenTimeToLive : DWORD, | |
| Reserved : DWORD, | |
| FileOffset : DWORDLONG, | |
| CopyLength : DWORDLONG, | |
| }; | |
| PFSCTL_OFFLOAD_READ_INPUT :: ^FSCTL_OFFLOAD_READ_INPUT; | |
| FSCTL_OFFLOAD_READ_OUTPUT :: struct { | |
| Size : DWORD, | |
| Flags : DWORD, | |
| TransferLength : DWORDLONG, | |
| Token : [512]BYTE, | |
| }; | |
| PFSCTL_OFFLOAD_READ_OUTPUT :: ^FSCTL_OFFLOAD_READ_OUTPUT; | |
| FSCTL_OFFLOAD_WRITE_INPUT :: struct { | |
| Size : DWORD, | |
| Flags : DWORD, | |
| FileOffset : DWORDLONG, | |
| CopyLength : DWORDLONG, | |
| TransferOffset : DWORDLONG, | |
| Token : [512]BYTE, | |
| }; | |
| PFSCTL_OFFLOAD_WRITE_INPUT :: ^FSCTL_OFFLOAD_WRITE_INPUT; | |
| FSCTL_OFFLOAD_WRITE_OUTPUT :: struct { | |
| Size : DWORD, | |
| Flags : DWORD, | |
| LengthWritten : DWORDLONG, | |
| }; | |
| PFSCTL_OFFLOAD_WRITE_OUTPUT :: ^FSCTL_OFFLOAD_WRITE_OUTPUT; | |
| SET_PURGE_FAILURE_MODE_INPUT :: struct { | |
| Flags : DWORD, | |
| }; | |
| PSET_PURGE_FAILURE_MODE_INPUT :: ^SET_PURGE_FAILURE_MODE_INPUT; | |
| REPAIR_COPIES_INPUT :: struct { | |
| Size : DWORD, | |
| Flags : DWORD, | |
| FileOffset : LARGE_INTEGER, | |
| Length : DWORD, | |
| SourceCopy : DWORD, | |
| NumberOfRepairCopies : DWORD, | |
| RepairCopies : [1]DWORD, | |
| }; | |
| PREPAIR_COPIES_INPUT :: ^REPAIR_COPIES_INPUT; | |
| REPAIR_COPIES_OUTPUT :: struct { | |
| Size : DWORD, | |
| Status : DWORD, | |
| ResumeFileOffset : LARGE_INTEGER, | |
| }; | |
| PREPAIR_COPIES_OUTPUT :: ^REPAIR_COPIES_OUTPUT; | |
| FILE_REGION_INFO :: struct { | |
| FileOffset : LONGLONG, | |
| Length : LONGLONG, | |
| Usage : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PFILE_REGION_INFO :: ^FILE_REGION_INFO; | |
| FILE_REGION_OUTPUT :: struct { | |
| Flags : DWORD, | |
| TotalRegionEntryCount : DWORD, | |
| RegionEntryCount : DWORD, | |
| Reserved : DWORD, | |
| Region : [1]FILE_REGION_INFO, | |
| }; | |
| PFILE_REGION_OUTPUT :: ^FILE_REGION_OUTPUT; | |
| FILE_REGION_INPUT :: struct { | |
| FileOffset : LONGLONG, | |
| Length : LONGLONG, | |
| DesiredUsage : DWORD, | |
| }; | |
| PFILE_REGION_INPUT :: ^FILE_REGION_INPUT; | |
| WRITE_USN_REASON_INPUT :: struct { | |
| Flags : DWORD, | |
| UsnReasonToWrite : DWORD, | |
| }; | |
| PWRITE_USN_REASON_INPUT :: ^WRITE_USN_REASON_INPUT; | |
| /* FILE_STORAGE_TIER_MEDIA_TYPE :: enum { */ | |
| FILE_STORAGE_TIER_MEDIA_TYPE :: _c.int; | |
| FileStorageTierMediaTypeUnspecified :: 0; | |
| FileStorageTierMediaTypeDisk :: 1; | |
| FileStorageTierMediaTypeSsd :: 2; | |
| FileStorageTierMediaTypeScm :: 4; | |
| FileStorageTierMediaTypeMax :: FileStorageTierMediaTypeScm + 1; | |
| /* } */ | |
| PFILE_STORAGE_TIER_MEDIA_TYPE :: ^FILE_STORAGE_TIER_MEDIA_TYPE; | |
| /* FILE_STORAGE_TIER_CLASS :: enum { */ | |
| FILE_STORAGE_TIER_CLASS :: _c.int; | |
| FileStorageTierClassUnspecified :: 0; | |
| FileStorageTierClassCapacity :: FileStorageTierClassUnspecified + 1; | |
| FileStorageTierClassPerformance :: FileStorageTierClassCapacity + 1; | |
| FileStorageTierClassMax :: FileStorageTierClassPerformance + 1; | |
| /* } */ | |
| PFILE_STORAGE_TIER_CLASS :: ^FILE_STORAGE_TIER_CLASS; | |
| FILE_STORAGE_TIER :: struct { | |
| Id : GUID, | |
| Name : [(256)]WCHAR, | |
| Description : [(256)]WCHAR, | |
| Flags : DWORDLONG, | |
| ProvisionedCapacity : DWORDLONG, | |
| MediaType : FILE_STORAGE_TIER_MEDIA_TYPE, | |
| Class : FILE_STORAGE_TIER_CLASS, | |
| }; | |
| PFILE_STORAGE_TIER :: ^FILE_STORAGE_TIER; | |
| FSCTL_QUERY_STORAGE_CLASSES_OUTPUT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| TotalNumberOfTiers : DWORD, | |
| NumberOfTiersReturned : DWORD, | |
| Tiers : [1]FILE_STORAGE_TIER, | |
| }; | |
| PFSCTL_QUERY_STORAGE_CLASSES_OUTPUT :: ^FSCTL_QUERY_STORAGE_CLASSES_OUTPUT; | |
| STREAM_INFORMATION_ENTRY :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| StreamInformation : struct #raw_union { | |
| DesiredStorageClass : struct { | |
| Class : FILE_STORAGE_TIER_CLASS, | |
| Flags : DWORD, | |
| }, | |
| }, | |
| }; | |
| PSTREAM_INFORMATION_ENTRY :: ^STREAM_INFORMATION_ENTRY; | |
| FSCTL_QUERY_REGION_INFO_INPUT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| NumberOfTierIds : DWORD, | |
| TierIds : [1]GUID, | |
| }; | |
| PFSCTL_QUERY_REGION_INFO_INPUT :: ^FSCTL_QUERY_REGION_INFO_INPUT; | |
| FILE_STORAGE_TIER_REGION :: struct { | |
| TierId : GUID, | |
| Offset : DWORDLONG, | |
| Length : DWORDLONG, | |
| }; | |
| PFILE_STORAGE_TIER_REGION :: ^FILE_STORAGE_TIER_REGION; | |
| FSCTL_QUERY_REGION_INFO_OUTPUT :: struct { | |
| Version : DWORD, | |
| Size : DWORD, | |
| Flags : DWORD, | |
| Reserved : DWORD, | |
| Alignment : DWORDLONG, | |
| TotalNumberOfRegions : DWORD, | |
| NumberOfRegionsReturned : DWORD, | |
| Regions : [1]FILE_STORAGE_TIER_REGION, | |
| }; | |
| PFSCTL_QUERY_REGION_INFO_OUTPUT :: ^FSCTL_QUERY_REGION_INFO_OUTPUT; | |
| FILE_DESIRED_STORAGE_CLASS_INFORMATION :: struct { | |
| Class : FILE_STORAGE_TIER_CLASS, | |
| Flags : DWORD, | |
| }; | |
| PFILE_DESIRED_STORAGE_CLASS_INFORMATION :: ^FILE_DESIRED_STORAGE_CLASS_INFORMATION; | |
| DUPLICATE_EXTENTS_DATA :: struct { | |
| FileHandle : HANDLE, | |
| SourceFileOffset : LARGE_INTEGER, | |
| TargetFileOffset : LARGE_INTEGER, | |
| ByteCount : LARGE_INTEGER, | |
| }; | |
| PDUPLICATE_EXTENTS_DATA :: ^DUPLICATE_EXTENTS_DATA; | |
| DUPLICATE_EXTENTS_DATA32 :: struct { | |
| FileHandle : UINT32, | |
| SourceFileOffset : LARGE_INTEGER, | |
| TargetFileOffset : LARGE_INTEGER, | |
| ByteCount : LARGE_INTEGER, | |
| }; | |
| PDUPLICATE_EXTENTS_DATA32 :: ^DUPLICATE_EXTENTS_DATA32; | |
| DUPLICATE_EXTENTS_DATA_EX :: struct { | |
| Size : SIZE_T, | |
| FileHandle : HANDLE, | |
| SourceFileOffset : LARGE_INTEGER, | |
| TargetFileOffset : LARGE_INTEGER, | |
| ByteCount : LARGE_INTEGER, | |
| Flags : DWORD, | |
| }; | |
| PDUPLICATE_EXTENTS_DATA_EX :: ^DUPLICATE_EXTENTS_DATA_EX; | |
| DUPLICATE_EXTENTS_DATA_EX32 :: struct { | |
| Size : DWORD32, | |
| FileHandle : DWORD32, | |
| SourceFileOffset : LARGE_INTEGER, | |
| TargetFileOffset : LARGE_INTEGER, | |
| ByteCount : LARGE_INTEGER, | |
| Flags : DWORD, | |
| }; | |
| PDUPLICATE_EXTENTS_DATA_EX32 :: ^DUPLICATE_EXTENTS_DATA_EX32; | |
| /* REFS_SMR_VOLUME_GC_STATE :: enum { */ | |
| REFS_SMR_VOLUME_GC_STATE :: _c.int; | |
| SmrGcStateInactive :: 0; | |
| SmrGcStatePaused :: 1; | |
| SmrGcStateActive :: 2; | |
| SmrGcStateActiveFullSpeed :: 3; | |
| /* } */ | |
| PREFS_SMR_VOLUME_GC_STATE :: ^REFS_SMR_VOLUME_GC_STATE; | |
| REFS_SMR_VOLUME_INFO_OUTPUT :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| SizeOfRandomlyWritableTier : LARGE_INTEGER, | |
| FreeSpaceInRandomlyWritableTier : LARGE_INTEGER, | |
| SizeofSMRTier : LARGE_INTEGER, | |
| FreeSpaceInSMRTier : LARGE_INTEGER, | |
| UsableFreeSpaceInSMRTier : LARGE_INTEGER, | |
| VolumeGcState : REFS_SMR_VOLUME_GC_STATE, | |
| VolumeGcLastStatus : DWORD, | |
| Unused : [7]DWORDLONG, | |
| }; | |
| PREFS_SMR_VOLUME_INFO_OUTPUT :: ^REFS_SMR_VOLUME_INFO_OUTPUT; | |
| /* REFS_SMR_VOLUME_GC_ACTION :: enum { */ | |
| REFS_SMR_VOLUME_GC_ACTION :: _c.int; | |
| SmrGcActionStart :: 1; | |
| SmrGcActionStartFullSpeed :: 2; | |
| SmrGcActionPause :: 3; | |
| SmrGcActionStop :: 4; | |
| /* } */ | |
| PREFS_SMR_VOLUME_GC_ACTION :: ^REFS_SMR_VOLUME_GC_ACTION; | |
| /* REFS_SMR_VOLUME_GC_METHOD :: enum { */ | |
| REFS_SMR_VOLUME_GC_METHOD :: _c.int; | |
| SmrGcMethodCompaction :: 1; | |
| SmrGcMethodCompression :: 2; | |
| SmrGcMethodRotation :: 3; | |
| /* } */ | |
| PREFS_SMR_VOLUME_GC_METHOD :: ^REFS_SMR_VOLUME_GC_METHOD; | |
| REFS_SMR_VOLUME_GC_PARAMETERS :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| Action : REFS_SMR_VOLUME_GC_ACTION, | |
| Method : REFS_SMR_VOLUME_GC_METHOD, | |
| IoGranularity : DWORD, | |
| CompressionFormat : DWORD, | |
| Unused : [8]DWORDLONG, | |
| }; | |
| PREFS_SMR_VOLUME_GC_PARAMETERS :: ^REFS_SMR_VOLUME_GC_PARAMETERS; | |
| STREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER :: struct { | |
| OptimalWriteSize : DWORD, | |
| StreamGranularitySize : DWORD, | |
| StreamIdMin : DWORD, | |
| StreamIdMax : DWORD, | |
| }; | |
| PSTREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER :: ^STREAMS_QUERY_PARAMETERS_OUTPUT_BUFFER; | |
| STREAMS_ASSOCIATE_ID_INPUT_BUFFER :: struct { | |
| Flags : DWORD, | |
| StreamId : DWORD, | |
| }; | |
| PSTREAMS_ASSOCIATE_ID_INPUT_BUFFER :: ^STREAMS_ASSOCIATE_ID_INPUT_BUFFER; | |
| STREAMS_QUERY_ID_OUTPUT_BUFFER :: struct { | |
| StreamId : DWORD, | |
| }; | |
| PSTREAMS_QUERY_ID_OUTPUT_BUFFER :: ^STREAMS_QUERY_ID_OUTPUT_BUFFER; | |
| QUERY_BAD_RANGES_INPUT_RANGE :: struct { | |
| StartOffset : DWORDLONG, | |
| LengthInBytes : DWORDLONG, | |
| }; | |
| PQUERY_BAD_RANGES_INPUT_RANGE :: ^QUERY_BAD_RANGES_INPUT_RANGE; | |
| QUERY_BAD_RANGES_INPUT :: struct { | |
| Flags : DWORD, | |
| NumRanges : DWORD, | |
| Ranges : [1]QUERY_BAD_RANGES_INPUT_RANGE, | |
| }; | |
| PQUERY_BAD_RANGES_INPUT :: ^QUERY_BAD_RANGES_INPUT; | |
| QUERY_BAD_RANGES_OUTPUT_RANGE :: struct { | |
| Flags : DWORD, | |
| Reserved : DWORD, | |
| StartOffset : DWORDLONG, | |
| LengthInBytes : DWORDLONG, | |
| }; | |
| PQUERY_BAD_RANGES_OUTPUT_RANGE :: ^QUERY_BAD_RANGES_OUTPUT_RANGE; | |
| QUERY_BAD_RANGES_OUTPUT :: struct { | |
| Flags : DWORD, | |
| NumBadRanges : DWORD, | |
| NextOffsetToLookUp : DWORDLONG, | |
| BadRanges : [1]QUERY_BAD_RANGES_OUTPUT_RANGE, | |
| }; | |
| PQUERY_BAD_RANGES_OUTPUT :: ^QUERY_BAD_RANGES_OUTPUT; | |
| SET_DAX_ALLOC_ALIGNMENT_HINT_INPUT :: struct { | |
| Flags : DWORD, | |
| AlignmentShift : DWORD, | |
| FileOffsetToAlign : DWORDLONG, | |
| FallbackAlignmentShift : DWORD, | |
| }; | |
| PSET_DAX_ALLOC_ALIGNMENT_HINT_INPUT :: ^SET_DAX_ALLOC_ALIGNMENT_HINT_INPUT; | |
| /* VIRTUAL_STORAGE_BEHAVIOR_CODE :: enum { */ | |
| VIRTUAL_STORAGE_BEHAVIOR_CODE :: _c.int; | |
| VirtualStorageBehaviorUndefined :: 0; | |
| VirtualStorageBehaviorCacheWriteThrough :: 1; | |
| VirtualStorageBehaviorCacheWriteBack :: 2; | |
| /* } */ | |
| PVIRTUAL_STORAGE_BEHAVIOR_CODE :: ^VIRTUAL_STORAGE_BEHAVIOR_CODE; | |
| VIRTUAL_STORAGE_SET_BEHAVIOR_INPUT :: struct { | |
| Size : DWORD, | |
| BehaviorCode : VIRTUAL_STORAGE_BEHAVIOR_CODE, | |
| }; | |
| PVIRTUAL_STORAGE_SET_BEHAVIOR_INPUT :: ^VIRTUAL_STORAGE_SET_BEHAVIOR_INPUT; | |
| ENCRYPTION_KEY_CTRL_INPUT :: struct { | |
| HeaderSize : DWORD, | |
| StructureSize : DWORD, | |
| KeyOffset : WORD, | |
| KeySize : WORD, | |
| DplLock : DWORD, | |
| DplUserId : DWORDLONG, | |
| DplCredentialId : DWORDLONG, | |
| }; | |
| PENCRYPTION_KEY_CTRL_INPUT :: ^ENCRYPTION_KEY_CTRL_INPUT; | |
| WOF_EXTERNAL_INFO :: struct { | |
| Version : DWORD, | |
| Provider : DWORD, | |
| }; | |
| PWOF_EXTERNAL_INFO :: ^WOF_EXTERNAL_INFO; | |
| WOF_EXTERNAL_FILE_ID :: struct { | |
| FileId : FILE_ID_128, | |
| }; | |
| PWOF_EXTERNAL_FILE_ID :: ^WOF_EXTERNAL_FILE_ID; | |
| WOF_VERSION_INFO :: struct { | |
| WofVersion : DWORD, | |
| }; | |
| PWOF_VERSION_INFO :: ^WOF_VERSION_INFO; | |
| WIM_PROVIDER_EXTERNAL_INFO :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| DataSourceId : LARGE_INTEGER, | |
| ResourceHash : [20]BYTE, | |
| }; | |
| PWIM_PROVIDER_EXTERNAL_INFO :: ^WIM_PROVIDER_EXTERNAL_INFO; | |
| WIM_PROVIDER_ADD_OVERLAY_INPUT :: struct { | |
| WimType : DWORD, | |
| WimIndex : DWORD, | |
| WimFileNameOffset : DWORD, | |
| WimFileNameLength : DWORD, | |
| }; | |
| PWIM_PROVIDER_ADD_OVERLAY_INPUT :: ^WIM_PROVIDER_ADD_OVERLAY_INPUT; | |
| WIM_PROVIDER_UPDATE_OVERLAY_INPUT :: struct { | |
| DataSourceId : LARGE_INTEGER, | |
| WimFileNameOffset : DWORD, | |
| WimFileNameLength : DWORD, | |
| }; | |
| PWIM_PROVIDER_UPDATE_OVERLAY_INPUT :: ^WIM_PROVIDER_UPDATE_OVERLAY_INPUT; | |
| WIM_PROVIDER_REMOVE_OVERLAY_INPUT :: struct { | |
| DataSourceId : LARGE_INTEGER, | |
| }; | |
| PWIM_PROVIDER_REMOVE_OVERLAY_INPUT :: ^WIM_PROVIDER_REMOVE_OVERLAY_INPUT; | |
| WIM_PROVIDER_SUSPEND_OVERLAY_INPUT :: struct { | |
| DataSourceId : LARGE_INTEGER, | |
| }; | |
| PWIM_PROVIDER_SUSPEND_OVERLAY_INPUT :: ^WIM_PROVIDER_SUSPEND_OVERLAY_INPUT; | |
| WIM_PROVIDER_OVERLAY_ENTRY :: struct { | |
| NextEntryOffset : DWORD, | |
| DataSourceId : LARGE_INTEGER, | |
| WimGuid : GUID, | |
| WimFileNameOffset : DWORD, | |
| WimType : DWORD, | |
| WimIndex : DWORD, | |
| Flags : DWORD, | |
| }; | |
| PWIM_PROVIDER_OVERLAY_ENTRY :: ^WIM_PROVIDER_OVERLAY_ENTRY; | |
| FILE_PROVIDER_EXTERNAL_INFO_V0 :: struct { | |
| Version : DWORD, | |
| Algorithm : DWORD, | |
| }; | |
| PFILE_PROVIDER_EXTERNAL_INFO_V0 :: ^FILE_PROVIDER_EXTERNAL_INFO_V0; | |
| FILE_PROVIDER_EXTERNAL_INFO_V1 :: struct { | |
| Version : DWORD, | |
| Algorithm : DWORD, | |
| Flags : DWORD, | |
| }; | |
| PFILE_PROVIDER_EXTERNAL_INFO_V1 :: ^FILE_PROVIDER_EXTERNAL_INFO_V1; | |
| FILE_PROVIDER_EXTERNAL_INFO :: FILE_PROVIDER_EXTERNAL_INFO_V1; | |
| PFILE_PROVIDER_EXTERNAL_INFO :: PFILE_PROVIDER_EXTERNAL_INFO_V1; | |
| CONTAINER_VOLUME_STATE :: struct { | |
| Flags : DWORD, | |
| }; | |
| PCONTAINER_VOLUME_STATE :: ^CONTAINER_VOLUME_STATE; | |
| CONTAINER_ROOT_INFO_INPUT :: struct { | |
| Flags : DWORD, | |
| }; | |
| PCONTAINER_ROOT_INFO_INPUT :: ^CONTAINER_ROOT_INFO_INPUT; | |
| CONTAINER_ROOT_INFO_OUTPUT :: struct { | |
| ContainerRootIdLength : WORD, | |
| ContainerRootId : [1]BYTE, | |
| }; | |
| PCONTAINER_ROOT_INFO_OUTPUT :: ^CONTAINER_ROOT_INFO_OUTPUT; | |
| VIRTUALIZATION_INSTANCE_INFO_INPUT :: struct { | |
| NumberOfWorkerThreads : DWORD, | |
| Flags : DWORD, | |
| }; | |
| PVIRTUALIZATION_INSTANCE_INFO_INPUT :: ^VIRTUALIZATION_INSTANCE_INFO_INPUT; | |
| VIRTUALIZATION_INSTANCE_INFO_INPUT_EX :: struct { | |
| HeaderSize : WORD, | |
| Flags : DWORD, | |
| NotificationInfoSize : DWORD, | |
| NotificationInfoOffset : WORD, | |
| ProviderMajorVersion : WORD, | |
| }; | |
| PVIRTUALIZATION_INSTANCE_INFO_INPUT_EX :: ^VIRTUALIZATION_INSTANCE_INFO_INPUT_EX; | |
| VIRTUALIZATION_INSTANCE_INFO_OUTPUT :: struct { | |
| VirtualizationInstanceID : GUID, | |
| }; | |
| PVIRTUALIZATION_INSTANCE_INFO_OUTPUT :: ^VIRTUALIZATION_INSTANCE_INFO_OUTPUT; | |
| GET_FILTER_FILE_IDENTIFIER_INPUT :: struct { | |
| AltitudeLength : WORD, | |
| Altitude : [1]WCHAR, | |
| }; | |
| PGET_FILTER_FILE_IDENTIFIER_INPUT :: ^GET_FILTER_FILE_IDENTIFIER_INPUT; | |
| GET_FILTER_FILE_IDENTIFIER_OUTPUT :: struct { | |
| FilterFileIdentifierLength : WORD, | |
| FilterFileIdentifier : [1]BYTE, | |
| }; | |
| PGET_FILTER_FILE_IDENTIFIER_OUTPUT :: ^GET_FILTER_FILE_IDENTIFIER_OUTPUT; | |
| DISK_EXTENT :: struct { | |
| DiskNumber : DWORD, | |
| StartingOffset : LARGE_INTEGER, | |
| ExtentLength : LARGE_INTEGER, | |
| }; | |
| PDISK_EXTENT :: ^DISK_EXTENT; | |
| VOLUME_DISK_EXTENTS :: struct { | |
| NumberOfDiskExtents : DWORD, | |
| Extents : [1]DISK_EXTENT, | |
| }; | |
| PVOLUME_DISK_EXTENTS :: ^VOLUME_DISK_EXTENTS; | |
| VOLUME_GET_GPT_ATTRIBUTES_INFORMATION :: struct { | |
| GptAttributes : DWORDLONG, | |
| }; | |
| PVOLUME_GET_GPT_ATTRIBUTES_INFORMATION :: ^VOLUME_GET_GPT_ATTRIBUTES_INFORMATION; | |
| PIO_IRP_EXT_PROCESS_TRACKED_OFFSET_CALLBACK :: proc(SourceContext : ^IO_IRP_EXT_TRACK_OFFSET_HEADER, TargetContext : ^IO_IRP_EXT_TRACK_OFFSET_HEADER, RelativeOffset : LONGLONG); | |
| IO_IRP_EXT_TRACK_OFFSET_HEADER :: struct { | |
| Validation : WORD, | |
| Flags : WORD, | |
| TrackedOffsetCallback : PIO_IRP_EXT_PROCESS_TRACKED_OFFSET_CALLBACK, | |
| }; | |
| PIO_IRP_EXT_TRACK_OFFSET_HEADER :: ^IO_IRP_EXT_TRACK_OFFSET_HEADER; | |
| ; | |
| UWORD :: WORD; | |
| ; | |
| SCARD_IO_REQUEST :: struct { | |
| dwProtocol : DWORD, | |
| cbPciLength : DWORD, | |
| }; | |
| PSCARD_IO_REQUEST :: ^SCARD_IO_REQUEST; | |
| LPSCARD_IO_REQUEST :: ^SCARD_IO_REQUEST; | |
| LPCSCARD_IO_REQUEST :: ^SCARD_IO_REQUEST; | |
| SCARD_T0_COMMAND :: struct { | |
| bCla : BYTE, | |
| bIns : BYTE, | |
| bP1 : BYTE, | |
| bP2 : BYTE, | |
| bP3 : BYTE, | |
| }; | |
| LPSCARD_T0_COMMAND :: ^SCARD_T0_COMMAND; | |
| SCARD_T0_REQUEST :: struct { | |
| ioRequest : SCARD_IO_REQUEST, | |
| bSw1 : BYTE, | |
| bSw2 : BYTE, | |
| u : struct #raw_union { | |
| CmdBytes : SCARD_T0_COMMAND, | |
| rgbHeader : [5]BYTE, | |
| }, | |
| }; | |
| PSCARD_T0_REQUEST :: ^SCARD_T0_REQUEST; | |
| LPSCARD_T0_REQUEST :: ^SCARD_T0_REQUEST; | |
| SCARD_T1_REQUEST :: struct { | |
| ioRequest : SCARD_IO_REQUEST, | |
| }; | |
| PSCARD_T1_REQUEST :: ^SCARD_T1_REQUEST; | |
| LPSCARD_T1_REQUEST :: ^SCARD_T1_REQUEST; | |
| LPCBYTE :: ^BYTE; | |
| ; | |
| SCARDCONTEXT :: ULONG_PTR; | |
| PSCARDCONTEXT :: ^SCARDCONTEXT; | |
| LPSCARDCONTEXT :: ^SCARDCONTEXT; | |
| SCARDHANDLE :: ULONG_PTR; | |
| PSCARDHANDLE :: ^SCARDHANDLE; | |
| LPSCARDHANDLE :: ^SCARDHANDLE; | |
| SCARD_READERSTATEA :: struct { | |
| szReader : LPCSTR, | |
| pvUserData : LPVOID, | |
| dwCurrentState : DWORD, | |
| dwEventState : DWORD, | |
| cbAtr : DWORD, | |
| rgbAtr : [36]BYTE, | |
| }; | |
| PSCARD_READERSTATEA :: ^SCARD_READERSTATEA; | |
| LPSCARD_READERSTATEA :: ^SCARD_READERSTATEA; | |
| SCARD_READERSTATEW :: struct { | |
| szReader : LPCWSTR, | |
| pvUserData : LPVOID, | |
| dwCurrentState : DWORD, | |
| dwEventState : DWORD, | |
| cbAtr : DWORD, | |
| rgbAtr : [36]BYTE, | |
| }; | |
| PSCARD_READERSTATEW :: ^SCARD_READERSTATEW; | |
| LPSCARD_READERSTATEW :: ^SCARD_READERSTATEW; | |
| SCARD_READERSTATE :: SCARD_READERSTATEA; | |
| PSCARD_READERSTATE :: PSCARD_READERSTATEA; | |
| LPSCARD_READERSTATE :: LPSCARD_READERSTATEA; | |
| SCARD_ATRMASK :: struct { | |
| cbAtr : DWORD, | |
| rgbAtr : [36]BYTE, | |
| rgbMask : [36]BYTE, | |
| }; | |
| PSCARD_ATRMASK :: ^SCARD_ATRMASK; | |
| LPSCARD_ATRMASK :: ^SCARD_ATRMASK; | |
| LPOCNCONNPROCA :: (proc "stdcall" (SCARDCONTEXT, LPSTR, LPSTR, PVOID) -> SCARDHANDLE); | |
| LPOCNCONNPROCW :: (proc "stdcall" (SCARDCONTEXT, LPWSTR, LPWSTR, PVOID) -> SCARDHANDLE); | |
| LPOCNCHKPROC :: (proc "stdcall" (SCARDCONTEXT, SCARDHANDLE, PVOID) -> BOOL); | |
| LPOCNDSCPROC :: proc "stdcall" (SCARDCONTEXT, SCARDHANDLE, PVOID); | |
| OPENCARD_SEARCH_CRITERIAA :: struct { | |
| dwStructSize : DWORD, | |
| lpstrGroupNames : LPSTR, | |
| nMaxGroupNames : DWORD, | |
| rgguidInterfaces : LPCGUID, | |
| cguidInterfaces : DWORD, | |
| lpstrCardNames : LPSTR, | |
| nMaxCardNames : DWORD, | |
| lpfnCheck : LPOCNCHKPROC, | |
| lpfnConnect : LPOCNCONNPROCA, | |
| lpfnDisconnect : LPOCNDSCPROC, | |
| pvUserData : LPVOID, | |
| dwShareMode : DWORD, | |
| dwPreferredProtocols : DWORD, | |
| }; | |
| POPENCARD_SEARCH_CRITERIAA :: ^OPENCARD_SEARCH_CRITERIAA; | |
| LPOPENCARD_SEARCH_CRITERIAA :: ^OPENCARD_SEARCH_CRITERIAA; | |
| OPENCARD_SEARCH_CRITERIAW :: struct { | |
| dwStructSize : DWORD, | |
| lpstrGroupNames : LPWSTR, | |
| nMaxGroupNames : DWORD, | |
| rgguidInterfaces : LPCGUID, | |
| cguidInterfaces : DWORD, | |
| lpstrCardNames : LPWSTR, | |
| nMaxCardNames : DWORD, | |
| lpfnCheck : LPOCNCHKPROC, | |
| lpfnConnect : LPOCNCONNPROCW, | |
| lpfnDisconnect : LPOCNDSCPROC, | |
| pvUserData : LPVOID, | |
| dwShareMode : DWORD, | |
| dwPreferredProtocols : DWORD, | |
| }; | |
| POPENCARD_SEARCH_CRITERIAW :: ^OPENCARD_SEARCH_CRITERIAW; | |
| LPOPENCARD_SEARCH_CRITERIAW :: ^OPENCARD_SEARCH_CRITERIAW; | |
| OPENCARD_SEARCH_CRITERIA :: OPENCARD_SEARCH_CRITERIAA; | |
| POPENCARD_SEARCH_CRITERIA :: POPENCARD_SEARCH_CRITERIAA; | |
| LPOPENCARD_SEARCH_CRITERIA :: LPOPENCARD_SEARCH_CRITERIAA; | |
| OPENCARDNAME_EXA :: struct { | |
| dwStructSize : DWORD, | |
| hSCardContext : SCARDCONTEXT, | |
| hwndOwner : HWND, | |
| dwFlags : DWORD, | |
| lpstrTitle : LPCSTR, | |
| lpstrSearchDesc : LPCSTR, | |
| hIcon : HICON, | |
| pOpenCardSearchCriteria : POPENCARD_SEARCH_CRITERIAA, | |
| lpfnConnect : LPOCNCONNPROCA, | |
| pvUserData : LPVOID, | |
| dwShareMode : DWORD, | |
| dwPreferredProtocols : DWORD, | |
| lpstrRdr : LPSTR, | |
| nMaxRdr : DWORD, | |
| lpstrCard : LPSTR, | |
| nMaxCard : DWORD, | |
| dwActiveProtocol : DWORD, | |
| hCardHandle : SCARDHANDLE, | |
| }; | |
| POPENCARDNAME_EXA :: ^OPENCARDNAME_EXA; | |
| LPOPENCARDNAME_EXA :: ^OPENCARDNAME_EXA; | |
| OPENCARDNAME_EXW :: struct { | |
| dwStructSize : DWORD, | |
| hSCardContext : SCARDCONTEXT, | |
| hwndOwner : HWND, | |
| dwFlags : DWORD, | |
| lpstrTitle : LPCWSTR, | |
| lpstrSearchDesc : LPCWSTR, | |
| hIcon : HICON, | |
| pOpenCardSearchCriteria : POPENCARD_SEARCH_CRITERIAW, | |
| lpfnConnect : LPOCNCONNPROCW, | |
| pvUserData : LPVOID, | |
| dwShareMode : DWORD, | |
| dwPreferredProtocols : DWORD, | |
| lpstrRdr : LPWSTR, | |
| nMaxRdr : DWORD, | |
| lpstrCard : LPWSTR, | |
| nMaxCard : DWORD, | |
| dwActiveProtocol : DWORD, | |
| hCardHandle : SCARDHANDLE, | |
| }; | |
| POPENCARDNAME_EXW :: ^OPENCARDNAME_EXW; | |
| LPOPENCARDNAME_EXW :: ^OPENCARDNAME_EXW; | |
| OPENCARDNAME_EX :: OPENCARDNAME_EXA; | |
| POPENCARDNAME_EX :: POPENCARDNAME_EXA; | |
| LPOPENCARDNAME_EX :: LPOPENCARDNAME_EXA; | |
| /* READER_SEL_REQUEST_MATCH_TYPE :: enum { */ | |
| READER_SEL_REQUEST_MATCH_TYPE :: _c.int; | |
| RSR_MATCH_TYPE_READER_AND_CONTAINER :: 1; | |
| RSR_MATCH_TYPE_SERIAL_NUMBER :: RSR_MATCH_TYPE_READER_AND_CONTAINER + 1; | |
| RSR_MATCH_TYPE_ALL_CARDS :: RSR_MATCH_TYPE_SERIAL_NUMBER + 1; | |
| /* } */ | |
| ; | |
| READER_SEL_REQUEST :: struct { | |
| dwShareMode : DWORD, | |
| dwPreferredProtocols : DWORD, | |
| MatchType : READER_SEL_REQUEST_MATCH_TYPE, | |
| u : struct #raw_union { | |
| ReaderAndContainerParameter : struct { | |
| cbReaderNameOffset : DWORD, | |
| cchReaderNameLength : DWORD, | |
| cbContainerNameOffset : DWORD, | |
| cchContainerNameLength : DWORD, | |
| dwDesiredCardModuleVersion : DWORD, | |
| dwCspFlags : DWORD, | |
| }, | |
| SerialNumberParameter : struct { | |
| cbSerialNumberOffset : DWORD, | |
| cbSerialNumberLength : DWORD, | |
| dwDesiredCardModuleVersion : DWORD, | |
| }, | |
| }, | |
| }; | |
| PREADER_SEL_REQUEST :: ^READER_SEL_REQUEST; | |
| READER_SEL_RESPONSE :: struct { | |
| cbReaderNameOffset : DWORD, | |
| cchReaderNameLength : DWORD, | |
| cbCardNameOffset : DWORD, | |
| cchCardNameLength : DWORD, | |
| }; | |
| PREADER_SEL_RESPONSE :: ^READER_SEL_RESPONSE; | |
| OPENCARDNAMEA :: struct { | |
| dwStructSize : DWORD, | |
| hwndOwner : HWND, | |
| hSCardContext : SCARDCONTEXT, | |
| lpstrGroupNames : LPSTR, | |
| nMaxGroupNames : DWORD, | |
| lpstrCardNames : LPSTR, | |
| nMaxCardNames : DWORD, | |
| rgguidInterfaces : LPCGUID, | |
| cguidInterfaces : DWORD, | |
| lpstrRdr : LPSTR, | |
| nMaxRdr : DWORD, | |
| lpstrCard : LPSTR, | |
| nMaxCard : DWORD, | |
| lpstrTitle : LPCSTR, | |
| dwFlags : DWORD, | |
| pvUserData : LPVOID, | |
| dwShareMode : DWORD, | |
| dwPreferredProtocols : DWORD, | |
| dwActiveProtocol : DWORD, | |
| lpfnConnect : LPOCNCONNPROCA, | |
| lpfnCheck : LPOCNCHKPROC, | |
| lpfnDisconnect : LPOCNDSCPROC, | |
| hCardHandle : SCARDHANDLE, | |
| }; | |
| POPENCARDNAMEA :: ^OPENCARDNAMEA; | |
| LPOPENCARDNAMEA :: ^OPENCARDNAMEA; | |
| OPENCARDNAMEW :: struct { | |
| dwStructSize : DWORD, | |
| hwndOwner : HWND, | |
| hSCardContext : SCARDCONTEXT, | |
| lpstrGroupNames : LPWSTR, | |
| nMaxGroupNames : DWORD, | |
| lpstrCardNames : LPWSTR, | |
| nMaxCardNames : DWORD, | |
| rgguidInterfaces : LPCGUID, | |
| cguidInterfaces : DWORD, | |
| lpstrRdr : LPWSTR, | |
| nMaxRdr : DWORD, | |
| lpstrCard : LPWSTR, | |
| nMaxCard : DWORD, | |
| lpstrTitle : LPCWSTR, | |
| dwFlags : DWORD, | |
| pvUserData : LPVOID, | |
| dwShareMode : DWORD, | |
| dwPreferredProtocols : DWORD, | |
| dwActiveProtocol : DWORD, | |
| lpfnConnect : LPOCNCONNPROCW, | |
| lpfnCheck : LPOCNCHKPROC, | |
| lpfnDisconnect : LPOCNDSCPROC, | |
| hCardHandle : SCARDHANDLE, | |
| }; | |
| POPENCARDNAMEW :: ^OPENCARDNAMEW; | |
| LPOPENCARDNAMEW :: ^OPENCARDNAMEW; | |
| OPENCARDNAME :: OPENCARDNAMEA; | |
| POPENCARDNAME :: POPENCARDNAMEA; | |
| LPOPENCARDNAME :: LPOPENCARDNAMEA; | |
| _PSP :: struct {}; | |
| HPROPSHEETPAGE :: ^_PSP; | |
| LPFNPSPCALLBACKA :: (proc "stdcall" (hwnd : HWND, uMsg : UINT, ppsp : ^PROPSHEETPAGEA_V4) -> UINT); | |
| LPFNPSPCALLBACKW :: (proc "stdcall" (hwnd : HWND, uMsg : UINT, ppsp : ^PROPSHEETPAGEW_V4) -> UINT); | |
| PROPSHEETPAGE_RESOURCE :: LPCDLGTEMPLATE; | |
| PROPSHEETPAGEA_V1 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| pszTemplate : LPCSTR, | |
| pResource : PROPSHEETPAGE_RESOURCE, | |
| }, | |
| u2 : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCSTR, | |
| }, | |
| pszTitle : LPCSTR, | |
| pfnDlgProc : DLGPROC, | |
| lParam : LPARAM, | |
| pfnCallback : LPFNPSPCALLBACKA, | |
| pcRefParent : ^UINT, | |
| }; | |
| LPPROPSHEETPAGEA_V1 :: ^PROPSHEETPAGEA_V1; | |
| LPCPROPSHEETPAGEA_V1 :: ^PROPSHEETPAGEA_V1; | |
| PROPSHEETPAGEA_V2 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| pszTemplate : LPCSTR, | |
| pResource : PROPSHEETPAGE_RESOURCE, | |
| }, | |
| u2 : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCSTR, | |
| }, | |
| pszTitle : LPCSTR, | |
| pfnDlgProc : DLGPROC, | |
| lParam : LPARAM, | |
| pfnCallback : LPFNPSPCALLBACKA, | |
| pcRefParent : ^UINT, | |
| pszHeaderTitle : LPCSTR, | |
| pszHeaderSubTitle : LPCSTR, | |
| }; | |
| LPPROPSHEETPAGEA_V2 :: ^PROPSHEETPAGEA_V2; | |
| LPCPROPSHEETPAGEA_V2 :: ^PROPSHEETPAGEA_V2; | |
| PROPSHEETPAGEA_V3 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| pszTemplate : LPCSTR, | |
| pResource : PROPSHEETPAGE_RESOURCE, | |
| }, | |
| u2 : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCSTR, | |
| }, | |
| pszTitle : LPCSTR, | |
| pfnDlgProc : DLGPROC, | |
| lParam : LPARAM, | |
| pfnCallback : LPFNPSPCALLBACKA, | |
| pcRefParent : ^UINT, | |
| pszHeaderTitle : LPCSTR, | |
| pszHeaderSubTitle : LPCSTR, | |
| hActCtx : HANDLE, | |
| }; | |
| LPPROPSHEETPAGEA_V3 :: ^PROPSHEETPAGEA_V3; | |
| LPCPROPSHEETPAGEA_V3 :: ^PROPSHEETPAGEA_V3; | |
| PROPSHEETPAGEA_V4 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| pszTemplate : LPCSTR, | |
| pResource : PROPSHEETPAGE_RESOURCE, | |
| }, | |
| u2 : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCSTR, | |
| }, | |
| pszTitle : LPCSTR, | |
| pfnDlgProc : DLGPROC, | |
| lParam : LPARAM, | |
| pfnCallback : LPFNPSPCALLBACKA, | |
| pcRefParent : ^UINT, | |
| pszHeaderTitle : LPCSTR, | |
| pszHeaderSubTitle : LPCSTR, | |
| hActCtx : HANDLE, | |
| u3 : struct #raw_union { | |
| hbmHeader : HBITMAP, | |
| pszbmHeader : LPCSTR, | |
| }, | |
| }; | |
| LPPROPSHEETPAGEA_V4 :: ^PROPSHEETPAGEA_V4; | |
| LPCPROPSHEETPAGEA_V4 :: ^PROPSHEETPAGEA_V4; | |
| PROPSHEETPAGEW_V1 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| pszTemplate : LPCWSTR, | |
| pResource : PROPSHEETPAGE_RESOURCE, | |
| }, | |
| u2 : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCWSTR, | |
| }, | |
| pszTitle : LPCWSTR, | |
| pfnDlgProc : DLGPROC, | |
| lParam : LPARAM, | |
| pfnCallback : LPFNPSPCALLBACKW, | |
| pcRefParent : ^UINT, | |
| }; | |
| LPPROPSHEETPAGEW_V1 :: ^PROPSHEETPAGEW_V1; | |
| LPCPROPSHEETPAGEW_V1 :: ^PROPSHEETPAGEW_V1; | |
| PROPSHEETPAGEW_V2 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| pszTemplate : LPCWSTR, | |
| pResource : PROPSHEETPAGE_RESOURCE, | |
| }, | |
| u2 : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCWSTR, | |
| }, | |
| pszTitle : LPCWSTR, | |
| pfnDlgProc : DLGPROC, | |
| lParam : LPARAM, | |
| pfnCallback : LPFNPSPCALLBACKW, | |
| pcRefParent : ^UINT, | |
| pszHeaderTitle : LPCWSTR, | |
| pszHeaderSubTitle : LPCWSTR, | |
| }; | |
| LPPROPSHEETPAGEW_V2 :: ^PROPSHEETPAGEW_V2; | |
| LPCPROPSHEETPAGEW_V2 :: ^PROPSHEETPAGEW_V2; | |
| PROPSHEETPAGEW_V3 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| pszTemplate : LPCWSTR, | |
| pResource : PROPSHEETPAGE_RESOURCE, | |
| }, | |
| u2 : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCWSTR, | |
| }, | |
| pszTitle : LPCWSTR, | |
| pfnDlgProc : DLGPROC, | |
| lParam : LPARAM, | |
| pfnCallback : LPFNPSPCALLBACKW, | |
| pcRefParent : ^UINT, | |
| pszHeaderTitle : LPCWSTR, | |
| pszHeaderSubTitle : LPCWSTR, | |
| hActCtx : HANDLE, | |
| }; | |
| LPPROPSHEETPAGEW_V3 :: ^PROPSHEETPAGEW_V3; | |
| LPCPROPSHEETPAGEW_V3 :: ^PROPSHEETPAGEW_V3; | |
| PROPSHEETPAGEW_V4 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| pszTemplate : LPCWSTR, | |
| pResource : PROPSHEETPAGE_RESOURCE, | |
| }, | |
| u2 : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCWSTR, | |
| }, | |
| pszTitle : LPCWSTR, | |
| pfnDlgProc : DLGPROC, | |
| lParam : LPARAM, | |
| pfnCallback : LPFNPSPCALLBACKW, | |
| pcRefParent : ^UINT, | |
| pszHeaderTitle : LPCWSTR, | |
| pszHeaderSubTitle : LPCWSTR, | |
| hActCtx : HANDLE, | |
| u3 : struct #raw_union { | |
| hbmHeader : HBITMAP, | |
| pszbmHeader : LPCWSTR, | |
| }, | |
| }; | |
| LPPROPSHEETPAGEW_V4 :: ^PROPSHEETPAGEW_V4; | |
| LPCPROPSHEETPAGEW_V4 :: ^PROPSHEETPAGEW_V4; | |
| PROPSHEETPAGEA_LATEST :: PROPSHEETPAGEA_V4; | |
| PROPSHEETPAGEW_LATEST :: PROPSHEETPAGEW_V4; | |
| LPPROPSHEETPAGEA_LATEST :: LPPROPSHEETPAGEA_V4; | |
| LPPROPSHEETPAGEW_LATEST :: LPPROPSHEETPAGEW_V4; | |
| LPCPROPSHEETPAGEA_LATEST :: LPCPROPSHEETPAGEA_V4; | |
| LPCPROPSHEETPAGEW_LATEST :: LPCPROPSHEETPAGEW_V4; | |
| PROPSHEETPAGEA :: PROPSHEETPAGEA_V4; | |
| PROPSHEETPAGEW :: PROPSHEETPAGEW_V4; | |
| LPPROPSHEETPAGEA :: LPPROPSHEETPAGEA_V4; | |
| LPPROPSHEETPAGEW :: LPPROPSHEETPAGEW_V4; | |
| LPCPROPSHEETPAGEA :: LPCPROPSHEETPAGEA_V4; | |
| LPCPROPSHEETPAGEW :: LPCPROPSHEETPAGEW_V4; | |
| PFNPROPSHEETCALLBACK :: (proc "stdcall" (HWND, UINT, LPARAM) -> _c.int); | |
| PROPSHEETHEADERA_V1 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hwndParent : HWND, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCSTR, | |
| }, | |
| pszCaption : LPCSTR, | |
| nPages : UINT, | |
| u2 : struct #raw_union { | |
| nStartPage : UINT, | |
| pStartPage : LPCSTR, | |
| }, | |
| u3 : struct #raw_union { | |
| ppsp : LPCPROPSHEETPAGEA, | |
| phpage : ^HPROPSHEETPAGE, | |
| }, | |
| pfnCallback : PFNPROPSHEETCALLBACK, | |
| }; | |
| LPPROPSHEETHEADERA_V1 :: ^PROPSHEETHEADERA_V1; | |
| LPCPROPSHEETHEADERA_V1 :: ^PROPSHEETHEADERA_V1; | |
| PROPSHEETHEADERA_V2 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hwndParent : HWND, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCSTR, | |
| }, | |
| pszCaption : LPCSTR, | |
| nPages : UINT, | |
| u2 : struct #raw_union { | |
| nStartPage : UINT, | |
| pStartPage : LPCSTR, | |
| }, | |
| u3 : struct #raw_union { | |
| ppsp : LPCPROPSHEETPAGEA, | |
| phpage : ^HPROPSHEETPAGE, | |
| }, | |
| pfnCallback : PFNPROPSHEETCALLBACK, | |
| u4 : struct #raw_union { | |
| hbmWatermark : HBITMAP, | |
| pszbmWatermark : LPCSTR, | |
| }, | |
| hplWatermark : HPALETTE, | |
| u5 : struct #raw_union { | |
| hbmHeader : HBITMAP, | |
| pszbmHeader : LPCSTR, | |
| }, | |
| }; | |
| LPPROPSHEETHEADERA_V2 :: ^PROPSHEETHEADERA_V2; | |
| LPCPROPSHEETHEADERA_V2 :: ^PROPSHEETHEADERA_V2; | |
| PROPSHEETHEADERW_V1 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hwndParent : HWND, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCWSTR, | |
| }, | |
| pszCaption : LPCWSTR, | |
| nPages : UINT, | |
| u2 : struct #raw_union { | |
| nStartPage : UINT, | |
| pStartPage : LPCWSTR, | |
| }, | |
| u3 : struct #raw_union { | |
| ppsp : LPCPROPSHEETPAGEW, | |
| phpage : ^HPROPSHEETPAGE, | |
| }, | |
| pfnCallback : PFNPROPSHEETCALLBACK, | |
| }; | |
| LPPROPSHEETHEADERW_V1 :: ^PROPSHEETHEADERW_V1; | |
| LPCPROPSHEETHEADERW_V1 :: ^PROPSHEETHEADERW_V1; | |
| PROPSHEETHEADERW_V2 :: struct { | |
| dwSize : DWORD, | |
| dwFlags : DWORD, | |
| hwndParent : HWND, | |
| hInstance : HINSTANCE, | |
| u : struct #raw_union { | |
| hIcon : HICON, | |
| pszIcon : LPCWSTR, | |
| }, | |
| pszCaption : LPCWSTR, | |
| nPages : UINT, | |
| u2 : struct #raw_union { | |
| nStartPage : UINT, | |
| pStartPage : LPCWSTR, | |
| }, | |
| u3 : struct #raw_union { | |
| ppsp : LPCPROPSHEETPAGEW, | |
| phpage : ^HPROPSHEETPAGE, | |
| }, | |
| pfnCallback : PFNPROPSHEETCALLBACK, | |
| u4 : struct #raw_union { | |
| hbmWatermark : HBITMAP, | |
| pszbmWatermark : LPCWSTR, | |
| }, | |
| hplWatermark : HPALETTE, | |
| u5 : struct #raw_union { | |
| hbmHeader : HBITMAP, | |
| pszbmHeader : LPCWSTR, | |
| }, | |
| }; | |
| LPPROPSHEETHEADERW_V2 :: ^PROPSHEETHEADERW_V2; | |
| LPCPROPSHEETHEADERW_V2 :: ^PROPSHEETHEADERW_V2; | |
| PROPSHEETHEADERA :: PROPSHEETHEADERA_V2; | |
| PROPSHEETHEADERW :: PROPSHEETHEADERW_V2; | |
| LPPROPSHEETHEADERA :: LPPROPSHEETHEADERA_V2; | |
| LPPROPSHEETHEADERW :: LPPROPSHEETHEADERW_V2; | |
| LPCPROPSHEETHEADERA :: LPCPROPSHEETHEADERA_V2; | |
| LPCPROPSHEETHEADERW :: LPCPROPSHEETHEADERW_V2; | |
| LPFNADDPROPSHEETPAGE :: (proc "stdcall" (HPROPSHEETPAGE, LPARAM) -> BOOL); | |
| LPFNADDPROPSHEETPAGES :: (proc "stdcall" (LPVOID, LPFNADDPROPSHEETPAGE, LPARAM) -> BOOL); | |
| PSHNOTIFY :: struct { | |
| hdr : NMHDR, | |
| lParam : LPARAM, | |
| }; | |
| LPPSHNOTIFY :: ^PSHNOTIFY; | |
| PRINTER_INFO_1A :: struct { | |
| Flags : DWORD, | |
| pDescription : LPSTR, | |
| pName : LPSTR, | |
| pComment : LPSTR, | |
| }; | |
| PPRINTER_INFO_1A :: ^PRINTER_INFO_1A; | |
| LPPRINTER_INFO_1A :: ^PRINTER_INFO_1A; | |
| PRINTER_INFO_1W :: struct { | |
| Flags : DWORD, | |
| pDescription : LPWSTR, | |
| pName : LPWSTR, | |
| pComment : LPWSTR, | |
| }; | |
| PPRINTER_INFO_1W :: ^PRINTER_INFO_1W; | |
| LPPRINTER_INFO_1W :: ^PRINTER_INFO_1W; | |
| PRINTER_INFO_1 :: PRINTER_INFO_1A; | |
| PPRINTER_INFO_1 :: PPRINTER_INFO_1A; | |
| LPPRINTER_INFO_1 :: LPPRINTER_INFO_1A; | |
| PRINTER_INFO_2A :: struct { | |
| pServerName : LPSTR, | |
| pPrinterName : LPSTR, | |
| pShareName : LPSTR, | |
| pPortName : LPSTR, | |
| pDriverName : LPSTR, | |
| pComment : LPSTR, | |
| pLocation : LPSTR, | |
| pDevMode : LPDEVMODEA, | |
| pSepFile : LPSTR, | |
| pPrintProcessor : LPSTR, | |
| pDatatype : LPSTR, | |
| pParameters : LPSTR, | |
| pSecurityDescriptor : PSECURITY_DESCRIPTOR, | |
| Attributes : DWORD, | |
| Priority : DWORD, | |
| DefaultPriority : DWORD, | |
| StartTime : DWORD, | |
| UntilTime : DWORD, | |
| Status : DWORD, | |
| cJobs : DWORD, | |
| AveragePPM : DWORD, | |
| }; | |
| PPRINTER_INFO_2A :: ^PRINTER_INFO_2A; | |
| LPPRINTER_INFO_2A :: ^PRINTER_INFO_2A; | |
| PRINTER_INFO_2W :: struct { | |
| pServerName : LPWSTR, | |
| pPrinterName : LPWSTR, | |
| pShareName : LPWSTR, | |
| pPortName : LPWSTR, | |
| pDriverName : LPWSTR, | |
| pComment : LPWSTR, | |
| pLocation : LPWSTR, | |
| pDevMode : LPDEVMODEW, | |
| pSepFile : LPWSTR, | |
| pPrintProcessor : LPWSTR, | |
| pDatatype : LPWSTR, | |
| pParameters : LPWSTR, | |
| pSecurityDescriptor : PSECURITY_DESCRIPTOR, | |
| Attributes : DWORD, | |
| Priority : DWORD, | |
| DefaultPriority : DWORD, | |
| StartTime : DWORD, | |
| UntilTime : DWORD, | |
| Status : DWORD, | |
| cJobs : DWORD, | |
| AveragePPM : DWORD, | |
| }; | |
| PPRINTER_INFO_2W :: ^PRINTER_INFO_2W; | |
| LPPRINTER_INFO_2W :: ^PRINTER_INFO_2W; | |
| PRINTER_INFO_2 :: PRINTER_INFO_2A; | |
| PPRINTER_INFO_2 :: PPRINTER_INFO_2A; | |
| LPPRINTER_INFO_2 :: LPPRINTER_INFO_2A; | |
| PRINTER_INFO_3 :: struct { | |
| pSecurityDescriptor : PSECURITY_DESCRIPTOR, | |
| }; | |
| PPRINTER_INFO_3 :: ^PRINTER_INFO_3; | |
| LPPRINTER_INFO_3 :: ^PRINTER_INFO_3; | |
| PRINTER_INFO_4A :: struct { | |
| pPrinterName : LPSTR, | |
| pServerName : LPSTR, | |
| Attributes : DWORD, | |
| }; | |
| PPRINTER_INFO_4A :: ^PRINTER_INFO_4A; | |
| LPPRINTER_INFO_4A :: ^PRINTER_INFO_4A; | |
| PRINTER_INFO_4W :: struct { | |
| pPrinterName : LPWSTR, | |
| pServerName : LPWSTR, | |
| Attributes : DWORD, | |
| }; | |
| PPRINTER_INFO_4W :: ^PRINTER_INFO_4W; | |
| LPPRINTER_INFO_4W :: ^PRINTER_INFO_4W; | |
| PRINTER_INFO_4 :: PRINTER_INFO_4A; | |
| PPRINTER_INFO_4 :: PPRINTER_INFO_4A; | |
| LPPRINTER_INFO_4 :: LPPRINTER_INFO_4A; | |
| PRINTER_INFO_5A :: struct { | |
| pPrinterName : LPSTR, | |
| pPortName : LPSTR, | |
| Attributes : DWORD, | |
| DeviceNotSelectedTimeout : DWORD, | |
| TransmissionRetryTimeout : DWORD, | |
| }; | |
| PPRINTER_INFO_5A :: ^PRINTER_INFO_5A; | |
| LPPRINTER_INFO_5A :: ^PRINTER_INFO_5A; | |
| PRINTER_INFO_5W :: struct { | |
| pPrinterName : LPWSTR, | |
| pPortName : LPWSTR, | |
| Attributes : DWORD, | |
| DeviceNotSelectedTimeout : DWORD, | |
| TransmissionRetryTimeout : DWORD, | |
| }; | |
| PPRINTER_INFO_5W :: ^PRINTER_INFO_5W; | |
| LPPRINTER_INFO_5W :: ^PRINTER_INFO_5W; | |
| PRINTER_INFO_5 :: PRINTER_INFO_5A; | |
| PPRINTER_INFO_5 :: PPRINTER_INFO_5A; | |
| LPPRINTER_INFO_5 :: LPPRINTER_INFO_5A; | |
| PRINTER_INFO_6 :: struct { | |
| dwStatus : DWORD, | |
| }; | |
| PPRINTER_INFO_6 :: ^PRINTER_INFO_6; | |
| LPPRINTER_INFO_6 :: ^PRINTER_INFO_6; | |
| PRINTER_INFO_7A :: struct { | |
| pszObjectGUID : LPSTR, | |
| dwAction : DWORD, | |
| }; | |
| PPRINTER_INFO_7A :: ^PRINTER_INFO_7A; | |
| LPPRINTER_INFO_7A :: ^PRINTER_INFO_7A; | |
| PRINTER_INFO_7W :: struct { | |
| pszObjectGUID : LPWSTR, | |
| dwAction : DWORD, | |
| }; | |
| PPRINTER_INFO_7W :: ^PRINTER_INFO_7W; | |
| LPPRINTER_INFO_7W :: ^PRINTER_INFO_7W; | |
| PRINTER_INFO_7 :: PRINTER_INFO_7A; | |
| PPRINTER_INFO_7 :: PPRINTER_INFO_7A; | |
| LPPRINTER_INFO_7 :: LPPRINTER_INFO_7A; | |
| PRINTER_INFO_8A :: struct { | |
| pDevMode : LPDEVMODEA, | |
| }; | |
| PPRINTER_INFO_8A :: ^PRINTER_INFO_8A; | |
| LPPRINTER_INFO_8A :: ^PRINTER_INFO_8A; | |
| PRINTER_INFO_8W :: struct { | |
| pDevMode : LPDEVMODEW, | |
| }; | |
| PPRINTER_INFO_8W :: ^PRINTER_INFO_8W; | |
| LPPRINTER_INFO_8W :: ^PRINTER_INFO_8W; | |
| PRINTER_INFO_8 :: PRINTER_INFO_8A; | |
| PPRINTER_INFO_8 :: PPRINTER_INFO_8A; | |
| LPPRINTER_INFO_8 :: LPPRINTER_INFO_8A; | |
| PRINTER_INFO_9A :: struct { | |
| pDevMode : LPDEVMODEA, | |
| }; | |
| PPRINTER_INFO_9A :: ^PRINTER_INFO_9A; | |
| LPPRINTER_INFO_9A :: ^PRINTER_INFO_9A; | |
| PRINTER_INFO_9W :: struct { | |
| pDevMode : LPDEVMODEW, | |
| }; | |
| PPRINTER_INFO_9W :: ^PRINTER_INFO_9W; | |
| LPPRINTER_INFO_9W :: ^PRINTER_INFO_9W; | |
| PRINTER_INFO_9 :: PRINTER_INFO_9A; | |
| PPRINTER_INFO_9 :: PPRINTER_INFO_9A; | |
| LPPRINTER_INFO_9 :: LPPRINTER_INFO_9A; | |
| JOB_INFO_1A :: struct { | |
| JobId : DWORD, | |
| pPrinterName : LPSTR, | |
| pMachineName : LPSTR, | |
| pUserName : LPSTR, | |
| pDocument : LPSTR, | |
| pDatatype : LPSTR, | |
| pStatus : LPSTR, | |
| Status : DWORD, | |
| Priority : DWORD, | |
| Position : DWORD, | |
| TotalPages : DWORD, | |
| PagesPrinted : DWORD, | |
| Submitted : SYSTEMTIME, | |
| }; | |
| PJOB_INFO_1A :: ^JOB_INFO_1A; | |
| LPJOB_INFO_1A :: ^JOB_INFO_1A; | |
| JOB_INFO_1W :: struct { | |
| JobId : DWORD, | |
| pPrinterName : LPWSTR, | |
| pMachineName : LPWSTR, | |
| pUserName : LPWSTR, | |
| pDocument : LPWSTR, | |
| pDatatype : LPWSTR, | |
| pStatus : LPWSTR, | |
| Status : DWORD, | |
| Priority : DWORD, | |
| Position : DWORD, | |
| TotalPages : DWORD, | |
| PagesPrinted : DWORD, | |
| Submitted : SYSTEMTIME, | |
| }; | |
| PJOB_INFO_1W :: ^JOB_INFO_1W; | |
| LPJOB_INFO_1W :: ^JOB_INFO_1W; | |
| JOB_INFO_1 :: JOB_INFO_1A; | |
| PJOB_INFO_1 :: PJOB_INFO_1A; | |
| LPJOB_INFO_1 :: LPJOB_INFO_1A; | |
| JOB_INFO_2A :: struct { | |
| JobId : DWORD, | |
| pPrinterName : LPSTR, | |
| pMachineName : LPSTR, | |
| pUserName : LPSTR, | |
| pDocument : LPSTR, | |
| pNotifyName : LPSTR, | |
| pDatatype : LPSTR, | |
| pPrintProcessor : LPSTR, | |
| pParameters : LPSTR, | |
| pDriverName : LPSTR, | |
| pDevMode : LPDEVMODEA, | |
| pStatus : LPSTR, | |
| pSecurityDescriptor : PSECURITY_DESCRIPTOR, | |
| Status : DWORD, | |
| Priority : DWORD, | |
| Position : DWORD, | |
| StartTime : DWORD, | |
| UntilTime : DWORD, | |
| TotalPages : DWORD, | |
| Size : DWORD, | |
| Submitted : SYSTEMTIME, | |
| Time : DWORD, | |
| PagesPrinted : DWORD, | |
| }; | |
| PJOB_INFO_2A :: ^JOB_INFO_2A; | |
| LPJOB_INFO_2A :: ^JOB_INFO_2A; | |
| JOB_INFO_2W :: struct { | |
| JobId : DWORD, | |
| pPrinterName : LPWSTR, | |
| pMachineName : LPWSTR, | |
| pUserName : LPWSTR, | |
| pDocument : LPWSTR, | |
| pNotifyName : LPWSTR, | |
| pDatatype : LPWSTR, | |
| pPrintProcessor : LPWSTR, | |
| pParameters : LPWSTR, | |
| pDriverName : LPWSTR, | |
| pDevMode : LPDEVMODEW, | |
| pStatus : LPWSTR, | |
| pSecurityDescriptor : PSECURITY_DESCRIPTOR, | |
| Status : DWORD, | |
| Priority : DWORD, | |
| Position : DWORD, | |
| StartTime : DWORD, | |
| UntilTime : DWORD, | |
| TotalPages : DWORD, | |
| Size : DWORD, | |
| Submitted : SYSTEMTIME, | |
| Time : DWORD, | |
| PagesPrinted : DWORD, | |
| }; | |
| PJOB_INFO_2W :: ^JOB_INFO_2W; | |
| LPJOB_INFO_2W :: ^JOB_INFO_2W; | |
| JOB_INFO_2 :: JOB_INFO_2A; | |
| PJOB_INFO_2 :: PJOB_INFO_2A; | |
| LPJOB_INFO_2 :: LPJOB_INFO_2A; | |
| JOB_INFO_3 :: struct { | |
| JobId : DWORD, | |
| NextJobId : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PJOB_INFO_3 :: ^JOB_INFO_3; | |
| LPJOB_INFO_3 :: ^JOB_INFO_3; | |
| JOB_INFO_4A :: struct { | |
| JobId : DWORD, | |
| pPrinterName : LPSTR, | |
| pMachineName : LPSTR, | |
| pUserName : LPSTR, | |
| pDocument : LPSTR, | |
| pNotifyName : LPSTR, | |
| pDatatype : LPSTR, | |
| pPrintProcessor : LPSTR, | |
| pParameters : LPSTR, | |
| pDriverName : LPSTR, | |
| pDevMode : LPDEVMODEA, | |
| pStatus : LPSTR, | |
| pSecurityDescriptor : PSECURITY_DESCRIPTOR, | |
| Status : DWORD, | |
| Priority : DWORD, | |
| Position : DWORD, | |
| StartTime : DWORD, | |
| UntilTime : DWORD, | |
| TotalPages : DWORD, | |
| Size : DWORD, | |
| Submitted : SYSTEMTIME, | |
| Time : DWORD, | |
| PagesPrinted : DWORD, | |
| SizeHigh : LONG, | |
| }; | |
| PJOB_INFO_4A :: ^JOB_INFO_4A; | |
| LPJOB_INFO_4A :: ^JOB_INFO_4A; | |
| JOB_INFO_4W :: struct { | |
| JobId : DWORD, | |
| pPrinterName : LPWSTR, | |
| pMachineName : LPWSTR, | |
| pUserName : LPWSTR, | |
| pDocument : LPWSTR, | |
| pNotifyName : LPWSTR, | |
| pDatatype : LPWSTR, | |
| pPrintProcessor : LPWSTR, | |
| pParameters : LPWSTR, | |
| pDriverName : LPWSTR, | |
| pDevMode : LPDEVMODEW, | |
| pStatus : LPWSTR, | |
| pSecurityDescriptor : PSECURITY_DESCRIPTOR, | |
| Status : DWORD, | |
| Priority : DWORD, | |
| Position : DWORD, | |
| StartTime : DWORD, | |
| UntilTime : DWORD, | |
| TotalPages : DWORD, | |
| Size : DWORD, | |
| Submitted : SYSTEMTIME, | |
| Time : DWORD, | |
| PagesPrinted : DWORD, | |
| SizeHigh : LONG, | |
| }; | |
| PJOB_INFO_4W :: ^JOB_INFO_4W; | |
| LPJOB_INFO_4W :: ^JOB_INFO_4W; | |
| JOB_INFO_4 :: JOB_INFO_4A; | |
| PJOB_INFO_4 :: PJOB_INFO_4A; | |
| LPJOB_INFO_4 :: LPJOB_INFO_4A; | |
| ADDJOB_INFO_1A :: struct { | |
| Path : LPSTR, | |
| JobId : DWORD, | |
| }; | |
| PADDJOB_INFO_1A :: ^ADDJOB_INFO_1A; | |
| LPADDJOB_INFO_1A :: ^ADDJOB_INFO_1A; | |
| ADDJOB_INFO_1W :: struct { | |
| Path : LPWSTR, | |
| JobId : DWORD, | |
| }; | |
| PADDJOB_INFO_1W :: ^ADDJOB_INFO_1W; | |
| LPADDJOB_INFO_1W :: ^ADDJOB_INFO_1W; | |
| ADDJOB_INFO_1 :: ADDJOB_INFO_1A; | |
| PADDJOB_INFO_1 :: PADDJOB_INFO_1A; | |
| LPADDJOB_INFO_1 :: LPADDJOB_INFO_1A; | |
| DRIVER_INFO_1A :: struct { | |
| pName : LPSTR, | |
| }; | |
| PDRIVER_INFO_1A :: ^DRIVER_INFO_1A; | |
| LPDRIVER_INFO_1A :: ^DRIVER_INFO_1A; | |
| DRIVER_INFO_1W :: struct { | |
| pName : LPWSTR, | |
| }; | |
| PDRIVER_INFO_1W :: ^DRIVER_INFO_1W; | |
| LPDRIVER_INFO_1W :: ^DRIVER_INFO_1W; | |
| DRIVER_INFO_1 :: DRIVER_INFO_1A; | |
| PDRIVER_INFO_1 :: PDRIVER_INFO_1A; | |
| LPDRIVER_INFO_1 :: LPDRIVER_INFO_1A; | |
| DRIVER_INFO_2A :: struct { | |
| cVersion : DWORD, | |
| pName : LPSTR, | |
| pEnvironment : LPSTR, | |
| pDriverPath : LPSTR, | |
| pDataFile : LPSTR, | |
| pConfigFile : LPSTR, | |
| }; | |
| PDRIVER_INFO_2A :: ^DRIVER_INFO_2A; | |
| LPDRIVER_INFO_2A :: ^DRIVER_INFO_2A; | |
| DRIVER_INFO_2W :: struct { | |
| cVersion : DWORD, | |
| pName : LPWSTR, | |
| pEnvironment : LPWSTR, | |
| pDriverPath : LPWSTR, | |
| pDataFile : LPWSTR, | |
| pConfigFile : LPWSTR, | |
| }; | |
| PDRIVER_INFO_2W :: ^DRIVER_INFO_2W; | |
| LPDRIVER_INFO_2W :: ^DRIVER_INFO_2W; | |
| DRIVER_INFO_2 :: DRIVER_INFO_2A; | |
| PDRIVER_INFO_2 :: PDRIVER_INFO_2A; | |
| LPDRIVER_INFO_2 :: LPDRIVER_INFO_2A; | |
| DRIVER_INFO_3A :: struct { | |
| cVersion : DWORD, | |
| pName : LPSTR, | |
| pEnvironment : LPSTR, | |
| pDriverPath : LPSTR, | |
| pDataFile : LPSTR, | |
| pConfigFile : LPSTR, | |
| pHelpFile : LPSTR, | |
| pDependentFiles : LPSTR, | |
| pMonitorName : LPSTR, | |
| pDefaultDataType : LPSTR, | |
| }; | |
| PDRIVER_INFO_3A :: ^DRIVER_INFO_3A; | |
| LPDRIVER_INFO_3A :: ^DRIVER_INFO_3A; | |
| DRIVER_INFO_3W :: struct { | |
| cVersion : DWORD, | |
| pName : LPWSTR, | |
| pEnvironment : LPWSTR, | |
| pDriverPath : LPWSTR, | |
| pDataFile : LPWSTR, | |
| pConfigFile : LPWSTR, | |
| pHelpFile : LPWSTR, | |
| pDependentFiles : LPWSTR, | |
| pMonitorName : LPWSTR, | |
| pDefaultDataType : LPWSTR, | |
| }; | |
| PDRIVER_INFO_3W :: ^DRIVER_INFO_3W; | |
| LPDRIVER_INFO_3W :: ^DRIVER_INFO_3W; | |
| DRIVER_INFO_3 :: DRIVER_INFO_3A; | |
| PDRIVER_INFO_3 :: PDRIVER_INFO_3A; | |
| LPDRIVER_INFO_3 :: LPDRIVER_INFO_3A; | |
| DRIVER_INFO_4A :: struct { | |
| cVersion : DWORD, | |
| pName : LPSTR, | |
| pEnvironment : LPSTR, | |
| pDriverPath : LPSTR, | |
| pDataFile : LPSTR, | |
| pConfigFile : LPSTR, | |
| pHelpFile : LPSTR, | |
| pDependentFiles : LPSTR, | |
| pMonitorName : LPSTR, | |
| pDefaultDataType : LPSTR, | |
| pszzPreviousNames : LPSTR, | |
| }; | |
| PDRIVER_INFO_4A :: ^DRIVER_INFO_4A; | |
| LPDRIVER_INFO_4A :: ^DRIVER_INFO_4A; | |
| DRIVER_INFO_4W :: struct { | |
| cVersion : DWORD, | |
| pName : LPWSTR, | |
| pEnvironment : LPWSTR, | |
| pDriverPath : LPWSTR, | |
| pDataFile : LPWSTR, | |
| pConfigFile : LPWSTR, | |
| pHelpFile : LPWSTR, | |
| pDependentFiles : LPWSTR, | |
| pMonitorName : LPWSTR, | |
| pDefaultDataType : LPWSTR, | |
| pszzPreviousNames : LPWSTR, | |
| }; | |
| PDRIVER_INFO_4W :: ^DRIVER_INFO_4W; | |
| LPDRIVER_INFO_4W :: ^DRIVER_INFO_4W; | |
| DRIVER_INFO_4 :: DRIVER_INFO_4A; | |
| PDRIVER_INFO_4 :: PDRIVER_INFO_4A; | |
| LPDRIVER_INFO_4 :: LPDRIVER_INFO_4A; | |
| DRIVER_INFO_5A :: struct { | |
| cVersion : DWORD, | |
| pName : LPSTR, | |
| pEnvironment : LPSTR, | |
| pDriverPath : LPSTR, | |
| pDataFile : LPSTR, | |
| pConfigFile : LPSTR, | |
| dwDriverAttributes : DWORD, | |
| dwConfigVersion : DWORD, | |
| dwDriverVersion : DWORD, | |
| }; | |
| PDRIVER_INFO_5A :: ^DRIVER_INFO_5A; | |
| LPDRIVER_INFO_5A :: ^DRIVER_INFO_5A; | |
| DRIVER_INFO_5W :: struct { | |
| cVersion : DWORD, | |
| pName : LPWSTR, | |
| pEnvironment : LPWSTR, | |
| pDriverPath : LPWSTR, | |
| pDataFile : LPWSTR, | |
| pConfigFile : LPWSTR, | |
| dwDriverAttributes : DWORD, | |
| dwConfigVersion : DWORD, | |
| dwDriverVersion : DWORD, | |
| }; | |
| PDRIVER_INFO_5W :: ^DRIVER_INFO_5W; | |
| LPDRIVER_INFO_5W :: ^DRIVER_INFO_5W; | |
| DRIVER_INFO_5 :: DRIVER_INFO_5A; | |
| PDRIVER_INFO_5 :: PDRIVER_INFO_5A; | |
| LPDRIVER_INFO_5 :: LPDRIVER_INFO_5A; | |
| DRIVER_INFO_6A :: struct { | |
| cVersion : DWORD, | |
| pName : LPSTR, | |
| pEnvironment : LPSTR, | |
| pDriverPath : LPSTR, | |
| pDataFile : LPSTR, | |
| pConfigFile : LPSTR, | |
| pHelpFile : LPSTR, | |
| pDependentFiles : LPSTR, | |
| pMonitorName : LPSTR, | |
| pDefaultDataType : LPSTR, | |
| pszzPreviousNames : LPSTR, | |
| ftDriverDate : FILETIME, | |
| dwlDriverVersion : DWORDLONG, | |
| pszMfgName : LPSTR, | |
| pszOEMUrl : LPSTR, | |
| pszHardwareID : LPSTR, | |
| pszProvider : LPSTR, | |
| }; | |
| PDRIVER_INFO_6A :: ^DRIVER_INFO_6A; | |
| LPDRIVER_INFO_6A :: ^DRIVER_INFO_6A; | |
| DRIVER_INFO_6W :: struct { | |
| cVersion : DWORD, | |
| pName : LPWSTR, | |
| pEnvironment : LPWSTR, | |
| pDriverPath : LPWSTR, | |
| pDataFile : LPWSTR, | |
| pConfigFile : LPWSTR, | |
| pHelpFile : LPWSTR, | |
| pDependentFiles : LPWSTR, | |
| pMonitorName : LPWSTR, | |
| pDefaultDataType : LPWSTR, | |
| pszzPreviousNames : LPWSTR, | |
| ftDriverDate : FILETIME, | |
| dwlDriverVersion : DWORDLONG, | |
| pszMfgName : LPWSTR, | |
| pszOEMUrl : LPWSTR, | |
| pszHardwareID : LPWSTR, | |
| pszProvider : LPWSTR, | |
| }; | |
| PDRIVER_INFO_6W :: ^DRIVER_INFO_6W; | |
| LPDRIVER_INFO_6W :: ^DRIVER_INFO_6W; | |
| DRIVER_INFO_6 :: DRIVER_INFO_6A; | |
| PDRIVER_INFO_6 :: PDRIVER_INFO_6A; | |
| LPDRIVER_INFO_6 :: LPDRIVER_INFO_6A; | |
| DRIVER_INFO_8A :: struct { | |
| cVersion : DWORD, | |
| pName : LPSTR, | |
| pEnvironment : LPSTR, | |
| pDriverPath : LPSTR, | |
| pDataFile : LPSTR, | |
| pConfigFile : LPSTR, | |
| pHelpFile : LPSTR, | |
| pDependentFiles : LPSTR, | |
| pMonitorName : LPSTR, | |
| pDefaultDataType : LPSTR, | |
| pszzPreviousNames : LPSTR, | |
| ftDriverDate : FILETIME, | |
| dwlDriverVersion : DWORDLONG, | |
| pszMfgName : LPSTR, | |
| pszOEMUrl : LPSTR, | |
| pszHardwareID : LPSTR, | |
| pszProvider : LPSTR, | |
| pszPrintProcessor : LPSTR, | |
| pszVendorSetup : LPSTR, | |
| pszzColorProfiles : LPSTR, | |
| pszInfPath : LPSTR, | |
| dwPrinterDriverAttributes : DWORD, | |
| pszzCoreDriverDependencies : LPSTR, | |
| ftMinInboxDriverVerDate : FILETIME, | |
| dwlMinInboxDriverVerVersion : DWORDLONG, | |
| }; | |
| PDRIVER_INFO_8A :: ^DRIVER_INFO_8A; | |
| LPDRIVER_INFO_8A :: ^DRIVER_INFO_8A; | |
| DRIVER_INFO_8W :: struct { | |
| cVersion : DWORD, | |
| pName : LPWSTR, | |
| pEnvironment : LPWSTR, | |
| pDriverPath : LPWSTR, | |
| pDataFile : LPWSTR, | |
| pConfigFile : LPWSTR, | |
| pHelpFile : LPWSTR, | |
| pDependentFiles : LPWSTR, | |
| pMonitorName : LPWSTR, | |
| pDefaultDataType : LPWSTR, | |
| pszzPreviousNames : LPWSTR, | |
| ftDriverDate : FILETIME, | |
| dwlDriverVersion : DWORDLONG, | |
| pszMfgName : LPWSTR, | |
| pszOEMUrl : LPWSTR, | |
| pszHardwareID : LPWSTR, | |
| pszProvider : LPWSTR, | |
| pszPrintProcessor : LPWSTR, | |
| pszVendorSetup : LPWSTR, | |
| pszzColorProfiles : LPWSTR, | |
| pszInfPath : LPWSTR, | |
| dwPrinterDriverAttributes : DWORD, | |
| pszzCoreDriverDependencies : LPWSTR, | |
| ftMinInboxDriverVerDate : FILETIME, | |
| dwlMinInboxDriverVerVersion : DWORDLONG, | |
| }; | |
| PDRIVER_INFO_8W :: ^DRIVER_INFO_8W; | |
| LPDRIVER_INFO_8W :: ^DRIVER_INFO_8W; | |
| DRIVER_INFO_8 :: DRIVER_INFO_8A; | |
| PDRIVER_INFO_8 :: PDRIVER_INFO_8A; | |
| LPDRIVER_INFO_8 :: LPDRIVER_INFO_8A; | |
| DOC_INFO_1A :: struct { | |
| pDocName : LPSTR, | |
| pOutputFile : LPSTR, | |
| pDatatype : LPSTR, | |
| }; | |
| PDOC_INFO_1A :: ^DOC_INFO_1A; | |
| LPDOC_INFO_1A :: ^DOC_INFO_1A; | |
| DOC_INFO_1W :: struct { | |
| pDocName : LPWSTR, | |
| pOutputFile : LPWSTR, | |
| pDatatype : LPWSTR, | |
| }; | |
| PDOC_INFO_1W :: ^DOC_INFO_1W; | |
| LPDOC_INFO_1W :: ^DOC_INFO_1W; | |
| DOC_INFO_1 :: DOC_INFO_1A; | |
| PDOC_INFO_1 :: PDOC_INFO_1A; | |
| LPDOC_INFO_1 :: LPDOC_INFO_1A; | |
| FORM_INFO_1A :: struct { | |
| Flags : DWORD, | |
| pName : LPSTR, | |
| Size : SIZEL, | |
| ImageableArea : RECTL, | |
| }; | |
| PFORM_INFO_1A :: ^FORM_INFO_1A; | |
| LPFORM_INFO_1A :: ^FORM_INFO_1A; | |
| FORM_INFO_1W :: struct { | |
| Flags : DWORD, | |
| pName : LPWSTR, | |
| Size : SIZEL, | |
| ImageableArea : RECTL, | |
| }; | |
| PFORM_INFO_1W :: ^FORM_INFO_1W; | |
| LPFORM_INFO_1W :: ^FORM_INFO_1W; | |
| FORM_INFO_1 :: FORM_INFO_1A; | |
| PFORM_INFO_1 :: PFORM_INFO_1A; | |
| LPFORM_INFO_1 :: LPFORM_INFO_1A; | |
| FORM_INFO_2A :: struct { | |
| Flags : DWORD, | |
| pName : LPCSTR, | |
| Size : SIZEL, | |
| ImageableArea : RECTL, | |
| pKeyword : LPCSTR, | |
| StringType : DWORD, | |
| pMuiDll : LPCSTR, | |
| dwResourceId : DWORD, | |
| pDisplayName : LPCSTR, | |
| wLangId : LANGID, | |
| }; | |
| PFORM_INFO_2A :: ^FORM_INFO_2A; | |
| LPFORM_INFO_2A :: ^FORM_INFO_2A; | |
| FORM_INFO_2W :: struct { | |
| Flags : DWORD, | |
| pName : LPCWSTR, | |
| Size : SIZEL, | |
| ImageableArea : RECTL, | |
| pKeyword : LPCSTR, | |
| StringType : DWORD, | |
| pMuiDll : LPCWSTR, | |
| dwResourceId : DWORD, | |
| pDisplayName : LPCWSTR, | |
| wLangId : LANGID, | |
| }; | |
| PFORM_INFO_2W :: ^FORM_INFO_2W; | |
| LPFORM_INFO_2W :: ^FORM_INFO_2W; | |
| FORM_INFO_2 :: FORM_INFO_2A; | |
| PFORM_INFO_2 :: PFORM_INFO_2A; | |
| LPFORM_INFO_2 :: LPFORM_INFO_2A; | |
| DOC_INFO_2A :: struct { | |
| pDocName : LPSTR, | |
| pOutputFile : LPSTR, | |
| pDatatype : LPSTR, | |
| dwMode : DWORD, | |
| JobId : DWORD, | |
| }; | |
| PDOC_INFO_2A :: ^DOC_INFO_2A; | |
| LPDOC_INFO_2A :: ^DOC_INFO_2A; | |
| DOC_INFO_2W :: struct { | |
| pDocName : LPWSTR, | |
| pOutputFile : LPWSTR, | |
| pDatatype : LPWSTR, | |
| dwMode : DWORD, | |
| JobId : DWORD, | |
| }; | |
| PDOC_INFO_2W :: ^DOC_INFO_2W; | |
| LPDOC_INFO_2W :: ^DOC_INFO_2W; | |
| DOC_INFO_2 :: DOC_INFO_2A; | |
| PDOC_INFO_2 :: PDOC_INFO_2A; | |
| LPDOC_INFO_2 :: LPDOC_INFO_2A; | |
| DOC_INFO_3A :: struct { | |
| pDocName : LPSTR, | |
| pOutputFile : LPSTR, | |
| pDatatype : LPSTR, | |
| dwFlags : DWORD, | |
| }; | |
| PDOC_INFO_3A :: ^DOC_INFO_3A; | |
| LPDOC_INFO_3A :: ^DOC_INFO_3A; | |
| DOC_INFO_3W :: struct { | |
| pDocName : LPWSTR, | |
| pOutputFile : LPWSTR, | |
| pDatatype : LPWSTR, | |
| dwFlags : DWORD, | |
| }; | |
| PDOC_INFO_3W :: ^DOC_INFO_3W; | |
| LPDOC_INFO_3W :: ^DOC_INFO_3W; | |
| DOC_INFO_3 :: DOC_INFO_3A; | |
| PDOC_INFO_3 :: PDOC_INFO_3A; | |
| LPDOC_INFO_3 :: LPDOC_INFO_3A; | |
| PRINTPROCESSOR_INFO_1A :: struct { | |
| pName : LPSTR, | |
| }; | |
| PPRINTPROCESSOR_INFO_1A :: ^PRINTPROCESSOR_INFO_1A; | |
| LPPRINTPROCESSOR_INFO_1A :: ^PRINTPROCESSOR_INFO_1A; | |
| PRINTPROCESSOR_INFO_1W :: struct { | |
| pName : LPWSTR, | |
| }; | |
| PPRINTPROCESSOR_INFO_1W :: ^PRINTPROCESSOR_INFO_1W; | |
| LPPRINTPROCESSOR_INFO_1W :: ^PRINTPROCESSOR_INFO_1W; | |
| PRINTPROCESSOR_INFO_1 :: PRINTPROCESSOR_INFO_1A; | |
| PPRINTPROCESSOR_INFO_1 :: PPRINTPROCESSOR_INFO_1A; | |
| LPPRINTPROCESSOR_INFO_1 :: LPPRINTPROCESSOR_INFO_1A; | |
| PRINTPROCESSOR_CAPS_1 :: struct { | |
| dwLevel : DWORD, | |
| dwNupOptions : DWORD, | |
| dwPageOrderFlags : DWORD, | |
| dwNumberOfCopies : DWORD, | |
| }; | |
| PPRINTPROCESSOR_CAPS_1 :: ^PRINTPROCESSOR_CAPS_1; | |
| PRINTPROCESSOR_CAPS_2 :: struct { | |
| dwLevel : DWORD, | |
| dwNupOptions : DWORD, | |
| dwPageOrderFlags : DWORD, | |
| dwNumberOfCopies : DWORD, | |
| dwDuplexHandlingCaps : DWORD, | |
| dwNupDirectionCaps : DWORD, | |
| dwNupBorderCaps : DWORD, | |
| dwBookletHandlingCaps : DWORD, | |
| dwScalingCaps : DWORD, | |
| }; | |
| PPRINTPROCESSOR_CAPS_2 :: ^PRINTPROCESSOR_CAPS_2; | |
| PORT_INFO_1A :: struct { | |
| pName : LPSTR, | |
| }; | |
| PPORT_INFO_1A :: ^PORT_INFO_1A; | |
| LPPORT_INFO_1A :: ^PORT_INFO_1A; | |
| PORT_INFO_1W :: struct { | |
| pName : LPWSTR, | |
| }; | |
| PPORT_INFO_1W :: ^PORT_INFO_1W; | |
| LPPORT_INFO_1W :: ^PORT_INFO_1W; | |
| PORT_INFO_1 :: PORT_INFO_1A; | |
| PPORT_INFO_1 :: PPORT_INFO_1A; | |
| LPPORT_INFO_1 :: LPPORT_INFO_1A; | |
| PORT_INFO_2A :: struct { | |
| pPortName : LPSTR, | |
| pMonitorName : LPSTR, | |
| pDescription : LPSTR, | |
| fPortType : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PPORT_INFO_2A :: ^PORT_INFO_2A; | |
| LPPORT_INFO_2A :: ^PORT_INFO_2A; | |
| PORT_INFO_2W :: struct { | |
| pPortName : LPWSTR, | |
| pMonitorName : LPWSTR, | |
| pDescription : LPWSTR, | |
| fPortType : DWORD, | |
| Reserved : DWORD, | |
| }; | |
| PPORT_INFO_2W :: ^PORT_INFO_2W; | |
| LPPORT_INFO_2W :: ^PORT_INFO_2W; | |
| PORT_INFO_2 :: PORT_INFO_2A; | |
| PPORT_INFO_2 :: PPORT_INFO_2A; | |
| LPPORT_INFO_2 :: LPPORT_INFO_2A; | |
| PORT_INFO_3A :: struct { | |
| dwStatus : DWORD, | |
| pszStatus : LPSTR, | |
| dwSeverity : DWORD, | |
| }; | |
| PPORT_INFO_3A :: ^PORT_INFO_3A; | |
| LPPORT_INFO_3A :: ^PORT_INFO_3A; | |
| PORT_INFO_3W :: struct { | |
| dwStatus : DWORD, | |
| pszStatus : LPWSTR, | |
| dwSeverity : DWORD, | |
| }; | |
| PPORT_INFO_3W :: ^PORT_INFO_3W; | |
| LPPORT_INFO_3W :: ^PORT_INFO_3W; | |
| PORT_INFO_3 :: PORT_INFO_3A; | |
| PPORT_INFO_3 :: PPORT_INFO_3A; | |
| LPPORT_INFO_3 :: LPPORT_INFO_3A; | |
| MONITOR_INFO_1A :: struct { | |
| pName : LPSTR, | |
| }; | |
| PMONITOR_INFO_1A :: ^MONITOR_INFO_1A; | |
| LPMONITOR_INFO_1A :: ^MONITOR_INFO_1A; | |
| MONITOR_INFO_1W :: struct { | |
| pName : LPWSTR, | |
| }; | |
| PMONITOR_INFO_1W :: ^MONITOR_INFO_1W; | |
| LPMONITOR_INFO_1W :: ^MONITOR_INFO_1W; | |
| MONITOR_INFO_1 :: MONITOR_INFO_1A; | |
| PMONITOR_INFO_1 :: PMONITOR_INFO_1A; | |
| LPMONITOR_INFO_1 :: LPMONITOR_INFO_1A; | |
| MONITOR_INFO_2A :: struct { | |
| pName : LPSTR, | |
| pEnvironment : LPSTR, | |
| pDLLName : LPSTR, | |
| }; | |
| PMONITOR_INFO_2A :: ^MONITOR_INFO_2A; | |
| LPMONITOR_INFO_2A :: ^MONITOR_INFO_2A; | |
| MONITOR_INFO_2W :: struct { | |
| pName : LPWSTR, | |
| pEnvironment : LPWSTR, | |
| pDLLName : LPWSTR, | |
| }; | |
| PMONITOR_INFO_2W :: ^MONITOR_INFO_2W; | |
| LPMONITOR_INFO_2W :: ^MONITOR_INFO_2W; | |
| MONITOR_INFO_2 :: MONITOR_INFO_2A; | |
| PMONITOR_INFO_2 :: PMONITOR_INFO_2A; | |
| LPMONITOR_INFO_2 :: LPMONITOR_INFO_2A; | |
| DATATYPES_INFO_1A :: struct { | |
| pName : LPSTR, | |
| }; | |
| PDATATYPES_INFO_1A :: ^DATATYPES_INFO_1A; | |
| LPDATATYPES_INFO_1A :: ^DATATYPES_INFO_1A; | |
| DATATYPES_INFO_1W :: struct { | |
| pName : LPWSTR, | |
| }; | |
| PDATATYPES_INFO_1W :: ^DATATYPES_INFO_1W; | |
| LPDATATYPES_INFO_1W :: ^DATATYPES_INFO_1W; | |
| DATATYPES_INFO_1 :: DATATYPES_INFO_1A; | |
| PDATATYPES_INFO_1 :: PDATATYPES_INFO_1A; | |
| LPDATATYPES_INFO_1 :: LPDATATYPES_INFO_1A; | |
| PRINTER_DEFAULTSA :: struct { | |
| pDatatype : LPSTR, | |
| pDevMode : LPDEVMODEA, | |
| DesiredAccess : ACCESS_MASK, | |
| }; | |
| PPRINTER_DEFAULTSA :: ^PRINTER_DEFAULTSA; | |
| LPPRINTER_DEFAULTSA :: ^PRINTER_DEFAULTSA; | |
| PRINTER_DEFAULTSW :: struct { | |
| pDatatype : LPWSTR, | |
| pDevMode : LPDEVMODEW, | |
| DesiredAccess : ACCESS_MASK, | |
| }; | |
| PPRINTER_DEFAULTSW :: ^PRINTER_DEFAULTSW; | |
| LPPRINTER_DEFAULTSW :: ^PRINTER_DEFAULTSW; | |
| PRINTER_DEFAULTS :: PRINTER_DEFAULTSA; | |
| PPRINTER_DEFAULTS :: PPRINTER_DEFAULTSA; | |
| LPPRINTER_DEFAULTS :: LPPRINTER_DEFAULTSA; | |
| PRINTER_ENUM_VALUESA :: struct { | |
| pValueName : LPSTR, | |
| cbValueName : DWORD, | |
| dwType : DWORD, | |
| pData : LPBYTE, | |
| cbData : DWORD, | |
| }; | |
| PPRINTER_ENUM_VALUESA :: ^PRINTER_ENUM_VALUESA; | |
| LPPRINTER_ENUM_VALUESA :: ^PRINTER_ENUM_VALUESA; | |
| PRINTER_ENUM_VALUESW :: struct { | |
| pValueName : LPWSTR, | |
| cbValueName : DWORD, | |
| dwType : DWORD, | |
| pData : LPBYTE, | |
| cbData : DWORD, | |
| }; | |
| PPRINTER_ENUM_VALUESW :: ^PRINTER_ENUM_VALUESW; | |
| LPPRINTER_ENUM_VALUESW :: ^PRINTER_ENUM_VALUESW; | |
| PRINTER_ENUM_VALUES :: PRINTER_ENUM_VALUESA; | |
| PPRINTER_ENUM_VALUES :: PPRINTER_ENUM_VALUESA; | |
| LPPRINTER_ENUM_VALUES :: LPPRINTER_ENUM_VALUESA; | |
| PRINTER_NOTIFY_OPTIONS_TYPE :: struct { | |
| Type : WORD, | |
| Reserved0 : WORD, | |
| Reserved1 : DWORD, | |
| Reserved2 : DWORD, | |
| Count : DWORD, | |
| pFields : PWORD, | |
| }; | |
| PPRINTER_NOTIFY_OPTIONS_TYPE :: ^PRINTER_NOTIFY_OPTIONS_TYPE; | |
| LPPRINTER_NOTIFY_OPTIONS_TYPE :: ^PRINTER_NOTIFY_OPTIONS_TYPE; | |
| PRINTER_NOTIFY_OPTIONS :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| Count : DWORD, | |
| pTypes : PPRINTER_NOTIFY_OPTIONS_TYPE, | |
| }; | |
| PPRINTER_NOTIFY_OPTIONS :: ^PRINTER_NOTIFY_OPTIONS; | |
| LPPRINTER_NOTIFY_OPTIONS :: ^PRINTER_NOTIFY_OPTIONS; | |
| PRINTER_NOTIFY_INFO_DATA :: struct { | |
| Type : WORD, | |
| Field : WORD, | |
| Reserved : DWORD, | |
| Id : DWORD, | |
| NotifyData : struct #raw_union { | |
| adwData : [2]DWORD, | |
| Data : struct { | |
| cbBuf : DWORD, | |
| pBuf : LPVOID, | |
| }, | |
| }, | |
| }; | |
| PPRINTER_NOTIFY_INFO_DATA :: ^PRINTER_NOTIFY_INFO_DATA; | |
| LPPRINTER_NOTIFY_INFO_DATA :: ^PRINTER_NOTIFY_INFO_DATA; | |
| PRINTER_NOTIFY_INFO :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| Count : DWORD, | |
| aData : [1]PRINTER_NOTIFY_INFO_DATA, | |
| }; | |
| PPRINTER_NOTIFY_INFO :: ^PRINTER_NOTIFY_INFO; | |
| LPPRINTER_NOTIFY_INFO :: ^PRINTER_NOTIFY_INFO; | |
| BINARY_CONTAINER :: struct { | |
| cbBuf : DWORD, | |
| pData : LPBYTE, | |
| }; | |
| PBINARY_CONTAINER :: ^BINARY_CONTAINER; | |
| BIDI_DATA :: struct { | |
| dwBidiType : DWORD, | |
| u : struct #raw_union { | |
| bData : BOOL, | |
| iData : LONG, | |
| sData : LPWSTR, | |
| fData : FLOAT, | |
| biData : BINARY_CONTAINER, | |
| }, | |
| }; | |
| PBIDI_DATA :: ^BIDI_DATA; | |
| LPBIDI_DATA :: ^BIDI_DATA; | |
| BIDI_REQUEST_DATA :: struct { | |
| dwReqNumber : DWORD, | |
| pSchema : LPWSTR, | |
| data : BIDI_DATA, | |
| }; | |
| PBIDI_REQUEST_DATA :: ^BIDI_REQUEST_DATA; | |
| LPBIDI_REQUEST_DATA :: ^BIDI_REQUEST_DATA; | |
| BIDI_REQUEST_CONTAINER :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| Count : DWORD, | |
| aData : [1]BIDI_REQUEST_DATA, | |
| }; | |
| PBIDI_REQUEST_CONTAINER :: ^BIDI_REQUEST_CONTAINER; | |
| LPBIDI_REQUEST_CONTAINER :: ^BIDI_REQUEST_CONTAINER; | |
| BIDI_RESPONSE_DATA :: struct { | |
| dwResult : DWORD, | |
| dwReqNumber : DWORD, | |
| pSchema : LPWSTR, | |
| data : BIDI_DATA, | |
| }; | |
| PBIDI_RESPONSE_DATA :: ^BIDI_RESPONSE_DATA; | |
| LPBIDI_RESPONSE_DATA :: ^BIDI_RESPONSE_DATA; | |
| BIDI_RESPONSE_CONTAINER :: struct { | |
| Version : DWORD, | |
| Flags : DWORD, | |
| Count : DWORD, | |
| aData : [1]BIDI_RESPONSE_DATA, | |
| }; | |
| PBIDI_RESPONSE_CONTAINER :: ^BIDI_RESPONSE_CONTAINER; | |
| LPBIDI_RESPONSE_CONTAINER :: ^BIDI_RESPONSE_CONTAINER; | |
| /* BIDI_TYPE :: enum { */ | |
| BIDI_TYPE :: _c.int; | |
| BIDI_NULL :: 0; | |
| BIDI_INT :: 1; | |
| BIDI_FLOAT :: 2; | |
| BIDI_BOOL :: 3; | |
| BIDI_STRING :: 4; | |
| BIDI_TEXT :: 5; | |
| BIDI_ENUM :: 6; | |
| BIDI_BLOB :: 7; | |
| /* } */ | |
| ; | |
| PROVIDOR_INFO_1A :: struct { | |
| pName : LPSTR, | |
| pEnvironment : LPSTR, | |
| pDLLName : LPSTR, | |
| }; | |
| PPROVIDOR_INFO_1A :: ^PROVIDOR_INFO_1A; | |
| LPPROVIDOR_INFO_1A :: ^PROVIDOR_INFO_1A; | |
| PROVIDOR_INFO_1W :: struct { | |
| pName : LPWSTR, | |
| pEnvironment : LPWSTR, | |
| pDLLName : LPWSTR, | |
| }; | |
| PPROVIDOR_INFO_1W :: ^PROVIDOR_INFO_1W; | |
| LPPROVIDOR_INFO_1W :: ^PROVIDOR_INFO_1W; | |
| PROVIDOR_INFO_1 :: PROVIDOR_INFO_1A; | |
| PPROVIDOR_INFO_1 :: PPROVIDOR_INFO_1A; | |
| LPPROVIDOR_INFO_1 :: LPPROVIDOR_INFO_1A; | |
| PROVIDOR_INFO_2A :: struct { | |
| pOrder : LPSTR, | |
| }; | |
| PPROVIDOR_INFO_2A :: ^PROVIDOR_INFO_2A; | |
| LPPROVIDOR_INFO_2A :: ^PROVIDOR_INFO_2A; | |
| PROVIDOR_INFO_2W :: struct { | |
| pOrder : LPWSTR, | |
| }; | |
| PPROVIDOR_INFO_2W :: ^PROVIDOR_INFO_2W; | |
| LPPROVIDOR_INFO_2W :: ^PROVIDOR_INFO_2W; | |
| PROVIDOR_INFO_2 :: PROVIDOR_INFO_2A; | |
| PPROVIDOR_INFO_2 :: PPROVIDOR_INFO_2A; | |
| LPPROVIDOR_INFO_2 :: LPPROVIDOR_INFO_2A; | |
| /* PRINTER_OPTION_FLAGS :: enum { */ | |
| PRINTER_OPTION_FLAGS :: _c.int; | |
| PRINTER_OPTION_NO_CACHE :: 1 << 0; | |
| PRINTER_OPTION_CACHE :: 1 << 1; | |
| PRINTER_OPTION_CLIENT_CHANGE :: 1 << 2; | |
| PRINTER_OPTION_NO_CLIENT_DATA :: 1 << 3; | |
| /* } */ | |
| ; | |
| PRINTER_OPTIONSA :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| }; | |
| PPRINTER_OPTIONSA :: ^PRINTER_OPTIONSA; | |
| LPPRINTER_OPTIONSA :: ^PRINTER_OPTIONSA; | |
| PRINTER_OPTIONSW :: struct { | |
| cbSize : UINT, | |
| dwFlags : DWORD, | |
| }; | |
| PPRINTER_OPTIONSW :: ^PRINTER_OPTIONSW; | |
| LPPRINTER_OPTIONSW :: ^PRINTER_OPTIONSW; | |
| PRINTER_OPTIONS :: PRINTER_OPTIONSA; | |
| PPRINTER_OPTIONS :: PPRINTER_OPTIONSA; | |
| LPPRINTER_OPTIONS :: LPPRINTER_OPTIONSA; | |
| PRINTER_CONNECTION_INFO_1A :: struct { | |
| dwFlags : DWORD, | |
| pszDriverName : LPSTR, | |
| }; | |
| PPRINTER_CONNECTION_INFO_1A :: ^PRINTER_CONNECTION_INFO_1A; | |
| PRINTER_CONNECTION_INFO_1W :: struct { | |
| dwFlags : DWORD, | |
| pszDriverName : LPWSTR, | |
| }; | |
| PPRINTER_CONNECTION_INFO_1W :: ^PRINTER_CONNECTION_INFO_1W; | |
| PRINTER_CONNECTION_INFO_1 :: PRINTER_CONNECTION_INFO_1A; | |
| PPRINTER_CONNECTION_INFO_1 :: PPRINTER_CONNECTION_INFO_1A; | |
| CORE_PRINTER_DRIVERA :: struct { | |
| CoreDriverGUID : GUID, | |
| ftDriverDate : FILETIME, | |
| dwlDriverVersion : DWORDLONG, | |
| szPackageID : [260]CHAR, | |
| }; | |
| PCORE_PRINTER_DRIVERA :: ^CORE_PRINTER_DRIVERA; | |
| CORE_PRINTER_DRIVERW :: struct { | |
| CoreDriverGUID : GUID, | |
| ftDriverDate : FILETIME, | |
| dwlDriverVersion : DWORDLONG, | |
| szPackageID : [260]WCHAR, | |
| }; | |
| PCORE_PRINTER_DRIVERW :: ^CORE_PRINTER_DRIVERW; | |
| CORE_PRINTER_DRIVER :: CORE_PRINTER_DRIVERA; | |
| PCORE_PRINTER_DRIVER :: PCORE_PRINTER_DRIVERA; | |
| /* EPrintPropertyType :: enum { */ | |
| EPrintPropertyType :: _c.int; | |
| kPropertyTypeString :: 1; | |
| kPropertyTypeInt32 :: kPropertyTypeString + 1; | |
| kPropertyTypeInt64 :: kPropertyTypeInt32 + 1; | |
| kPropertyTypeByte :: kPropertyTypeInt64 + 1; | |
| kPropertyTypeTime :: kPropertyTypeByte + 1; | |
| kPropertyTypeDevMode :: kPropertyTypeTime + 1; | |
| kPropertyTypeSD :: kPropertyTypeDevMode + 1; | |
| kPropertyTypeNotificationReply :: kPropertyTypeSD + 1; | |
| kPropertyTypeNotificationOptions :: kPropertyTypeNotificationReply + 1; | |
| kPropertyTypeBuffer :: kPropertyTypeNotificationOptions + 1; | |
| /* } */ | |
| ; | |
| /* EPrintXPSJobProgress :: enum { */ | |
| EPrintXPSJobProgress :: _c.int; | |
| kAddingDocumentSequence :: 0; | |
| kDocumentSequenceAdded :: 1; | |
| kAddingFixedDocument :: 2; | |
| kFixedDocumentAdded :: 3; | |
| kAddingFixedPage :: 4; | |
| kFixedPageAdded :: 5; | |
| kResourceAdded :: 6; | |
| kFontAdded :: 7; | |
| kImageAdded :: 8; | |
| kXpsDocumentCommitted :: 9; | |
| /* } */ | |
| ; | |
| /* EPrintXPSJobOperation :: enum { */ | |
| EPrintXPSJobOperation :: _c.int; | |
| kJobProduction :: 1; | |
| kJobConsumption :: kJobProduction + 1; | |
| /* } */ | |
| ; | |
| PrintPropertyValue :: struct { | |
| ePropertyType : EPrintPropertyType, | |
| value : struct #raw_union { | |
| propertyByte : BYTE, | |
| propertyString : PWSTR, | |
| propertyInt32 : LONG, | |
| propertyInt64 : LONGLONG, | |
| propertyBlob : struct { | |
| cbBuf : DWORD, | |
| pBuf : LPVOID, | |
| }, | |
| }, | |
| }; | |
| PrintNamedProperty :: struct { | |
| propertyName : ^WCHAR, | |
| propertyValue : PrintPropertyValue, | |
| }; | |
| PrintPropertiesCollection :: struct { | |
| numberOfProperties : ULONG, | |
| propertiesCollection : ^PrintNamedProperty, | |
| }; | |
| /* PRINT_EXECUTION_CONTEXT :: enum { */ | |
| PRINT_EXECUTION_CONTEXT :: _c.int; | |
| PRINT_EXECUTION_CONTEXT_APPLICATION :: 0; | |
| PRINT_EXECUTION_CONTEXT_SPOOLER_SERVICE :: 1; | |
| PRINT_EXECUTION_CONTEXT_SPOOLER_ISOLATION_HOST :: 2; | |
| PRINT_EXECUTION_CONTEXT_FILTER_PIPELINE :: 3; | |
| PRINT_EXECUTION_CONTEXT_WOW64 :: 4; | |
| /* } */ | |
| ; | |
| PRINT_EXECUTION_DATA :: struct { | |
| context_ : PRINT_EXECUTION_CONTEXT, | |
| clientAppPID : DWORD, | |
| }; | |
| _CoreCrtSecureSearchSortCompareFunction :: (proc(rawptr, rawptr, rawptr) -> _c.int); | |
| _CoreCrtNonSecureSearchSortCompareFunction :: (proc(rawptr, rawptr) -> _c.int); | |
| _onexit_t :: (proc() -> _c.int); | |
| _purecall_handler :: proc(); | |
| _invalid_parameter_handler :: proc(^_c.wchar_t, ^_c.wchar_t, ^_c.wchar_t, _c.uint, _c.uintptr_t); | |
| div_t :: struct { | |
| quot : _c.int, | |
| rem : _c.int, | |
| }; | |
| ldiv_t :: struct { | |
| quot : _c.long, | |
| rem : _c.long, | |
| }; | |
| lldiv_t :: struct { | |
| quot : _c.longlong, | |
| rem : _c.longlong, | |
| }; | |
| _LDOUBLE :: struct { | |
| ld : [10]_c.uchar, | |
| }; | |
| _CRT_DOUBLE :: struct { | |
| x : _c.double, | |
| }; | |
| _CRT_FLOAT :: struct { | |
| f : _c.float, | |
| }; | |
| _LONGDOUBLE :: struct { | |
| x : _c.double, | |
| }; | |
| _LDBL12 :: struct { | |
| ld12 : [12]_c.uchar, | |
| }; | |
| /* REGCLS :: enum { */ | |
| REGCLS :: _c.int; | |
| REGCLS_SINGLEUSE :: 0; | |
| REGCLS_MULTIPLEUSE :: 1; | |
| REGCLS_MULTI_SEPARATE :: 2; | |
| REGCLS_SUSPENDED :: 4; | |
| REGCLS_SURROGATE :: 8; | |
| REGCLS_AGILE :: 0x10; | |
| /* } */ | |
| ; | |
| ; | |
| ; | |
| /* COINITBASE :: enum { */ | |
| COINITBASE :: _c.int; | |
| COINITBASE_MULTITHREADED :: 0x0; | |
| /* } */ | |
| ; | |
| ; | |
| ; | |
| ; | |
| LPUNKNOWN :: ^IUnknown; | |
| IUnknownVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IUnknown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IUnknown) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IUnknown) -> ULONG), | |
| }; | |
| IUnknown :: struct { | |
| lpVtbl : ^IUnknownVtbl, | |
| }; | |
| AsyncIUnknownVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^AsyncIUnknown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^AsyncIUnknown) -> ULONG), | |
| Release : (proc "stdcall" (This : ^AsyncIUnknown) -> ULONG), | |
| Begin_QueryInterface : (proc "stdcall" (This : ^AsyncIUnknown, riid : ^IID) -> HRESULT), | |
| Finish_QueryInterface : (proc "stdcall" (This : ^AsyncIUnknown, ppvObject : ^rawptr) -> HRESULT), | |
| Begin_AddRef : (proc "stdcall" (This : ^AsyncIUnknown) -> HRESULT), | |
| Finish_AddRef : (proc "stdcall" (This : ^AsyncIUnknown) -> ULONG), | |
| Begin_Release : (proc "stdcall" (This : ^AsyncIUnknown) -> HRESULT), | |
| Finish_Release : (proc "stdcall" (This : ^AsyncIUnknown) -> ULONG), | |
| }; | |
| AsyncIUnknown :: struct { | |
| lpVtbl : ^AsyncIUnknownVtbl, | |
| }; | |
| LPCLASSFACTORY :: ^IClassFactory; | |
| IClassFactoryVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IClassFactory, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IClassFactory) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IClassFactory) -> ULONG), | |
| CreateInstance : (proc "stdcall" (This : ^IClassFactory, pUnkOuter : ^IUnknown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| LockServer : (proc "stdcall" (This : ^IClassFactory, fLock : BOOL) -> HRESULT), | |
| }; | |
| IClassFactory :: struct { | |
| lpVtbl : ^IClassFactoryVtbl, | |
| }; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| IEnumContextProps :: struct {}; | |
| IContext :: struct {}; | |
| IObjContext :: struct {}; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| COSERVERINFO :: struct { | |
| dwReserved1 : DWORD, | |
| pwszName : LPWSTR, | |
| pAuthInfo : ^COAUTHINFO, | |
| dwReserved2 : DWORD, | |
| }; | |
| LPMARSHAL :: ^IMarshal; | |
| IMarshalVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IMarshal, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IMarshal) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IMarshal) -> ULONG), | |
| GetUnmarshalClass : (proc "stdcall" (This : ^IMarshal, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD, pCid : ^CLSID) -> HRESULT), | |
| GetMarshalSizeMax : (proc "stdcall" (This : ^IMarshal, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD, pSize : ^DWORD) -> HRESULT), | |
| MarshalInterface : (proc "stdcall" (This : ^IMarshal, pStm : ^IStream, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD) -> HRESULT), | |
| UnmarshalInterface : (proc "stdcall" (This : ^IMarshal, pStm : ^IStream, riid : ^IID, ppv : ^rawptr) -> HRESULT), | |
| ReleaseMarshalData : (proc "stdcall" (This : ^IMarshal, pStm : ^IStream) -> HRESULT), | |
| DisconnectObject : (proc "stdcall" (This : ^IMarshal, dwReserved : DWORD) -> HRESULT), | |
| }; | |
| IMarshal :: struct { | |
| lpVtbl : ^IMarshalVtbl, | |
| }; | |
| INoMarshalVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^INoMarshal, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^INoMarshal) -> ULONG), | |
| Release : (proc "stdcall" (This : ^INoMarshal) -> ULONG), | |
| }; | |
| INoMarshal :: struct { | |
| lpVtbl : ^INoMarshalVtbl, | |
| }; | |
| IAgileObjectVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IAgileObject, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IAgileObject) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IAgileObject) -> ULONG), | |
| }; | |
| IAgileObject :: struct { | |
| lpVtbl : ^IAgileObjectVtbl, | |
| }; | |
| /* ACTIVATIONTYPE :: enum { */ | |
| ACTIVATIONTYPE :: _c.int; | |
| ACTIVATIONTYPE_UNCATEGORIZED :: 0; | |
| ACTIVATIONTYPE_FROM_MONIKER :: 0x1; | |
| ACTIVATIONTYPE_FROM_DATA :: 0x2; | |
| ACTIVATIONTYPE_FROM_STORAGE :: 0x4; | |
| ACTIVATIONTYPE_FROM_STREAM :: 0x8; | |
| ACTIVATIONTYPE_FROM_FILE :: 0x10; | |
| /* } */ | |
| ; | |
| IActivationFilterVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IActivationFilter, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IActivationFilter) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IActivationFilter) -> ULONG), | |
| HandleActivation : (proc "stdcall" (This : ^IActivationFilter, dwActivationType : DWORD, rclsid : ^IID, pReplacementClsId : ^CLSID) -> HRESULT), | |
| }; | |
| IActivationFilter :: struct { | |
| lpVtbl : ^IActivationFilterVtbl, | |
| }; | |
| LPMARSHAL2 :: ^IMarshal2; | |
| IMarshal2Vtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IMarshal2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IMarshal2) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IMarshal2) -> ULONG), | |
| GetUnmarshalClass : (proc "stdcall" (This : ^IMarshal2, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD, pCid : ^CLSID) -> HRESULT), | |
| GetMarshalSizeMax : (proc "stdcall" (This : ^IMarshal2, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD, pSize : ^DWORD) -> HRESULT), | |
| MarshalInterface : (proc "stdcall" (This : ^IMarshal2, pStm : ^IStream, riid : ^IID, pv : rawptr, dwDestContext : DWORD, pvDestContext : rawptr, mshlflags : DWORD) -> HRESULT), | |
| UnmarshalInterface : (proc "stdcall" (This : ^IMarshal2, pStm : ^IStream, riid : ^IID, ppv : ^rawptr) -> HRESULT), | |
| ReleaseMarshalData : (proc "stdcall" (This : ^IMarshal2, pStm : ^IStream) -> HRESULT), | |
| DisconnectObject : (proc "stdcall" (This : ^IMarshal2, dwReserved : DWORD) -> HRESULT), | |
| }; | |
| IMarshal2 :: struct { | |
| lpVtbl : ^IMarshal2Vtbl, | |
| }; | |
| LPMALLOC :: ^IMalloc; | |
| IMallocVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IMalloc, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IMalloc) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IMalloc) -> ULONG), | |
| Alloc : (proc "stdcall" (This : ^IMalloc, cb : SIZE_T) -> rawptr), | |
| Realloc : (proc "stdcall" (This : ^IMalloc, pv : rawptr, cb : SIZE_T) -> rawptr), | |
| Free : proc "stdcall" (This : ^IMalloc, pv : rawptr), | |
| GetSize : (proc "stdcall" (This : ^IMalloc, pv : rawptr) -> SIZE_T), | |
| DidAlloc : (proc "stdcall" (This : ^IMalloc, pv : rawptr) -> _c.int), | |
| HeapMinimize : proc "stdcall" (This : ^IMalloc), | |
| }; | |
| IMalloc :: struct { | |
| lpVtbl : ^IMallocVtbl, | |
| }; | |
| LPSTDMARSHALINFO :: ^IStdMarshalInfo; | |
| IStdMarshalInfoVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IStdMarshalInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IStdMarshalInfo) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IStdMarshalInfo) -> ULONG), | |
| GetClassForHandler : (proc "stdcall" (This : ^IStdMarshalInfo, dwDestContext : DWORD, pvDestContext : rawptr, pClsid : ^CLSID) -> HRESULT), | |
| }; | |
| IStdMarshalInfo :: struct { | |
| lpVtbl : ^IStdMarshalInfoVtbl, | |
| }; | |
| LPEXTERNALCONNECTION :: ^IExternalConnection; | |
| /* EXTCONN :: enum { */ | |
| EXTCONN :: _c.int; | |
| EXTCONN_STRONG :: 0x1; | |
| EXTCONN_WEAK :: 0x2; | |
| EXTCONN_CALLABLE :: 0x4; | |
| /* } */ | |
| ; | |
| IExternalConnectionVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IExternalConnection, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IExternalConnection) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IExternalConnection) -> ULONG), | |
| AddConnection : (proc "stdcall" (This : ^IExternalConnection, extconn : DWORD, reserved : DWORD) -> DWORD), | |
| ReleaseConnection : (proc "stdcall" (This : ^IExternalConnection, extconn : DWORD, reserved : DWORD, fLastReleaseCloses : BOOL) -> DWORD), | |
| }; | |
| IExternalConnection :: struct { | |
| lpVtbl : ^IExternalConnectionVtbl, | |
| }; | |
| LPMULTIQI :: ^IMultiQI; | |
| MULTI_QI :: struct { | |
| pIID : ^IID, | |
| pItf : ^IUnknown, | |
| hr : HRESULT, | |
| }; | |
| IMultiQIVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IMultiQI, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IMultiQI) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IMultiQI) -> ULONG), | |
| QueryMultipleInterfaces : (proc "stdcall" (This : ^IMultiQI, cMQIs : ULONG, pMQIs : ^MULTI_QI) -> HRESULT), | |
| }; | |
| IMultiQI :: struct { | |
| lpVtbl : ^IMultiQIVtbl, | |
| }; | |
| AsyncIMultiQIVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^AsyncIMultiQI, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^AsyncIMultiQI) -> ULONG), | |
| Release : (proc "stdcall" (This : ^AsyncIMultiQI) -> ULONG), | |
| Begin_QueryMultipleInterfaces : (proc "stdcall" (This : ^AsyncIMultiQI, cMQIs : ULONG, pMQIs : ^MULTI_QI) -> HRESULT), | |
| Finish_QueryMultipleInterfaces : (proc "stdcall" (This : ^AsyncIMultiQI, pMQIs : ^MULTI_QI) -> HRESULT), | |
| }; | |
| AsyncIMultiQI :: struct { | |
| lpVtbl : ^AsyncIMultiQIVtbl, | |
| }; | |
| IInternalUnknownVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IInternalUnknown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IInternalUnknown) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IInternalUnknown) -> ULONG), | |
| QueryInternalInterface : (proc "stdcall" (This : ^IInternalUnknown, riid : ^IID, ppv : ^rawptr) -> HRESULT), | |
| }; | |
| IInternalUnknown :: struct { | |
| lpVtbl : ^IInternalUnknownVtbl, | |
| }; | |
| LPENUMUNKNOWN :: ^IEnumUnknown; | |
| IEnumUnknownVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IEnumUnknown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IEnumUnknown) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IEnumUnknown) -> ULONG), | |
| Next : (proc "stdcall" (This : ^IEnumUnknown, celt : ULONG, rgelt : ^^IUnknown, pceltFetched : ^ULONG) -> HRESULT), | |
| Skip : (proc "stdcall" (This : ^IEnumUnknown, celt : ULONG) -> HRESULT), | |
| Reset : (proc "stdcall" (This : ^IEnumUnknown) -> HRESULT), | |
| Clone : (proc "stdcall" (This : ^IEnumUnknown, ppenum : ^^IEnumUnknown) -> HRESULT), | |
| }; | |
| IEnumUnknown :: struct { | |
| lpVtbl : ^IEnumUnknownVtbl, | |
| }; | |
| LPENUMSTRING :: ^IEnumString; | |
| IEnumStringVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IEnumString, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IEnumString) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IEnumString) -> ULONG), | |
| Next : (proc "stdcall" (This : ^IEnumString, celt : ULONG, rgelt : ^LPOLESTR, pceltFetched : ^ULONG) -> HRESULT), | |
| Skip : (proc "stdcall" (This : ^IEnumString, celt : ULONG) -> HRESULT), | |
| Reset : (proc "stdcall" (This : ^IEnumString) -> HRESULT), | |
| Clone : (proc "stdcall" (This : ^IEnumString, ppenum : ^^IEnumString) -> HRESULT), | |
| }; | |
| IEnumString :: struct { | |
| lpVtbl : ^IEnumStringVtbl, | |
| }; | |
| ISequentialStreamVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ISequentialStream, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ISequentialStream) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ISequentialStream) -> ULONG), | |
| Read : (proc "stdcall" (This : ^ISequentialStream, pv : rawptr, cb : ULONG, pcbRead : ^ULONG) -> HRESULT), | |
| Write : (proc "stdcall" (This : ^ISequentialStream, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT), | |
| }; | |
| ISequentialStream :: struct { | |
| lpVtbl : ^ISequentialStreamVtbl, | |
| }; | |
| LPSTREAM :: ^IStream; | |
| STATSTG :: struct { | |
| pwcsName : LPOLESTR, | |
| type : DWORD, | |
| cbSize : ULARGE_INTEGER, | |
| mtime : FILETIME, | |
| ctime : FILETIME, | |
| atime : FILETIME, | |
| grfMode : DWORD, | |
| grfLocksSupported : DWORD, | |
| clsid : CLSID, | |
| grfStateBits : DWORD, | |
| reserved : DWORD, | |
| }; | |
| /* STGTY :: enum { */ | |
| STGTY :: _c.int; | |
| STGTY_STORAGE :: 1; | |
| STGTY_STREAM :: 2; | |
| STGTY_LOCKBYTES :: 3; | |
| STGTY_PROPERTY :: 4; | |
| /* } */ | |
| ; | |
| /* STREAM_SEEK :: enum { */ | |
| STREAM_SEEK :: _c.int; | |
| STREAM_SEEK_SET :: 0; | |
| STREAM_SEEK_CUR :: 1; | |
| STREAM_SEEK_END :: 2; | |
| /* } */ | |
| ; | |
| /* LOCKTYPE :: enum { */ | |
| LOCKTYPE :: _c.int; | |
| LOCK_WRITE :: 1; | |
| LOCK_EXCLUSIVE :: 2; | |
| LOCK_ONLYONCE :: 4; | |
| /* } */ | |
| ; | |
| IStreamVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IStream, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IStream) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IStream) -> ULONG), | |
| Read : (proc "stdcall" (This : ^IStream, pv : rawptr, cb : ULONG, pcbRead : ^ULONG) -> HRESULT), | |
| Write : (proc "stdcall" (This : ^IStream, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT), | |
| Seek : (proc "stdcall" (This : ^IStream, dlibMove : LARGE_INTEGER, dwOrigin : DWORD, plibNewPosition : ^ULARGE_INTEGER) -> HRESULT), | |
| SetSize : (proc "stdcall" (This : ^IStream, libNewSize : ULARGE_INTEGER) -> HRESULT), | |
| CopyTo : (proc "stdcall" (This : ^IStream, pstm : ^IStream, cb : ULARGE_INTEGER, pcbRead : ^ULARGE_INTEGER, pcbWritten : ^ULARGE_INTEGER) -> HRESULT), | |
| Commit : (proc "stdcall" (This : ^IStream, grfCommitFlags : DWORD) -> HRESULT), | |
| Revert : (proc "stdcall" (This : ^IStream) -> HRESULT), | |
| LockRegion : (proc "stdcall" (This : ^IStream, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT), | |
| UnlockRegion : (proc "stdcall" (This : ^IStream, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT), | |
| Stat : (proc "stdcall" (This : ^IStream, pstatstg : ^STATSTG, grfStatFlag : DWORD) -> HRESULT), | |
| Clone : (proc "stdcall" (This : ^IStream, ppstm : ^^IStream) -> HRESULT), | |
| }; | |
| IStream :: struct { | |
| lpVtbl : ^IStreamVtbl, | |
| }; | |
| RPCOLEDATAREP :: ULONG; | |
| RPCOLEMESSAGE :: struct { | |
| reserved1 : rawptr, | |
| dataRepresentation : RPCOLEDATAREP, | |
| Buffer : rawptr, | |
| cbBuffer : ULONG, | |
| iMethod : ULONG, | |
| reserved2 : [5]rawptr, | |
| rpcFlags : ULONG, | |
| }; | |
| PRPCOLEMESSAGE :: ^RPCOLEMESSAGE; | |
| IRpcChannelBufferVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRpcChannelBuffer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRpcChannelBuffer) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRpcChannelBuffer) -> ULONG), | |
| GetBuffer : (proc "stdcall" (This : ^IRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE, riid : ^IID) -> HRESULT), | |
| SendReceive : (proc "stdcall" (This : ^IRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE, pStatus : ^ULONG) -> HRESULT), | |
| FreeBuffer : (proc "stdcall" (This : ^IRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE) -> HRESULT), | |
| GetDestCtx : (proc "stdcall" (This : ^IRpcChannelBuffer, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT), | |
| IsConnected : (proc "stdcall" (This : ^IRpcChannelBuffer) -> HRESULT), | |
| }; | |
| IRpcChannelBuffer :: struct { | |
| lpVtbl : ^IRpcChannelBufferVtbl, | |
| }; | |
| IRpcChannelBuffer2Vtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRpcChannelBuffer2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRpcChannelBuffer2) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRpcChannelBuffer2) -> ULONG), | |
| GetBuffer : (proc "stdcall" (This : ^IRpcChannelBuffer2, pMessage : ^RPCOLEMESSAGE, riid : ^IID) -> HRESULT), | |
| SendReceive : (proc "stdcall" (This : ^IRpcChannelBuffer2, pMessage : ^RPCOLEMESSAGE, pStatus : ^ULONG) -> HRESULT), | |
| FreeBuffer : (proc "stdcall" (This : ^IRpcChannelBuffer2, pMessage : ^RPCOLEMESSAGE) -> HRESULT), | |
| GetDestCtx : (proc "stdcall" (This : ^IRpcChannelBuffer2, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT), | |
| IsConnected : (proc "stdcall" (This : ^IRpcChannelBuffer2) -> HRESULT), | |
| GetProtocolVersion : (proc "stdcall" (This : ^IRpcChannelBuffer2, pdwVersion : ^DWORD) -> HRESULT), | |
| }; | |
| IRpcChannelBuffer2 :: struct { | |
| lpVtbl : ^IRpcChannelBuffer2Vtbl, | |
| }; | |
| IAsyncRpcChannelBufferVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer) -> ULONG), | |
| GetBuffer : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE, riid : ^IID) -> HRESULT), | |
| SendReceive : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE, pStatus : ^ULONG) -> HRESULT), | |
| FreeBuffer : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMessage : ^RPCOLEMESSAGE) -> HRESULT), | |
| GetDestCtx : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT), | |
| IsConnected : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer) -> HRESULT), | |
| GetProtocolVersion : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pdwVersion : ^DWORD) -> HRESULT), | |
| Send : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMsg : ^RPCOLEMESSAGE, pSync : ^ISynchronize, pulStatus : ^ULONG) -> HRESULT), | |
| Receive : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMsg : ^RPCOLEMESSAGE, pulStatus : ^ULONG) -> HRESULT), | |
| GetDestCtxEx : (proc "stdcall" (This : ^IAsyncRpcChannelBuffer, pMsg : ^RPCOLEMESSAGE, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT), | |
| }; | |
| IAsyncRpcChannelBuffer :: struct { | |
| lpVtbl : ^IAsyncRpcChannelBufferVtbl, | |
| }; | |
| IRpcChannelBuffer3Vtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRpcChannelBuffer3, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRpcChannelBuffer3) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRpcChannelBuffer3) -> ULONG), | |
| GetBuffer : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMessage : ^RPCOLEMESSAGE, riid : ^IID) -> HRESULT), | |
| SendReceive : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMessage : ^RPCOLEMESSAGE, pStatus : ^ULONG) -> HRESULT), | |
| FreeBuffer : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMessage : ^RPCOLEMESSAGE) -> HRESULT), | |
| GetDestCtx : (proc "stdcall" (This : ^IRpcChannelBuffer3, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT), | |
| IsConnected : (proc "stdcall" (This : ^IRpcChannelBuffer3) -> HRESULT), | |
| GetProtocolVersion : (proc "stdcall" (This : ^IRpcChannelBuffer3, pdwVersion : ^DWORD) -> HRESULT), | |
| Send : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, pulStatus : ^ULONG) -> HRESULT), | |
| Receive : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, ulSize : ULONG, pulStatus : ^ULONG) -> HRESULT), | |
| Cancel : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE) -> HRESULT), | |
| GetCallContext : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, riid : ^IID, pInterface : ^rawptr) -> HRESULT), | |
| GetDestCtxEx : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, pdwDestContext : ^DWORD, ppvDestContext : ^rawptr) -> HRESULT), | |
| GetState : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, pState : ^DWORD) -> HRESULT), | |
| RegisterAsync : (proc "stdcall" (This : ^IRpcChannelBuffer3, pMsg : ^RPCOLEMESSAGE, pAsyncMgr : ^IAsyncManager) -> HRESULT), | |
| }; | |
| IRpcChannelBuffer3 :: struct { | |
| lpVtbl : ^IRpcChannelBuffer3Vtbl, | |
| }; | |
| IRpcSyntaxNegotiateVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRpcSyntaxNegotiate, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRpcSyntaxNegotiate) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRpcSyntaxNegotiate) -> ULONG), | |
| NegotiateSyntax : (proc "stdcall" (This : ^IRpcSyntaxNegotiate, pMsg : ^RPCOLEMESSAGE) -> HRESULT), | |
| }; | |
| IRpcSyntaxNegotiate :: struct { | |
| lpVtbl : ^IRpcSyntaxNegotiateVtbl, | |
| }; | |
| IRpcProxyBufferVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRpcProxyBuffer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRpcProxyBuffer) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRpcProxyBuffer) -> ULONG), | |
| Connect : (proc "stdcall" (This : ^IRpcProxyBuffer, pRpcChannelBuffer : ^IRpcChannelBuffer) -> HRESULT), | |
| Disconnect : proc "stdcall" (This : ^IRpcProxyBuffer), | |
| }; | |
| IRpcProxyBuffer :: struct { | |
| lpVtbl : ^IRpcProxyBufferVtbl, | |
| }; | |
| IRpcStubBufferVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRpcStubBuffer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRpcStubBuffer) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRpcStubBuffer) -> ULONG), | |
| Connect : (proc "stdcall" (This : ^IRpcStubBuffer, pUnkServer : ^IUnknown) -> HRESULT), | |
| Disconnect : proc "stdcall" (This : ^IRpcStubBuffer), | |
| Invoke : (proc "stdcall" (This : ^IRpcStubBuffer, _prpcmsg : ^RPCOLEMESSAGE, _pRpcChannelBuffer : ^IRpcChannelBuffer) -> HRESULT), | |
| IsIIDSupported : (proc "stdcall" (This : ^IRpcStubBuffer, riid : ^IID) -> ^IRpcStubBuffer), | |
| CountRefs : (proc "stdcall" (This : ^IRpcStubBuffer) -> ULONG), | |
| DebugServerQueryInterface : (proc "stdcall" (This : ^IRpcStubBuffer, ppv : ^rawptr) -> HRESULT), | |
| DebugServerRelease : proc "stdcall" (This : ^IRpcStubBuffer, pv : rawptr), | |
| }; | |
| IRpcStubBuffer :: struct { | |
| lpVtbl : ^IRpcStubBufferVtbl, | |
| }; | |
| IPSFactoryBufferVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IPSFactoryBuffer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IPSFactoryBuffer) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IPSFactoryBuffer) -> ULONG), | |
| CreateProxy : (proc "stdcall" (This : ^IPSFactoryBuffer, pUnkOuter : ^IUnknown, riid : ^IID, ppProxy : ^^IRpcProxyBuffer, ppv : ^rawptr) -> HRESULT), | |
| CreateStub : (proc "stdcall" (This : ^IPSFactoryBuffer, riid : ^IID, pUnkServer : ^IUnknown, ppStub : ^^IRpcStubBuffer) -> HRESULT), | |
| }; | |
| IPSFactoryBuffer :: struct { | |
| lpVtbl : ^IPSFactoryBufferVtbl, | |
| }; | |
| SChannelHookCallInfo :: struct { | |
| iid : IID, | |
| cbSize : DWORD, | |
| uCausality : GUID, | |
| dwServerPid : DWORD, | |
| iMethod : DWORD, | |
| pObject : rawptr, | |
| }; | |
| IChannelHookVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IChannelHook, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IChannelHook) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IChannelHook) -> ULONG), | |
| ClientGetSize : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, pDataSize : ^ULONG), | |
| ClientFillBuffer : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, pDataSize : ^ULONG, pDataBuffer : rawptr), | |
| ClientNotify : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, cbDataSize : ULONG, pDataBuffer : rawptr, lDataRep : DWORD, hrFault : HRESULT), | |
| ServerNotify : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, cbDataSize : ULONG, pDataBuffer : rawptr, lDataRep : DWORD), | |
| ServerGetSize : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, hrFault : HRESULT, pDataSize : ^ULONG), | |
| ServerFillBuffer : proc "stdcall" (This : ^IChannelHook, uExtent : ^GUID, riid : ^IID, pDataSize : ^ULONG, pDataBuffer : rawptr, hrFault : HRESULT), | |
| }; | |
| IChannelHook :: struct { | |
| lpVtbl : ^IChannelHookVtbl, | |
| }; | |
| SOLE_AUTHENTICATION_SERVICE :: struct { | |
| dwAuthnSvc : DWORD, | |
| dwAuthzSvc : DWORD, | |
| pPrincipalName : ^OLECHAR, | |
| hr : HRESULT, | |
| }; | |
| PSOLE_AUTHENTICATION_SERVICE :: ^SOLE_AUTHENTICATION_SERVICE; | |
| /* EOLE_AUTHENTICATION_CAPABILITIES :: enum { */ | |
| EOLE_AUTHENTICATION_CAPABILITIES :: _c.int; | |
| EOAC_NONE :: 0; | |
| EOAC_MUTUAL_AUTH :: 0x1; | |
| EOAC_STATIC_CLOAKING :: 0x20; | |
| EOAC_DYNAMIC_CLOAKING :: 0x40; | |
| EOAC_ANY_AUTHORITY :: 0x80; | |
| EOAC_MAKE_FULLSIC :: 0x100; | |
| EOAC_DEFAULT :: 0x800; | |
| EOAC_SECURE_REFS :: 0x2; | |
| EOAC_ACCESS_CONTROL :: 0x4; | |
| EOAC_APPID :: 0x8; | |
| EOAC_DYNAMIC :: 0x10; | |
| EOAC_REQUIRE_FULLSIC :: 0x200; | |
| EOAC_AUTO_IMPERSONATE :: 0x400; | |
| EOAC_DISABLE_AAA :: 0x1000; | |
| EOAC_NO_CUSTOM_MARSHAL :: 0x2000; | |
| EOAC_RESERVED1 :: 0x4000; | |
| /* } */ | |
| ; | |
| SOLE_AUTHENTICATION_INFO :: struct { | |
| dwAuthnSvc : DWORD, | |
| dwAuthzSvc : DWORD, | |
| pAuthInfo : rawptr, | |
| }; | |
| PSOLE_AUTHENTICATION_INFO :: ^SOLE_AUTHENTICATION_INFO; | |
| SOLE_AUTHENTICATION_LIST :: struct { | |
| cAuthInfo : DWORD, | |
| aAuthInfo : ^SOLE_AUTHENTICATION_INFO, | |
| }; | |
| PSOLE_AUTHENTICATION_LIST :: ^SOLE_AUTHENTICATION_LIST; | |
| IClientSecurityVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IClientSecurity, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IClientSecurity) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IClientSecurity) -> ULONG), | |
| QueryBlanket : (proc "stdcall" (This : ^IClientSecurity, pProxy : ^IUnknown, pAuthnSvc : ^DWORD, pAuthzSvc : ^DWORD, pServerPrincName : ^^OLECHAR, pAuthnLevel : ^DWORD, pImpLevel : ^DWORD, pAuthInfo : ^rawptr, pCapabilites : ^DWORD) -> HRESULT), | |
| SetBlanket : (proc "stdcall" (This : ^IClientSecurity, pProxy : ^IUnknown, dwAuthnSvc : DWORD, dwAuthzSvc : DWORD, pServerPrincName : ^OLECHAR, dwAuthnLevel : DWORD, dwImpLevel : DWORD, pAuthInfo : rawptr, dwCapabilities : DWORD) -> HRESULT), | |
| CopyProxy : (proc "stdcall" (This : ^IClientSecurity, pProxy : ^IUnknown, ppCopy : ^^IUnknown) -> HRESULT), | |
| }; | |
| IClientSecurity :: struct { | |
| lpVtbl : ^IClientSecurityVtbl, | |
| }; | |
| IServerSecurityVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IServerSecurity, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IServerSecurity) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IServerSecurity) -> ULONG), | |
| QueryBlanket : (proc "stdcall" (This : ^IServerSecurity, pAuthnSvc : ^DWORD, pAuthzSvc : ^DWORD, pServerPrincName : ^^OLECHAR, pAuthnLevel : ^DWORD, pImpLevel : ^DWORD, pPrivs : ^rawptr, pCapabilities : ^DWORD) -> HRESULT), | |
| ImpersonateClient : (proc "stdcall" (This : ^IServerSecurity) -> HRESULT), | |
| RevertToSelf : (proc "stdcall" (This : ^IServerSecurity) -> HRESULT), | |
| IsImpersonating : (proc "stdcall" (This : ^IServerSecurity) -> BOOL), | |
| }; | |
| IServerSecurity :: struct { | |
| lpVtbl : ^IServerSecurityVtbl, | |
| }; | |
| /* RPCOPT_PROPERTIES :: enum { */ | |
| RPCOPT_PROPERTIES :: _c.int; | |
| COMBND_RPCTIMEOUT :: 0x1; | |
| COMBND_SERVER_LOCALITY :: 0x2; | |
| COMBND_RESERVED1 :: 0x4; | |
| COMBND_RESERVED2 :: 0x5; | |
| COMBND_RESERVED3 :: 0x8; | |
| COMBND_RESERVED4 :: 0x10; | |
| /* } */ | |
| ; | |
| /* RPCOPT_SERVER_LOCALITY_VALUES :: enum { */ | |
| RPCOPT_SERVER_LOCALITY_VALUES :: _c.int; | |
| SERVER_LOCALITY_PROCESS_LOCAL :: 0; | |
| SERVER_LOCALITY_MACHINE_LOCAL :: 1; | |
| SERVER_LOCALITY_REMOTE :: 2; | |
| /* } */ | |
| ; | |
| IRpcOptionsVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRpcOptions, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRpcOptions) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRpcOptions) -> ULONG), | |
| Set : (proc "stdcall" (This : ^IRpcOptions, pPrx : ^IUnknown, dwProperty : RPCOPT_PROPERTIES, dwValue : ULONG_PTR) -> HRESULT), | |
| Query : (proc "stdcall" (This : ^IRpcOptions, pPrx : ^IUnknown, dwProperty : RPCOPT_PROPERTIES, pdwValue : ^ULONG_PTR) -> HRESULT), | |
| }; | |
| IRpcOptions :: struct { | |
| lpVtbl : ^IRpcOptionsVtbl, | |
| }; | |
| /* GLOBALOPT_PROPERTIES :: enum { */ | |
| GLOBALOPT_PROPERTIES :: _c.int; | |
| COMGLB_EXCEPTION_HANDLING :: 1; | |
| COMGLB_APPID :: 2; | |
| COMGLB_RPC_THREADPOOL_SETTING :: 3; | |
| COMGLB_RO_SETTINGS :: 4; | |
| COMGLB_UNMARSHALING_POLICY :: 5; | |
| COMGLB_PROPERTIES_RESERVED1 :: 6; | |
| COMGLB_PROPERTIES_RESERVED2 :: 7; | |
| COMGLB_PROPERTIES_RESERVED3 :: 8; | |
| /* } */ | |
| ; | |
| /* GLOBALOPT_EH_VALUES :: enum { */ | |
| GLOBALOPT_EH_VALUES :: _c.int; | |
| COMGLB_EXCEPTION_HANDLE :: 0; | |
| COMGLB_EXCEPTION_DONOT_HANDLE_FATAL :: 1; | |
| COMGLB_EXCEPTION_DONOT_HANDLE :: COMGLB_EXCEPTION_DONOT_HANDLE_FATAL; | |
| COMGLB_EXCEPTION_DONOT_HANDLE_ANY :: 2; | |
| /* } */ | |
| ; | |
| /* GLOBALOPT_RPCTP_VALUES :: enum { */ | |
| GLOBALOPT_RPCTP_VALUES :: _c.int; | |
| COMGLB_RPC_THREADPOOL_SETTING_DEFAULT_POOL :: 0; | |
| COMGLB_RPC_THREADPOOL_SETTING_PRIVATE_POOL :: 1; | |
| /* } */ | |
| ; | |
| /* GLOBALOPT_RO_FLAGS :: enum { */ | |
| GLOBALOPT_RO_FLAGS :: _c.int; | |
| COMGLB_STA_MODALLOOP_REMOVE_TOUCH_MESSAGES :: 0x1; | |
| COMGLB_STA_MODALLOOP_SHARED_QUEUE_REMOVE_INPUT_MESSAGES :: 0x2; | |
| COMGLB_STA_MODALLOOP_SHARED_QUEUE_DONOT_REMOVE_INPUT_MESSAGES :: 0x4; | |
| COMGLB_FAST_RUNDOWN :: 0x8; | |
| COMGLB_RESERVED1 :: 0x10; | |
| COMGLB_RESERVED2 :: 0x20; | |
| COMGLB_RESERVED3 :: 0x40; | |
| COMGLB_STA_MODALLOOP_SHARED_QUEUE_REORDER_POINTER_MESSAGES :: 0x80; | |
| COMGLB_RESERVED4 :: 0x100; | |
| COMGLB_RESERVED5 :: 0x200; | |
| COMGLB_RESERVED6 :: 0x400; | |
| /* } */ | |
| ; | |
| /* GLOBALOPT_UNMARSHALING_POLICY_VALUES :: enum { */ | |
| GLOBALOPT_UNMARSHALING_POLICY_VALUES :: _c.int; | |
| COMGLB_UNMARSHALING_POLICY_NORMAL :: 0; | |
| COMGLB_UNMARSHALING_POLICY_STRONG :: 1; | |
| COMGLB_UNMARSHALING_POLICY_HYBRID :: 2; | |
| /* } */ | |
| ; | |
| IGlobalOptionsVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IGlobalOptions, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IGlobalOptions) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IGlobalOptions) -> ULONG), | |
| Set : (proc "stdcall" (This : ^IGlobalOptions, dwProperty : GLOBALOPT_PROPERTIES, dwValue : ULONG_PTR) -> HRESULT), | |
| Query : (proc "stdcall" (This : ^IGlobalOptions, dwProperty : GLOBALOPT_PROPERTIES, pdwValue : ^ULONG_PTR) -> HRESULT), | |
| }; | |
| IGlobalOptions :: struct { | |
| lpVtbl : ^IGlobalOptionsVtbl, | |
| }; | |
| LPSURROGATE :: ^ISurrogate; | |
| ISurrogateVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ISurrogate, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ISurrogate) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ISurrogate) -> ULONG), | |
| LoadDllServer : (proc "stdcall" (This : ^ISurrogate, Clsid : ^IID) -> HRESULT), | |
| FreeSurrogate : (proc "stdcall" (This : ^ISurrogate) -> HRESULT), | |
| }; | |
| ISurrogate :: struct { | |
| lpVtbl : ^ISurrogateVtbl, | |
| }; | |
| LPGLOBALINTERFACETABLE :: ^IGlobalInterfaceTable; | |
| IGlobalInterfaceTableVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IGlobalInterfaceTable, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IGlobalInterfaceTable) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IGlobalInterfaceTable) -> ULONG), | |
| RegisterInterfaceInGlobal : (proc "stdcall" (This : ^IGlobalInterfaceTable, pUnk : ^IUnknown, riid : ^IID, pdwCookie : ^DWORD) -> HRESULT), | |
| RevokeInterfaceFromGlobal : (proc "stdcall" (This : ^IGlobalInterfaceTable, dwCookie : DWORD) -> HRESULT), | |
| GetInterfaceFromGlobal : (proc "stdcall" (This : ^IGlobalInterfaceTable, dwCookie : DWORD, riid : ^IID, ppv : ^rawptr) -> HRESULT), | |
| }; | |
| IGlobalInterfaceTable :: struct { | |
| lpVtbl : ^IGlobalInterfaceTableVtbl, | |
| }; | |
| ISynchronizeVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ISynchronize, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ISynchronize) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ISynchronize) -> ULONG), | |
| Wait : (proc "stdcall" (This : ^ISynchronize, dwFlags : DWORD, dwMilliseconds : DWORD) -> HRESULT), | |
| Signal : (proc "stdcall" (This : ^ISynchronize) -> HRESULT), | |
| Reset : (proc "stdcall" (This : ^ISynchronize) -> HRESULT), | |
| }; | |
| ISynchronize :: struct { | |
| lpVtbl : ^ISynchronizeVtbl, | |
| }; | |
| ISynchronizeHandleVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ISynchronizeHandle, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ISynchronizeHandle) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ISynchronizeHandle) -> ULONG), | |
| GetHandle : (proc "stdcall" (This : ^ISynchronizeHandle, ph : ^HANDLE) -> HRESULT), | |
| }; | |
| ISynchronizeHandle :: struct { | |
| lpVtbl : ^ISynchronizeHandleVtbl, | |
| }; | |
| ISynchronizeEventVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ISynchronizeEvent, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ISynchronizeEvent) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ISynchronizeEvent) -> ULONG), | |
| GetHandle : (proc "stdcall" (This : ^ISynchronizeEvent, ph : ^HANDLE) -> HRESULT), | |
| SetEventHandle : (proc "stdcall" (This : ^ISynchronizeEvent, ph : ^HANDLE) -> HRESULT), | |
| }; | |
| ISynchronizeEvent :: struct { | |
| lpVtbl : ^ISynchronizeEventVtbl, | |
| }; | |
| ISynchronizeContainerVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ISynchronizeContainer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ISynchronizeContainer) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ISynchronizeContainer) -> ULONG), | |
| AddSynchronize : (proc "stdcall" (This : ^ISynchronizeContainer, pSync : ^ISynchronize) -> HRESULT), | |
| WaitMultiple : (proc "stdcall" (This : ^ISynchronizeContainer, dwFlags : DWORD, dwTimeOut : DWORD, ppSync : ^^ISynchronize) -> HRESULT), | |
| }; | |
| ISynchronizeContainer :: struct { | |
| lpVtbl : ^ISynchronizeContainerVtbl, | |
| }; | |
| ISynchronizeMutexVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ISynchronizeMutex, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ISynchronizeMutex) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ISynchronizeMutex) -> ULONG), | |
| Wait : (proc "stdcall" (This : ^ISynchronizeMutex, dwFlags : DWORD, dwMilliseconds : DWORD) -> HRESULT), | |
| Signal : (proc "stdcall" (This : ^ISynchronizeMutex) -> HRESULT), | |
| Reset : (proc "stdcall" (This : ^ISynchronizeMutex) -> HRESULT), | |
| ReleaseMutex : (proc "stdcall" (This : ^ISynchronizeMutex) -> HRESULT), | |
| }; | |
| ISynchronizeMutex :: struct { | |
| lpVtbl : ^ISynchronizeMutexVtbl, | |
| }; | |
| LPCANCELMETHODCALLS :: ^ICancelMethodCalls; | |
| ICancelMethodCallsVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ICancelMethodCalls, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ICancelMethodCalls) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ICancelMethodCalls) -> ULONG), | |
| Cancel : (proc "stdcall" (This : ^ICancelMethodCalls, ulSeconds : ULONG) -> HRESULT), | |
| TestCancel : (proc "stdcall" (This : ^ICancelMethodCalls) -> HRESULT), | |
| }; | |
| ICancelMethodCalls :: struct { | |
| lpVtbl : ^ICancelMethodCallsVtbl, | |
| }; | |
| /* DCOM_CALL_STATE :: enum { */ | |
| DCOM_CALL_STATE :: _c.int; | |
| DCOM_NONE :: 0; | |
| DCOM_CALL_COMPLETE :: 0x1; | |
| DCOM_CALL_CANCELED :: 0x2; | |
| /* } */ | |
| ; | |
| IAsyncManagerVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IAsyncManager, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IAsyncManager) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IAsyncManager) -> ULONG), | |
| CompleteCall : (proc "stdcall" (This : ^IAsyncManager, Result : HRESULT) -> HRESULT), | |
| GetCallContext : (proc "stdcall" (This : ^IAsyncManager, riid : ^IID, pInterface : ^rawptr) -> HRESULT), | |
| GetState : (proc "stdcall" (This : ^IAsyncManager, pulStateFlags : ^ULONG) -> HRESULT), | |
| }; | |
| IAsyncManager :: struct { | |
| lpVtbl : ^IAsyncManagerVtbl, | |
| }; | |
| ICallFactoryVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ICallFactory, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ICallFactory) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ICallFactory) -> ULONG), | |
| CreateCall : (proc "stdcall" (This : ^ICallFactory, riid : ^IID, pCtrlUnk : ^IUnknown, riid2 : ^IID, ppv : ^^IUnknown) -> HRESULT), | |
| }; | |
| ICallFactory :: struct { | |
| lpVtbl : ^ICallFactoryVtbl, | |
| }; | |
| IRpcHelperVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRpcHelper, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRpcHelper) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRpcHelper) -> ULONG), | |
| GetDCOMProtocolVersion : (proc "stdcall" (This : ^IRpcHelper, pComVersion : ^DWORD) -> HRESULT), | |
| GetIIDFromOBJREF : (proc "stdcall" (This : ^IRpcHelper, pObjRef : rawptr, piid : ^^IID) -> HRESULT), | |
| }; | |
| IRpcHelper :: struct { | |
| lpVtbl : ^IRpcHelperVtbl, | |
| }; | |
| IReleaseMarshalBuffersVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IReleaseMarshalBuffers, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IReleaseMarshalBuffers) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IReleaseMarshalBuffers) -> ULONG), | |
| ReleaseMarshalBuffer : (proc "stdcall" (This : ^IReleaseMarshalBuffers, pMsg : ^RPCOLEMESSAGE, dwFlags : DWORD, pChnl : ^IUnknown) -> HRESULT), | |
| }; | |
| IReleaseMarshalBuffers :: struct { | |
| lpVtbl : ^IReleaseMarshalBuffersVtbl, | |
| }; | |
| IWaitMultipleVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IWaitMultiple, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IWaitMultiple) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IWaitMultiple) -> ULONG), | |
| WaitMultiple : (proc "stdcall" (This : ^IWaitMultiple, timeout : DWORD, pSync : ^^ISynchronize) -> HRESULT), | |
| AddSynchronize : (proc "stdcall" (This : ^IWaitMultiple, pSync : ^ISynchronize) -> HRESULT), | |
| }; | |
| IWaitMultiple :: struct { | |
| lpVtbl : ^IWaitMultipleVtbl, | |
| }; | |
| LPADDRTRACKINGCONTROL :: ^IAddrTrackingControl; | |
| IAddrTrackingControlVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IAddrTrackingControl, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IAddrTrackingControl) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IAddrTrackingControl) -> ULONG), | |
| EnableCOMDynamicAddrTracking : (proc "stdcall" (This : ^IAddrTrackingControl) -> HRESULT), | |
| DisableCOMDynamicAddrTracking : (proc "stdcall" (This : ^IAddrTrackingControl) -> HRESULT), | |
| }; | |
| IAddrTrackingControl :: struct { | |
| lpVtbl : ^IAddrTrackingControlVtbl, | |
| }; | |
| LPADDREXCLUSIONCONTROL :: ^IAddrExclusionControl; | |
| IAddrExclusionControlVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IAddrExclusionControl, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IAddrExclusionControl) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IAddrExclusionControl) -> ULONG), | |
| GetCurrentAddrExclusionList : (proc "stdcall" (This : ^IAddrExclusionControl, riid : ^IID, ppEnumerator : ^rawptr) -> HRESULT), | |
| UpdateAddrExclusionList : (proc "stdcall" (This : ^IAddrExclusionControl, pEnumerator : ^IUnknown) -> HRESULT), | |
| }; | |
| IAddrExclusionControl :: struct { | |
| lpVtbl : ^IAddrExclusionControlVtbl, | |
| }; | |
| IPipeByteVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IPipeByte, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IPipeByte) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IPipeByte) -> ULONG), | |
| Pull : (proc "stdcall" (This : ^IPipeByte, buf : ^BYTE, cRequest : ULONG, pcReturned : ^ULONG) -> HRESULT), | |
| Push : (proc "stdcall" (This : ^IPipeByte, buf : ^BYTE, cSent : ULONG) -> HRESULT), | |
| }; | |
| IPipeByte :: struct { | |
| lpVtbl : ^IPipeByteVtbl, | |
| }; | |
| AsyncIPipeByteVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^AsyncIPipeByte, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^AsyncIPipeByte) -> ULONG), | |
| Release : (proc "stdcall" (This : ^AsyncIPipeByte) -> ULONG), | |
| Begin_Pull : (proc "stdcall" (This : ^AsyncIPipeByte, cRequest : ULONG) -> HRESULT), | |
| Finish_Pull : (proc "stdcall" (This : ^AsyncIPipeByte, buf : ^BYTE, pcReturned : ^ULONG) -> HRESULT), | |
| Begin_Push : (proc "stdcall" (This : ^AsyncIPipeByte, buf : ^BYTE, cSent : ULONG) -> HRESULT), | |
| Finish_Push : (proc "stdcall" (This : ^AsyncIPipeByte) -> HRESULT), | |
| }; | |
| AsyncIPipeByte :: struct { | |
| lpVtbl : ^AsyncIPipeByteVtbl, | |
| }; | |
| IPipeLongVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IPipeLong, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IPipeLong) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IPipeLong) -> ULONG), | |
| Pull : (proc "stdcall" (This : ^IPipeLong, buf : ^LONG, cRequest : ULONG, pcReturned : ^ULONG) -> HRESULT), | |
| Push : (proc "stdcall" (This : ^IPipeLong, buf : ^LONG, cSent : ULONG) -> HRESULT), | |
| }; | |
| IPipeLong :: struct { | |
| lpVtbl : ^IPipeLongVtbl, | |
| }; | |
| AsyncIPipeLongVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^AsyncIPipeLong, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^AsyncIPipeLong) -> ULONG), | |
| Release : (proc "stdcall" (This : ^AsyncIPipeLong) -> ULONG), | |
| Begin_Pull : (proc "stdcall" (This : ^AsyncIPipeLong, cRequest : ULONG) -> HRESULT), | |
| Finish_Pull : (proc "stdcall" (This : ^AsyncIPipeLong, buf : ^LONG, pcReturned : ^ULONG) -> HRESULT), | |
| Begin_Push : (proc "stdcall" (This : ^AsyncIPipeLong, buf : ^LONG, cSent : ULONG) -> HRESULT), | |
| Finish_Push : (proc "stdcall" (This : ^AsyncIPipeLong) -> HRESULT), | |
| }; | |
| AsyncIPipeLong :: struct { | |
| lpVtbl : ^AsyncIPipeLongVtbl, | |
| }; | |
| IPipeDoubleVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IPipeDouble, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IPipeDouble) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IPipeDouble) -> ULONG), | |
| Pull : (proc "stdcall" (This : ^IPipeDouble, buf : ^DOUBLE, cRequest : ULONG, pcReturned : ^ULONG) -> HRESULT), | |
| Push : (proc "stdcall" (This : ^IPipeDouble, buf : ^DOUBLE, cSent : ULONG) -> HRESULT), | |
| }; | |
| IPipeDouble :: struct { | |
| lpVtbl : ^IPipeDoubleVtbl, | |
| }; | |
| AsyncIPipeDoubleVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^AsyncIPipeDouble, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^AsyncIPipeDouble) -> ULONG), | |
| Release : (proc "stdcall" (This : ^AsyncIPipeDouble) -> ULONG), | |
| Begin_Pull : (proc "stdcall" (This : ^AsyncIPipeDouble, cRequest : ULONG) -> HRESULT), | |
| Finish_Pull : (proc "stdcall" (This : ^AsyncIPipeDouble, buf : ^DOUBLE, pcReturned : ^ULONG) -> HRESULT), | |
| Begin_Push : (proc "stdcall" (This : ^AsyncIPipeDouble, buf : ^DOUBLE, cSent : ULONG) -> HRESULT), | |
| Finish_Push : (proc "stdcall" (This : ^AsyncIPipeDouble) -> HRESULT), | |
| }; | |
| AsyncIPipeDouble :: struct { | |
| lpVtbl : ^AsyncIPipeDoubleVtbl, | |
| }; | |
| /* APTTYPEQUALIFIER :: enum { */ | |
| APTTYPEQUALIFIER :: _c.int; | |
| APTTYPEQUALIFIER_NONE :: 0; | |
| APTTYPEQUALIFIER_IMPLICIT_MTA :: 1; | |
| APTTYPEQUALIFIER_NA_ON_MTA :: 2; | |
| APTTYPEQUALIFIER_NA_ON_STA :: 3; | |
| APTTYPEQUALIFIER_NA_ON_IMPLICIT_MTA :: 4; | |
| APTTYPEQUALIFIER_NA_ON_MAINSTA :: 5; | |
| APTTYPEQUALIFIER_APPLICATION_STA :: 6; | |
| APTTYPEQUALIFIER_RESERVED_1 :: 7; | |
| /* } */ | |
| ; | |
| /* APTTYPE :: enum { */ | |
| APTTYPE :: _c.int; | |
| APTTYPE_CURRENT :: -1; | |
| APTTYPE_STA :: 0; | |
| APTTYPE_MTA :: 1; | |
| APTTYPE_NA :: 2; | |
| APTTYPE_MAINSTA :: 3; | |
| /* } */ | |
| ; | |
| /* THDTYPE :: enum { */ | |
| THDTYPE :: _c.int; | |
| THDTYPE_BLOCKMESSAGES :: 0; | |
| THDTYPE_PROCESSMESSAGES :: 1; | |
| /* } */ | |
| ; | |
| APARTMENTID :: DWORD; | |
| IComThreadingInfoVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IComThreadingInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IComThreadingInfo) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IComThreadingInfo) -> ULONG), | |
| GetCurrentApartmentType : (proc "stdcall" (This : ^IComThreadingInfo, pAptType : ^APTTYPE) -> HRESULT), | |
| GetCurrentThreadType : (proc "stdcall" (This : ^IComThreadingInfo, pThreadType : ^THDTYPE) -> HRESULT), | |
| GetCurrentLogicalThreadId : (proc "stdcall" (This : ^IComThreadingInfo, pguidLogicalThreadId : ^GUID) -> HRESULT), | |
| SetCurrentLogicalThreadId : (proc "stdcall" (This : ^IComThreadingInfo, rguid : ^GUID) -> HRESULT), | |
| }; | |
| IComThreadingInfo :: struct { | |
| lpVtbl : ^IComThreadingInfoVtbl, | |
| }; | |
| IProcessInitControlVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IProcessInitControl, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IProcessInitControl) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IProcessInitControl) -> ULONG), | |
| ResetInitializerTimeout : (proc "stdcall" (This : ^IProcessInitControl, dwSecondsRemaining : DWORD) -> HRESULT), | |
| }; | |
| IProcessInitControl :: struct { | |
| lpVtbl : ^IProcessInitControlVtbl, | |
| }; | |
| IFastRundownVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IFastRundown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IFastRundown) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IFastRundown) -> ULONG), | |
| }; | |
| IFastRundown :: struct { | |
| lpVtbl : ^IFastRundownVtbl, | |
| }; | |
| /* CO_MARSHALING_CONTEXT_ATTRIBUTES :: enum { */ | |
| CO_MARSHALING_CONTEXT_ATTRIBUTES :: _c.int; | |
| CO_MARSHALING_SOURCE_IS_APP_CONTAINER :: 0; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_1 :: 0x80000000; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_2 :: 0x80000001; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_3 :: 0x80000002; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_4 :: 0x80000003; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_5 :: 0x80000004; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_6 :: 0x80000005; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_7 :: 0x80000006; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_8 :: 0x80000007; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_9 :: 0x80000008; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_10 :: 0x80000009; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_11 :: 0x8000000a; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_12 :: 0x8000000b; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_13 :: 0x8000000c; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_14 :: 0x8000000d; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_15 :: 0x8000000e; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_16 :: 0x8000000f; | |
| CO_MARSHALING_CONTEXT_ATTRIBUTE_RESERVED_17 :: 0x80000010; | |
| /* } */ | |
| ; | |
| IMarshalingStreamVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IMarshalingStream, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IMarshalingStream) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IMarshalingStream) -> ULONG), | |
| Read : (proc "stdcall" (This : ^IMarshalingStream, pv : rawptr, cb : ULONG, pcbRead : ^ULONG) -> HRESULT), | |
| Write : (proc "stdcall" (This : ^IMarshalingStream, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT), | |
| Seek : (proc "stdcall" (This : ^IMarshalingStream, dlibMove : LARGE_INTEGER, dwOrigin : DWORD, plibNewPosition : ^ULARGE_INTEGER) -> HRESULT), | |
| SetSize : (proc "stdcall" (This : ^IMarshalingStream, libNewSize : ULARGE_INTEGER) -> HRESULT), | |
| CopyTo : (proc "stdcall" (This : ^IMarshalingStream, pstm : ^IStream, cb : ULARGE_INTEGER, pcbRead : ^ULARGE_INTEGER, pcbWritten : ^ULARGE_INTEGER) -> HRESULT), | |
| Commit : (proc "stdcall" (This : ^IMarshalingStream, grfCommitFlags : DWORD) -> HRESULT), | |
| Revert : (proc "stdcall" (This : ^IMarshalingStream) -> HRESULT), | |
| LockRegion : (proc "stdcall" (This : ^IMarshalingStream, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT), | |
| UnlockRegion : (proc "stdcall" (This : ^IMarshalingStream, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT), | |
| Stat : (proc "stdcall" (This : ^IMarshalingStream, pstatstg : ^STATSTG, grfStatFlag : DWORD) -> HRESULT), | |
| Clone : (proc "stdcall" (This : ^IMarshalingStream, ppstm : ^^IStream) -> HRESULT), | |
| GetMarshalingContextAttribute : (proc "stdcall" (This : ^IMarshalingStream, attribute : CO_MARSHALING_CONTEXT_ATTRIBUTES, pAttributeValue : ^ULONG_PTR) -> HRESULT), | |
| }; | |
| IMarshalingStream :: struct { | |
| lpVtbl : ^IMarshalingStreamVtbl, | |
| }; | |
| IAgileReferenceVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IAgileReference, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IAgileReference) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IAgileReference) -> ULONG), | |
| Resolve : (proc "stdcall" (This : ^IAgileReference, riid : ^IID, ppvObjectReference : ^rawptr) -> HRESULT), | |
| }; | |
| IAgileReference :: struct { | |
| lpVtbl : ^IAgileReferenceVtbl, | |
| }; | |
| ServerInformation :: struct { | |
| dwServerPid : DWORD, | |
| dwServerTid : DWORD, | |
| ui64ServerAddress : UINT64, | |
| }; | |
| PServerInformation :: ^ServerInformation; | |
| CO_MTA_USAGE_COOKIE__ :: struct { | |
| unused : _c.int, | |
| }; | |
| CO_MTA_USAGE_COOKIE :: ^CO_MTA_USAGE_COOKIE__; | |
| /* STDMSHLFLAGS :: enum { */ | |
| STDMSHLFLAGS :: _c.int; | |
| SMEXF_SERVER :: 0x01; | |
| SMEXF_HANDLER :: 0x02; | |
| /* } */ | |
| ; | |
| PROPVARIANT :: struct {}; | |
| /* COWAIT_FLAGS :: enum { */ | |
| COWAIT_FLAGS :: _c.int; | |
| COWAIT_DEFAULT :: 0; | |
| COWAIT_WAITALL :: 1; | |
| COWAIT_ALERTABLE :: 2; | |
| COWAIT_INPUTAVAILABLE :: 4; | |
| COWAIT_DISPATCH_CALLS :: 8; | |
| COWAIT_DISPATCH_WINDOW_MESSAGES :: 0x10; | |
| /* } */ | |
| ; | |
| /* CWMO_FLAGS :: enum { */ | |
| CWMO_FLAGS :: _c.int; | |
| CWMO_DEFAULT :: 0; | |
| CWMO_DISPATCH_CALLS :: 1; | |
| CWMO_DISPATCH_WINDOW_MESSAGES :: 2; | |
| /* } */ | |
| ; | |
| /* AgileReferenceOptions :: enum { */ | |
| AgileReferenceOptions :: _c.int; | |
| AGILEREFERENCE_DEFAULT :: 0; | |
| AGILEREFERENCE_DELAYEDMARSHAL :: 1; | |
| /* } */ | |
| ; | |
| LPFNGETCLASSOBJECT :: (proc "stdcall" (^IID, ^IID, ^LPVOID) -> HRESULT); | |
| LPFNCANUNLOADNOW :: (proc "stdcall" () -> HRESULT); | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| LPMALLOCSPY :: ^IMallocSpy; | |
| IMallocSpyVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IMallocSpy, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IMallocSpy) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IMallocSpy) -> ULONG), | |
| PreAlloc : (proc "stdcall" (This : ^IMallocSpy, cbRequest : SIZE_T) -> SIZE_T), | |
| PostAlloc : (proc "stdcall" (This : ^IMallocSpy, pActual : rawptr) -> rawptr), | |
| PreFree : (proc "stdcall" (This : ^IMallocSpy, pRequest : rawptr, fSpyed : BOOL) -> rawptr), | |
| PostFree : proc "stdcall" (This : ^IMallocSpy, fSpyed : BOOL), | |
| PreRealloc : (proc "stdcall" (This : ^IMallocSpy, pRequest : rawptr, cbRequest : SIZE_T, ppNewRequest : ^rawptr, fSpyed : BOOL) -> SIZE_T), | |
| PostRealloc : (proc "stdcall" (This : ^IMallocSpy, pActual : rawptr, fSpyed : BOOL) -> rawptr), | |
| PreGetSize : (proc "stdcall" (This : ^IMallocSpy, pRequest : rawptr, fSpyed : BOOL) -> rawptr), | |
| PostGetSize : (proc "stdcall" (This : ^IMallocSpy, cbActual : SIZE_T, fSpyed : BOOL) -> SIZE_T), | |
| PreDidAlloc : (proc "stdcall" (This : ^IMallocSpy, pRequest : rawptr, fSpyed : BOOL) -> rawptr), | |
| PostDidAlloc : (proc "stdcall" (This : ^IMallocSpy, pRequest : rawptr, fSpyed : BOOL, fActual : _c.int) -> _c.int), | |
| PreHeapMinimize : proc "stdcall" (This : ^IMallocSpy), | |
| PostHeapMinimize : proc "stdcall" (This : ^IMallocSpy), | |
| }; | |
| IMallocSpy :: struct { | |
| lpVtbl : ^IMallocSpyVtbl, | |
| }; | |
| LPBC :: ^IBindCtx; | |
| LPBINDCTX :: ^IBindCtx; | |
| BIND_OPTS :: struct { | |
| cbStruct : DWORD, | |
| grfFlags : DWORD, | |
| grfMode : DWORD, | |
| dwTickCountDeadline : DWORD, | |
| }; | |
| LPBIND_OPTS :: ^BIND_OPTS; | |
| BIND_OPTS2 :: struct { | |
| cbStruct : DWORD, | |
| grfFlags : DWORD, | |
| grfMode : DWORD, | |
| dwTickCountDeadline : DWORD, | |
| dwTrackFlags : DWORD, | |
| dwClassContext : DWORD, | |
| locale : LCID, | |
| pServerInfo : ^COSERVERINFO, | |
| }; | |
| LPBIND_OPTS2 :: ^BIND_OPTS2; | |
| BIND_OPTS3 :: struct { | |
| cbStruct : DWORD, | |
| grfFlags : DWORD, | |
| grfMode : DWORD, | |
| dwTickCountDeadline : DWORD, | |
| dwTrackFlags : DWORD, | |
| dwClassContext : DWORD, | |
| locale : LCID, | |
| pServerInfo : ^COSERVERINFO, | |
| hwnd : HWND, | |
| }; | |
| LPBIND_OPTS3 :: ^BIND_OPTS3; | |
| /* BIND_FLAGS :: enum { */ | |
| BIND_FLAGS :: _c.int; | |
| BIND_MAYBOTHERUSER :: 1; | |
| BIND_JUSTTESTEXISTENCE :: 2; | |
| /* } */ | |
| ; | |
| IBindCtxVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IBindCtx, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IBindCtx) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IBindCtx) -> ULONG), | |
| RegisterObjectBound : (proc "stdcall" (This : ^IBindCtx, punk : ^IUnknown) -> HRESULT), | |
| RevokeObjectBound : (proc "stdcall" (This : ^IBindCtx, punk : ^IUnknown) -> HRESULT), | |
| ReleaseBoundObjects : (proc "stdcall" (This : ^IBindCtx) -> HRESULT), | |
| SetBindOptions : (proc "stdcall" (This : ^IBindCtx, pbindopts : ^BIND_OPTS) -> HRESULT), | |
| GetBindOptions : (proc "stdcall" (This : ^IBindCtx, pbindopts : ^BIND_OPTS) -> HRESULT), | |
| GetRunningObjectTable : (proc "stdcall" (This : ^IBindCtx, pprot : ^^IRunningObjectTable) -> HRESULT), | |
| RegisterObjectParam : (proc "stdcall" (This : ^IBindCtx, pszKey : LPOLESTR, punk : ^IUnknown) -> HRESULT), | |
| GetObjectParam : (proc "stdcall" (This : ^IBindCtx, pszKey : LPOLESTR, ppunk : ^^IUnknown) -> HRESULT), | |
| EnumObjectParam : (proc "stdcall" (This : ^IBindCtx, ppenum : ^^IEnumString) -> HRESULT), | |
| RevokeObjectParam : (proc "stdcall" (This : ^IBindCtx, pszKey : LPOLESTR) -> HRESULT), | |
| }; | |
| IBindCtx :: struct { | |
| lpVtbl : ^IBindCtxVtbl, | |
| }; | |
| LPENUMMONIKER :: ^IEnumMoniker; | |
| IEnumMonikerVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IEnumMoniker, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IEnumMoniker) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IEnumMoniker) -> ULONG), | |
| Next : (proc "stdcall" (This : ^IEnumMoniker, celt : ULONG, rgelt : ^^IMoniker, pceltFetched : ^ULONG) -> HRESULT), | |
| Skip : (proc "stdcall" (This : ^IEnumMoniker, celt : ULONG) -> HRESULT), | |
| Reset : (proc "stdcall" (This : ^IEnumMoniker) -> HRESULT), | |
| Clone : (proc "stdcall" (This : ^IEnumMoniker, ppenum : ^^IEnumMoniker) -> HRESULT), | |
| }; | |
| IEnumMoniker :: struct { | |
| lpVtbl : ^IEnumMonikerVtbl, | |
| }; | |
| LPRUNNABLEOBJECT :: ^IRunnableObject; | |
| IRunnableObjectVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRunnableObject, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRunnableObject) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRunnableObject) -> ULONG), | |
| GetRunningClass : (proc "stdcall" (This : ^IRunnableObject, lpClsid : LPCLSID) -> HRESULT), | |
| Run : (proc "stdcall" (This : ^IRunnableObject, pbc : LPBINDCTX) -> HRESULT), | |
| IsRunning : (proc "stdcall" (This : ^IRunnableObject) -> BOOL), | |
| LockRunning : (proc "stdcall" (This : ^IRunnableObject, fLock : BOOL, fLastUnlockCloses : BOOL) -> HRESULT), | |
| SetContainedObject : (proc "stdcall" (This : ^IRunnableObject, fContained : BOOL) -> HRESULT), | |
| }; | |
| IRunnableObject :: struct { | |
| lpVtbl : ^IRunnableObjectVtbl, | |
| }; | |
| LPRUNNINGOBJECTTABLE :: ^IRunningObjectTable; | |
| IRunningObjectTableVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRunningObjectTable, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRunningObjectTable) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRunningObjectTable) -> ULONG), | |
| Register : (proc "stdcall" (This : ^IRunningObjectTable, grfFlags : DWORD, punkObject : ^IUnknown, pmkObjectName : ^IMoniker, pdwRegister : ^DWORD) -> HRESULT), | |
| Revoke : (proc "stdcall" (This : ^IRunningObjectTable, dwRegister : DWORD) -> HRESULT), | |
| IsRunning : (proc "stdcall" (This : ^IRunningObjectTable, pmkObjectName : ^IMoniker) -> HRESULT), | |
| GetObjectA : (proc "stdcall" (This : ^IRunningObjectTable, pmkObjectName : ^IMoniker, ppunkObject : ^^IUnknown) -> HRESULT), | |
| NoteChangeTime : (proc "stdcall" (This : ^IRunningObjectTable, dwRegister : DWORD, pfiletime : ^FILETIME) -> HRESULT), | |
| GetTimeOfLastChange : (proc "stdcall" (This : ^IRunningObjectTable, pmkObjectName : ^IMoniker, pfiletime : ^FILETIME) -> HRESULT), | |
| EnumRunning : (proc "stdcall" (This : ^IRunningObjectTable, ppenumMoniker : ^^IEnumMoniker) -> HRESULT), | |
| }; | |
| IRunningObjectTable :: struct { | |
| lpVtbl : ^IRunningObjectTableVtbl, | |
| }; | |
| LPPERSIST :: ^IPersist; | |
| IPersistVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IPersist, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IPersist) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IPersist) -> ULONG), | |
| GetClassID : (proc "stdcall" (This : ^IPersist, pClassID : ^CLSID) -> HRESULT), | |
| }; | |
| IPersist :: struct { | |
| lpVtbl : ^IPersistVtbl, | |
| }; | |
| LPPERSISTSTREAM :: ^IPersistStream; | |
| IPersistStreamVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IPersistStream, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IPersistStream) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IPersistStream) -> ULONG), | |
| GetClassID : (proc "stdcall" (This : ^IPersistStream, pClassID : ^CLSID) -> HRESULT), | |
| IsDirty : (proc "stdcall" (This : ^IPersistStream) -> HRESULT), | |
| Load : (proc "stdcall" (This : ^IPersistStream, pStm : ^IStream) -> HRESULT), | |
| Save : (proc "stdcall" (This : ^IPersistStream, pStm : ^IStream, fClearDirty : BOOL) -> HRESULT), | |
| GetSizeMax : (proc "stdcall" (This : ^IPersistStream, pcbSize : ^ULARGE_INTEGER) -> HRESULT), | |
| }; | |
| IPersistStream :: struct { | |
| lpVtbl : ^IPersistStreamVtbl, | |
| }; | |
| LPMONIKER :: ^IMoniker; | |
| /* MKSYS :: enum { */ | |
| MKSYS :: _c.int; | |
| MKSYS_NONE :: 0; | |
| MKSYS_GENERICCOMPOSITE :: 1; | |
| MKSYS_FILEMONIKER :: 2; | |
| MKSYS_ANTIMONIKER :: 3; | |
| MKSYS_ITEMMONIKER :: 4; | |
| MKSYS_POINTERMONIKER :: 5; | |
| MKSYS_CLASSMONIKER :: 7; | |
| MKSYS_OBJREFMONIKER :: 8; | |
| MKSYS_SESSIONMONIKER :: 9; | |
| MKSYS_LUAMONIKER :: 10; | |
| /* } */ | |
| ; | |
| /* MKRREDUCE :: enum { */ | |
| MKRREDUCE :: _c.int; | |
| MKRREDUCE_ONE :: (3 << 16); | |
| MKRREDUCE_TOUSER :: (2 << 16); | |
| MKRREDUCE_THROUGHUSER :: (1 << 16); | |
| MKRREDUCE_ALL :: 0; | |
| /* } */ | |
| ; | |
| IMonikerVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IMoniker, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IMoniker) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IMoniker) -> ULONG), | |
| GetClassID : (proc "stdcall" (This : ^IMoniker, pClassID : ^CLSID) -> HRESULT), | |
| IsDirty : (proc "stdcall" (This : ^IMoniker) -> HRESULT), | |
| Load : (proc "stdcall" (This : ^IMoniker, pStm : ^IStream) -> HRESULT), | |
| Save : (proc "stdcall" (This : ^IMoniker, pStm : ^IStream, fClearDirty : BOOL) -> HRESULT), | |
| GetSizeMax : (proc "stdcall" (This : ^IMoniker, pcbSize : ^ULARGE_INTEGER) -> HRESULT), | |
| BindToObject : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, riidResult : ^IID, ppvResult : ^rawptr) -> HRESULT), | |
| BindToStorage : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, riid : ^IID, ppvObj : ^rawptr) -> HRESULT), | |
| Reduce : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, dwReduceHowFar : DWORD, ppmkToLeft : ^^IMoniker, ppmkReduced : ^^IMoniker) -> HRESULT), | |
| ComposeWith : (proc "stdcall" (This : ^IMoniker, pmkRight : ^IMoniker, fOnlyIfNotGeneric : BOOL, ppmkComposite : ^^IMoniker) -> HRESULT), | |
| Enum : (proc "stdcall" (This : ^IMoniker, fForward : BOOL, ppenumMoniker : ^^IEnumMoniker) -> HRESULT), | |
| IsEqual : (proc "stdcall" (This : ^IMoniker, pmkOtherMoniker : ^IMoniker) -> HRESULT), | |
| Hash : (proc "stdcall" (This : ^IMoniker, pdwHash : ^DWORD) -> HRESULT), | |
| IsRunning : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, pmkNewlyRunning : ^IMoniker) -> HRESULT), | |
| GetTimeOfLastChange : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, pFileTime : ^FILETIME) -> HRESULT), | |
| Inverse : (proc "stdcall" (This : ^IMoniker, ppmk : ^^IMoniker) -> HRESULT), | |
| CommonPrefixWith : (proc "stdcall" (This : ^IMoniker, pmkOther : ^IMoniker, ppmkPrefix : ^^IMoniker) -> HRESULT), | |
| RelativePathTo : (proc "stdcall" (This : ^IMoniker, pmkOther : ^IMoniker, ppmkRelPath : ^^IMoniker) -> HRESULT), | |
| GetDisplayName : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, ppszDisplayName : ^LPOLESTR) -> HRESULT), | |
| ParseDisplayName : (proc "stdcall" (This : ^IMoniker, pbc : ^IBindCtx, pmkToLeft : ^IMoniker, pszDisplayName : LPOLESTR, pchEaten : ^ULONG, ppmkOut : ^^IMoniker) -> HRESULT), | |
| IsSystemMoniker : (proc "stdcall" (This : ^IMoniker, pdwMksys : ^DWORD) -> HRESULT), | |
| }; | |
| IMoniker :: struct { | |
| lpVtbl : ^IMonikerVtbl, | |
| }; | |
| IROTDataVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IROTData, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IROTData) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IROTData) -> ULONG), | |
| GetComparisonData : (proc "stdcall" (This : ^IROTData, pbData : ^byte, cbMax : ULONG, pcbData : ^ULONG) -> HRESULT), | |
| }; | |
| IROTData :: struct { | |
| lpVtbl : ^IROTDataVtbl, | |
| }; | |
| LPENUMSTATSTG :: ^IEnumSTATSTG; | |
| IEnumSTATSTGVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IEnumSTATSTG, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IEnumSTATSTG) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IEnumSTATSTG) -> ULONG), | |
| Next : (proc "stdcall" (This : ^IEnumSTATSTG, celt : ULONG, rgelt : ^STATSTG, pceltFetched : ^ULONG) -> HRESULT), | |
| Skip : (proc "stdcall" (This : ^IEnumSTATSTG, celt : ULONG) -> HRESULT), | |
| Reset : (proc "stdcall" (This : ^IEnumSTATSTG) -> HRESULT), | |
| Clone : (proc "stdcall" (This : ^IEnumSTATSTG, ppenum : ^^IEnumSTATSTG) -> HRESULT), | |
| }; | |
| IEnumSTATSTG :: struct { | |
| lpVtbl : ^IEnumSTATSTGVtbl, | |
| }; | |
| LPSTORAGE :: ^IStorage; | |
| RemSNB :: struct { | |
| ulCntStr : ULONG, | |
| ulCntChar : ULONG, | |
| rgString : [1]OLECHAR, | |
| }; | |
| wireSNB :: ^RemSNB; | |
| SNB :: ^LPOLESTR; | |
| IStorageVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IStorage) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IStorage) -> ULONG), | |
| CreateStream : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, grfMode : DWORD, reserved1 : DWORD, reserved2 : DWORD, ppstm : ^^IStream) -> HRESULT), | |
| OpenStream : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, reserved1 : rawptr, grfMode : DWORD, reserved2 : DWORD, ppstm : ^^IStream) -> HRESULT), | |
| CreateStorage : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, grfMode : DWORD, reserved1 : DWORD, reserved2 : DWORD, ppstg : ^^IStorage) -> HRESULT), | |
| OpenStorage : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, pstgPriority : ^IStorage, grfMode : DWORD, snbExclude : SNB, reserved : DWORD, ppstg : ^^IStorage) -> HRESULT), | |
| CopyTo : (proc "stdcall" (This : ^IStorage, ciidExclude : DWORD, rgiidExclude : ^IID, snbExclude : SNB, pstgDest : ^IStorage) -> HRESULT), | |
| MoveElementTo : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, pstgDest : ^IStorage, pwcsNewName : ^OLECHAR, grfFlags : DWORD) -> HRESULT), | |
| Commit : (proc "stdcall" (This : ^IStorage, grfCommitFlags : DWORD) -> HRESULT), | |
| Revert : (proc "stdcall" (This : ^IStorage) -> HRESULT), | |
| EnumElements : (proc "stdcall" (This : ^IStorage, reserved1 : DWORD, reserved2 : rawptr, reserved3 : DWORD, ppenum : ^^IEnumSTATSTG) -> HRESULT), | |
| DestroyElement : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR) -> HRESULT), | |
| RenameElement : (proc "stdcall" (This : ^IStorage, pwcsOldName : ^OLECHAR, pwcsNewName : ^OLECHAR) -> HRESULT), | |
| SetElementTimes : (proc "stdcall" (This : ^IStorage, pwcsName : ^OLECHAR, pctime : ^FILETIME, patime : ^FILETIME, pmtime : ^FILETIME) -> HRESULT), | |
| SetClass : (proc "stdcall" (This : ^IStorage, clsid : ^IID) -> HRESULT), | |
| SetStateBits : (proc "stdcall" (This : ^IStorage, grfStateBits : DWORD, grfMask : DWORD) -> HRESULT), | |
| Stat : (proc "stdcall" (This : ^IStorage, pstatstg : ^STATSTG, grfStatFlag : DWORD) -> HRESULT), | |
| }; | |
| IStorage :: struct { | |
| lpVtbl : ^IStorageVtbl, | |
| }; | |
| LPPERSISTFILE :: ^IPersistFile; | |
| IPersistFileVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IPersistFile, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IPersistFile) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IPersistFile) -> ULONG), | |
| GetClassID : (proc "stdcall" (This : ^IPersistFile, pClassID : ^CLSID) -> HRESULT), | |
| IsDirty : (proc "stdcall" (This : ^IPersistFile) -> HRESULT), | |
| Load : (proc "stdcall" (This : ^IPersistFile, pszFileName : LPCOLESTR, dwMode : DWORD) -> HRESULT), | |
| Save : (proc "stdcall" (This : ^IPersistFile, pszFileName : LPCOLESTR, fRemember : BOOL) -> HRESULT), | |
| SaveCompleted : (proc "stdcall" (This : ^IPersistFile, pszFileName : LPCOLESTR) -> HRESULT), | |
| GetCurFile : (proc "stdcall" (This : ^IPersistFile, ppszFileName : ^LPOLESTR) -> HRESULT), | |
| }; | |
| IPersistFile :: struct { | |
| lpVtbl : ^IPersistFileVtbl, | |
| }; | |
| LPPERSISTSTORAGE :: ^IPersistStorage; | |
| IPersistStorageVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IPersistStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IPersistStorage) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IPersistStorage) -> ULONG), | |
| GetClassID : (proc "stdcall" (This : ^IPersistStorage, pClassID : ^CLSID) -> HRESULT), | |
| IsDirty : (proc "stdcall" (This : ^IPersistStorage) -> HRESULT), | |
| InitNew : (proc "stdcall" (This : ^IPersistStorage, pStg : ^IStorage) -> HRESULT), | |
| Load : (proc "stdcall" (This : ^IPersistStorage, pStg : ^IStorage) -> HRESULT), | |
| Save : (proc "stdcall" (This : ^IPersistStorage, pStgSave : ^IStorage, fSameAsLoad : BOOL) -> HRESULT), | |
| SaveCompleted : (proc "stdcall" (This : ^IPersistStorage, pStgNew : ^IStorage) -> HRESULT), | |
| HandsOffStorage : (proc "stdcall" (This : ^IPersistStorage) -> HRESULT), | |
| }; | |
| IPersistStorage :: struct { | |
| lpVtbl : ^IPersistStorageVtbl, | |
| }; | |
| LPLOCKBYTES :: ^ILockBytes; | |
| ILockBytesVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ILockBytes, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ILockBytes) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ILockBytes) -> ULONG), | |
| ReadAt : (proc "stdcall" (This : ^ILockBytes, ulOffset : ULARGE_INTEGER, pv : rawptr, cb : ULONG, pcbRead : ^ULONG) -> HRESULT), | |
| WriteAt : (proc "stdcall" (This : ^ILockBytes, ulOffset : ULARGE_INTEGER, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT), | |
| Flush : (proc "stdcall" (This : ^ILockBytes) -> HRESULT), | |
| SetSize : (proc "stdcall" (This : ^ILockBytes, cb : ULARGE_INTEGER) -> HRESULT), | |
| LockRegion : (proc "stdcall" (This : ^ILockBytes, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT), | |
| UnlockRegion : (proc "stdcall" (This : ^ILockBytes, libOffset : ULARGE_INTEGER, cb : ULARGE_INTEGER, dwLockType : DWORD) -> HRESULT), | |
| Stat : (proc "stdcall" (This : ^ILockBytes, pstatstg : ^STATSTG, grfStatFlag : DWORD) -> HRESULT), | |
| }; | |
| ILockBytes :: struct { | |
| lpVtbl : ^ILockBytesVtbl, | |
| }; | |
| LPENUMFORMATETC :: ^IEnumFORMATETC; | |
| DVTARGETDEVICE :: struct { | |
| tdSize : DWORD, | |
| tdDriverNameOffset : WORD, | |
| tdDeviceNameOffset : WORD, | |
| tdPortNameOffset : WORD, | |
| tdExtDevmodeOffset : WORD, | |
| tdData : [1]BYTE, | |
| }; | |
| LPCLIPFORMAT :: ^CLIPFORMAT; | |
| FORMATETC :: struct { | |
| cfFormat : CLIPFORMAT, | |
| ptd : ^DVTARGETDEVICE, | |
| dwAspect : DWORD, | |
| lindex : LONG, | |
| tymed : DWORD, | |
| }; | |
| LPFORMATETC :: ^FORMATETC; | |
| IEnumFORMATETCVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IEnumFORMATETC, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IEnumFORMATETC) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IEnumFORMATETC) -> ULONG), | |
| Next : (proc "stdcall" (This : ^IEnumFORMATETC, celt : ULONG, rgelt : ^FORMATETC, pceltFetched : ^ULONG) -> HRESULT), | |
| Skip : (proc "stdcall" (This : ^IEnumFORMATETC, celt : ULONG) -> HRESULT), | |
| Reset : (proc "stdcall" (This : ^IEnumFORMATETC) -> HRESULT), | |
| Clone : (proc "stdcall" (This : ^IEnumFORMATETC, ppenum : ^^IEnumFORMATETC) -> HRESULT), | |
| }; | |
| IEnumFORMATETC :: struct { | |
| lpVtbl : ^IEnumFORMATETCVtbl, | |
| }; | |
| LPENUMSTATDATA :: ^IEnumSTATDATA; | |
| /* ADVF :: enum { */ | |
| ADVF :: _c.int; | |
| ADVF_NODATA :: 1; | |
| ADVF_PRIMEFIRST :: 2; | |
| ADVF_ONLYONCE :: 4; | |
| ADVF_DATAONSTOP :: 64; | |
| ADVFCACHE_NOHANDLER :: 8; | |
| ADVFCACHE_FORCEBUILTIN :: 16; | |
| ADVFCACHE_ONSAVE :: 32; | |
| /* } */ | |
| ; | |
| STATDATA :: struct { | |
| formatetc : FORMATETC, | |
| advf : DWORD, | |
| pAdvSink : ^IAdviseSink, | |
| dwConnection : DWORD, | |
| }; | |
| LPSTATDATA :: ^STATDATA; | |
| IEnumSTATDATAVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IEnumSTATDATA, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IEnumSTATDATA) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IEnumSTATDATA) -> ULONG), | |
| Next : (proc "stdcall" (This : ^IEnumSTATDATA, celt : ULONG, rgelt : ^STATDATA, pceltFetched : ^ULONG) -> HRESULT), | |
| Skip : (proc "stdcall" (This : ^IEnumSTATDATA, celt : ULONG) -> HRESULT), | |
| Reset : (proc "stdcall" (This : ^IEnumSTATDATA) -> HRESULT), | |
| Clone : (proc "stdcall" (This : ^IEnumSTATDATA, ppenum : ^^IEnumSTATDATA) -> HRESULT), | |
| }; | |
| IEnumSTATDATA :: struct { | |
| lpVtbl : ^IEnumSTATDATAVtbl, | |
| }; | |
| LPROOTSTORAGE :: ^IRootStorage; | |
| IRootStorageVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRootStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRootStorage) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRootStorage) -> ULONG), | |
| SwitchToFile : (proc "stdcall" (This : ^IRootStorage, pszFile : LPOLESTR) -> HRESULT), | |
| }; | |
| IRootStorage :: struct { | |
| lpVtbl : ^IRootStorageVtbl, | |
| }; | |
| LPADVISESINK :: ^IAdviseSink; | |
| /* TYMED :: enum { */ | |
| TYMED :: _c.int; | |
| TYMED_HGLOBAL :: 1; | |
| TYMED_FILE :: 2; | |
| TYMED_ISTREAM :: 4; | |
| TYMED_ISTORAGE :: 8; | |
| TYMED_GDI :: 16; | |
| TYMED_MFPICT :: 32; | |
| TYMED_ENHMF :: 64; | |
| TYMED_NULL :: 0; | |
| /* } */ | |
| ; | |
| RemSTGMEDIUM :: struct { | |
| tymed : DWORD, | |
| dwHandleType : DWORD, | |
| pData : ULONG, | |
| pUnkForRelease : ULONG, | |
| cbData : ULONG, | |
| data : [1]byte, | |
| }; | |
| uSTGMEDIUM :: struct { | |
| tymed : DWORD, | |
| u : struct #raw_union { | |
| hBitmap : HBITMAP, | |
| hMetaFilePict : HMETAFILEPICT, | |
| hEnhMetaFile : HENHMETAFILE, | |
| hGlobal : HGLOBAL, | |
| lpszFileName : LPOLESTR, | |
| pstm : ^IStream, | |
| pstg : ^IStorage, | |
| }, | |
| pUnkForRelease : ^IUnknown, | |
| }; | |
| GDI_OBJECT :: struct { | |
| ObjectType : DWORD, | |
| u : struct #raw_union { | |
| hBitmap : wireHBITMAP, | |
| hPalette : wireHPALETTE, | |
| hGeneric : wireHGLOBAL, | |
| }, | |
| }; | |
| userSTGMEDIUM :: struct { | |
| u : struct { | |
| tymed : DWORD, | |
| u : struct #raw_union { | |
| hMetaFilePict : wireHMETAFILEPICT, | |
| hHEnhMetaFile : wireHENHMETAFILE, | |
| hGdiHandle : ^GDI_OBJECT, | |
| hGlobal : wireHGLOBAL, | |
| lpszFileName : LPOLESTR, | |
| pstm : ^BYTE_BLOB, | |
| pstg : ^BYTE_BLOB, | |
| }, | |
| }, | |
| pUnkForRelease : ^IUnknown, | |
| }; | |
| wireSTGMEDIUM :: ^userSTGMEDIUM; | |
| STGMEDIUM :: uSTGMEDIUM; | |
| wireASYNC_STGMEDIUM :: ^userSTGMEDIUM; | |
| ASYNC_STGMEDIUM :: STGMEDIUM; | |
| LPSTGMEDIUM :: ^STGMEDIUM; | |
| userFLAG_STGMEDIUM :: struct { | |
| ContextFlags : LONG, | |
| fPassOwnership : LONG, | |
| Stgmed : userSTGMEDIUM, | |
| }; | |
| wireFLAG_STGMEDIUM :: ^userFLAG_STGMEDIUM; | |
| FLAG_STGMEDIUM :: struct { | |
| ContextFlags : LONG, | |
| fPassOwnership : LONG, | |
| Stgmed : STGMEDIUM, | |
| }; | |
| IAdviseSinkVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IAdviseSink, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IAdviseSink) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IAdviseSink) -> ULONG), | |
| OnDataChange : proc "stdcall" (This : ^IAdviseSink, pFormatetc : ^FORMATETC, pStgmed : ^STGMEDIUM), | |
| OnViewChange : proc "stdcall" (This : ^IAdviseSink, dwAspect : DWORD, lindex : LONG), | |
| OnRename : proc "stdcall" (This : ^IAdviseSink, pmk : ^IMoniker), | |
| OnSave : proc "stdcall" (This : ^IAdviseSink), | |
| OnClose : proc "stdcall" (This : ^IAdviseSink), | |
| }; | |
| IAdviseSink :: struct { | |
| lpVtbl : ^IAdviseSinkVtbl, | |
| }; | |
| AsyncIAdviseSinkVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^AsyncIAdviseSink, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^AsyncIAdviseSink) -> ULONG), | |
| Release : (proc "stdcall" (This : ^AsyncIAdviseSink) -> ULONG), | |
| Begin_OnDataChange : proc "stdcall" (This : ^AsyncIAdviseSink, pFormatetc : ^FORMATETC, pStgmed : ^STGMEDIUM), | |
| Finish_OnDataChange : proc "stdcall" (This : ^AsyncIAdviseSink), | |
| Begin_OnViewChange : proc "stdcall" (This : ^AsyncIAdviseSink, dwAspect : DWORD, lindex : LONG), | |
| Finish_OnViewChange : proc "stdcall" (This : ^AsyncIAdviseSink), | |
| Begin_OnRename : proc "stdcall" (This : ^AsyncIAdviseSink, pmk : ^IMoniker), | |
| Finish_OnRename : proc "stdcall" (This : ^AsyncIAdviseSink), | |
| Begin_OnSave : proc "stdcall" (This : ^AsyncIAdviseSink), | |
| Finish_OnSave : proc "stdcall" (This : ^AsyncIAdviseSink), | |
| Begin_OnClose : proc "stdcall" (This : ^AsyncIAdviseSink), | |
| Finish_OnClose : proc "stdcall" (This : ^AsyncIAdviseSink), | |
| }; | |
| AsyncIAdviseSink :: struct { | |
| lpVtbl : ^AsyncIAdviseSinkVtbl, | |
| }; | |
| LPADVISESINK2 :: ^IAdviseSink2; | |
| IAdviseSink2Vtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IAdviseSink2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IAdviseSink2) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IAdviseSink2) -> ULONG), | |
| OnDataChange : proc "stdcall" (This : ^IAdviseSink2, pFormatetc : ^FORMATETC, pStgmed : ^STGMEDIUM), | |
| OnViewChange : proc "stdcall" (This : ^IAdviseSink2, dwAspect : DWORD, lindex : LONG), | |
| OnRename : proc "stdcall" (This : ^IAdviseSink2, pmk : ^IMoniker), | |
| OnSave : proc "stdcall" (This : ^IAdviseSink2), | |
| OnClose : proc "stdcall" (This : ^IAdviseSink2), | |
| OnLinkSrcChange : proc "stdcall" (This : ^IAdviseSink2, pmk : ^IMoniker), | |
| }; | |
| IAdviseSink2 :: struct { | |
| lpVtbl : ^IAdviseSink2Vtbl, | |
| }; | |
| AsyncIAdviseSink2Vtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^AsyncIAdviseSink2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^AsyncIAdviseSink2) -> ULONG), | |
| Release : (proc "stdcall" (This : ^AsyncIAdviseSink2) -> ULONG), | |
| Begin_OnDataChange : proc "stdcall" (This : ^AsyncIAdviseSink2, pFormatetc : ^FORMATETC, pStgmed : ^STGMEDIUM), | |
| Finish_OnDataChange : proc "stdcall" (This : ^AsyncIAdviseSink2), | |
| Begin_OnViewChange : proc "stdcall" (This : ^AsyncIAdviseSink2, dwAspect : DWORD, lindex : LONG), | |
| Finish_OnViewChange : proc "stdcall" (This : ^AsyncIAdviseSink2), | |
| Begin_OnRename : proc "stdcall" (This : ^AsyncIAdviseSink2, pmk : ^IMoniker), | |
| Finish_OnRename : proc "stdcall" (This : ^AsyncIAdviseSink2), | |
| Begin_OnSave : proc "stdcall" (This : ^AsyncIAdviseSink2), | |
| Finish_OnSave : proc "stdcall" (This : ^AsyncIAdviseSink2), | |
| Begin_OnClose : proc "stdcall" (This : ^AsyncIAdviseSink2), | |
| Finish_OnClose : proc "stdcall" (This : ^AsyncIAdviseSink2), | |
| Begin_OnLinkSrcChange : proc "stdcall" (This : ^AsyncIAdviseSink2, pmk : ^IMoniker), | |
| Finish_OnLinkSrcChange : proc "stdcall" (This : ^AsyncIAdviseSink2), | |
| }; | |
| AsyncIAdviseSink2 :: struct { | |
| lpVtbl : ^AsyncIAdviseSink2Vtbl, | |
| }; | |
| LPDATAOBJECT :: ^IDataObject; | |
| /* DATADIR :: enum { */ | |
| DATADIR :: _c.int; | |
| DATADIR_GET :: 1; | |
| DATADIR_SET :: 2; | |
| /* } */ | |
| ; | |
| IDataObjectVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IDataObject, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IDataObject) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IDataObject) -> ULONG), | |
| GetData : (proc "stdcall" (This : ^IDataObject, pformatetcIn : ^FORMATETC, pmedium : ^STGMEDIUM) -> HRESULT), | |
| GetDataHere : (proc "stdcall" (This : ^IDataObject, pformatetc : ^FORMATETC, pmedium : ^STGMEDIUM) -> HRESULT), | |
| QueryGetData : (proc "stdcall" (This : ^IDataObject, pformatetc : ^FORMATETC) -> HRESULT), | |
| GetCanonicalFormatEtc : (proc "stdcall" (This : ^IDataObject, pformatectIn : ^FORMATETC, pformatetcOut : ^FORMATETC) -> HRESULT), | |
| SetData : (proc "stdcall" (This : ^IDataObject, pformatetc : ^FORMATETC, pmedium : ^STGMEDIUM, fRelease : BOOL) -> HRESULT), | |
| EnumFormatEtc : (proc "stdcall" (This : ^IDataObject, dwDirection : DWORD, ppenumFormatEtc : ^^IEnumFORMATETC) -> HRESULT), | |
| DAdvise : (proc "stdcall" (This : ^IDataObject, pformatetc : ^FORMATETC, advf : DWORD, pAdvSink : ^IAdviseSink, pdwConnection : ^DWORD) -> HRESULT), | |
| DUnadvise : (proc "stdcall" (This : ^IDataObject, dwConnection : DWORD) -> HRESULT), | |
| EnumDAdvise : (proc "stdcall" (This : ^IDataObject, ppenumAdvise : ^^IEnumSTATDATA) -> HRESULT), | |
| }; | |
| IDataObject :: struct { | |
| lpVtbl : ^IDataObjectVtbl, | |
| }; | |
| LPDATAADVISEHOLDER :: ^IDataAdviseHolder; | |
| IDataAdviseHolderVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IDataAdviseHolder, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IDataAdviseHolder) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IDataAdviseHolder) -> ULONG), | |
| Advise : (proc "stdcall" (This : ^IDataAdviseHolder, pDataObject : ^IDataObject, pFetc : ^FORMATETC, advf : DWORD, pAdvise : ^IAdviseSink, pdwConnection : ^DWORD) -> HRESULT), | |
| Unadvise : (proc "stdcall" (This : ^IDataAdviseHolder, dwConnection : DWORD) -> HRESULT), | |
| EnumAdvise : (proc "stdcall" (This : ^IDataAdviseHolder, ppenumAdvise : ^^IEnumSTATDATA) -> HRESULT), | |
| SendOnDataChange : (proc "stdcall" (This : ^IDataAdviseHolder, pDataObject : ^IDataObject, dwReserved : DWORD, advf : DWORD) -> HRESULT), | |
| }; | |
| IDataAdviseHolder :: struct { | |
| lpVtbl : ^IDataAdviseHolderVtbl, | |
| }; | |
| LPMESSAGEFILTER :: ^IMessageFilter; | |
| /* CALLTYPE :: enum { */ | |
| CALLTYPE :: _c.int; | |
| CALLTYPE_TOPLEVEL :: 1; | |
| CALLTYPE_NESTED :: 2; | |
| CALLTYPE_ASYNC :: 3; | |
| CALLTYPE_TOPLEVEL_CALLPENDING :: 4; | |
| CALLTYPE_ASYNC_CALLPENDING :: 5; | |
| /* } */ | |
| ; | |
| /* SERVERCALL :: enum { */ | |
| SERVERCALL :: _c.int; | |
| SERVERCALL_ISHANDLED :: 0; | |
| SERVERCALL_REJECTED :: 1; | |
| SERVERCALL_RETRYLATER :: 2; | |
| /* } */ | |
| ; | |
| /* PENDINGTYPE :: enum { */ | |
| PENDINGTYPE :: _c.int; | |
| PENDINGTYPE_TOPLEVEL :: 1; | |
| PENDINGTYPE_NESTED :: 2; | |
| /* } */ | |
| ; | |
| /* PENDINGMSG :: enum { */ | |
| PENDINGMSG :: _c.int; | |
| PENDINGMSG_CANCELCALL :: 0; | |
| PENDINGMSG_WAITNOPROCESS :: 1; | |
| PENDINGMSG_WAITDEFPROCESS :: 2; | |
| /* } */ | |
| ; | |
| INTERFACEINFO :: struct { | |
| pUnk : ^IUnknown, | |
| iid : IID, | |
| wMethod : WORD, | |
| }; | |
| LPINTERFACEINFO :: ^INTERFACEINFO; | |
| IMessageFilterVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IMessageFilter, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IMessageFilter) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IMessageFilter) -> ULONG), | |
| HandleInComingCall : (proc "stdcall" (This : ^IMessageFilter, dwCallType : DWORD, htaskCaller : HTASK, dwTickCount : DWORD, lpInterfaceInfo : LPINTERFACEINFO) -> DWORD), | |
| RetryRejectedCall : (proc "stdcall" (This : ^IMessageFilter, htaskCallee : HTASK, dwTickCount : DWORD, dwRejectType : DWORD) -> DWORD), | |
| MessagePending : (proc "stdcall" (This : ^IMessageFilter, htaskCallee : HTASK, dwTickCount : DWORD, dwPendingType : DWORD) -> DWORD), | |
| }; | |
| IMessageFilter :: struct { | |
| lpVtbl : ^IMessageFilterVtbl, | |
| }; | |
| IClassActivatorVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IClassActivator, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IClassActivator) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IClassActivator) -> ULONG), | |
| GetClassObject : (proc "stdcall" (This : ^IClassActivator, rclsid : ^IID, dwClassContext : DWORD, locale : LCID, riid : ^IID, ppv : ^rawptr) -> HRESULT), | |
| }; | |
| IClassActivator :: struct { | |
| lpVtbl : ^IClassActivatorVtbl, | |
| }; | |
| IFillLockBytesVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IFillLockBytes, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IFillLockBytes) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IFillLockBytes) -> ULONG), | |
| FillAppend : (proc "stdcall" (This : ^IFillLockBytes, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT), | |
| FillAt : (proc "stdcall" (This : ^IFillLockBytes, ulOffset : ULARGE_INTEGER, pv : rawptr, cb : ULONG, pcbWritten : ^ULONG) -> HRESULT), | |
| SetFillSize : (proc "stdcall" (This : ^IFillLockBytes, ulSize : ULARGE_INTEGER) -> HRESULT), | |
| Terminate : (proc "stdcall" (This : ^IFillLockBytes, bCanceled : BOOL) -> HRESULT), | |
| }; | |
| IFillLockBytes :: struct { | |
| lpVtbl : ^IFillLockBytesVtbl, | |
| }; | |
| IProgressNotifyVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IProgressNotify, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IProgressNotify) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IProgressNotify) -> ULONG), | |
| OnProgress : (proc "stdcall" (This : ^IProgressNotify, dwProgressCurrent : DWORD, dwProgressMaximum : DWORD, fAccurate : BOOL, fOwner : BOOL) -> HRESULT), | |
| }; | |
| IProgressNotify :: struct { | |
| lpVtbl : ^IProgressNotifyVtbl, | |
| }; | |
| StorageLayout :: struct { | |
| LayoutType : DWORD, | |
| pwcsElementName : ^OLECHAR, | |
| cOffset : LARGE_INTEGER, | |
| cBytes : LARGE_INTEGER, | |
| }; | |
| ILayoutStorageVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ILayoutStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ILayoutStorage) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ILayoutStorage) -> ULONG), | |
| LayoutScript : (proc "stdcall" (This : ^ILayoutStorage, pStorageLayout : ^StorageLayout, nEntries : DWORD, glfInterleavedFlag : DWORD) -> HRESULT), | |
| BeginMonitor : (proc "stdcall" (This : ^ILayoutStorage) -> HRESULT), | |
| EndMonitor : (proc "stdcall" (This : ^ILayoutStorage) -> HRESULT), | |
| ReLayoutDocfile : (proc "stdcall" (This : ^ILayoutStorage, pwcsNewDfName : ^OLECHAR) -> HRESULT), | |
| ReLayoutDocfileOnILockBytes : (proc "stdcall" (This : ^ILayoutStorage, pILockBytes : ^ILockBytes) -> HRESULT), | |
| }; | |
| ILayoutStorage :: struct { | |
| lpVtbl : ^ILayoutStorageVtbl, | |
| }; | |
| IBlockingLockVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IBlockingLock, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IBlockingLock) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IBlockingLock) -> ULONG), | |
| Lock : (proc "stdcall" (This : ^IBlockingLock, dwTimeout : DWORD) -> HRESULT), | |
| Unlock : (proc "stdcall" (This : ^IBlockingLock) -> HRESULT), | |
| }; | |
| IBlockingLock :: struct { | |
| lpVtbl : ^IBlockingLockVtbl, | |
| }; | |
| ITimeAndNoticeControlVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITimeAndNoticeControl, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITimeAndNoticeControl) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITimeAndNoticeControl) -> ULONG), | |
| SuppressChanges : (proc "stdcall" (This : ^ITimeAndNoticeControl, res1 : DWORD, res2 : DWORD) -> HRESULT), | |
| }; | |
| ITimeAndNoticeControl :: struct { | |
| lpVtbl : ^ITimeAndNoticeControlVtbl, | |
| }; | |
| IOplockStorageVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IOplockStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IOplockStorage) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IOplockStorage) -> ULONG), | |
| CreateStorageEx : (proc "stdcall" (This : ^IOplockStorage, pwcsName : LPCWSTR, grfMode : DWORD, stgfmt : DWORD, grfAttrs : DWORD, riid : ^IID, ppstgOpen : ^rawptr) -> HRESULT), | |
| OpenStorageEx : (proc "stdcall" (This : ^IOplockStorage, pwcsName : LPCWSTR, grfMode : DWORD, stgfmt : DWORD, grfAttrs : DWORD, riid : ^IID, ppstgOpen : ^rawptr) -> HRESULT), | |
| }; | |
| IOplockStorage :: struct { | |
| lpVtbl : ^IOplockStorageVtbl, | |
| }; | |
| IDirectWriterLockVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IDirectWriterLock, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IDirectWriterLock) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IDirectWriterLock) -> ULONG), | |
| WaitForWriteAccess : (proc "stdcall" (This : ^IDirectWriterLock, dwTimeout : DWORD) -> HRESULT), | |
| ReleaseWriteAccess : (proc "stdcall" (This : ^IDirectWriterLock) -> HRESULT), | |
| HaveWriteAccess : (proc "stdcall" (This : ^IDirectWriterLock) -> HRESULT), | |
| }; | |
| IDirectWriterLock :: struct { | |
| lpVtbl : ^IDirectWriterLockVtbl, | |
| }; | |
| IUrlMonVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IUrlMon, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IUrlMon) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IUrlMon) -> ULONG), | |
| AsyncGetClassBits : (proc "stdcall" (This : ^IUrlMon, rclsid : ^IID, pszTYPE : LPCWSTR, pszExt : LPCWSTR, dwFileVersionMS : DWORD, dwFileVersionLS : DWORD, pszCodeBase : LPCWSTR, pbc : ^IBindCtx, dwClassContext : DWORD, riid : ^IID, flags : DWORD) -> HRESULT), | |
| }; | |
| IUrlMon :: struct { | |
| lpVtbl : ^IUrlMonVtbl, | |
| }; | |
| IForegroundTransferVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IForegroundTransfer, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IForegroundTransfer) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IForegroundTransfer) -> ULONG), | |
| AllowForegroundTransfer : (proc "stdcall" (This : ^IForegroundTransfer, lpvReserved : rawptr) -> HRESULT), | |
| }; | |
| IForegroundTransfer :: struct { | |
| lpVtbl : ^IForegroundTransferVtbl, | |
| }; | |
| IThumbnailExtractorVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IThumbnailExtractor, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IThumbnailExtractor) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IThumbnailExtractor) -> ULONG), | |
| ExtractThumbnail : (proc "stdcall" (This : ^IThumbnailExtractor, pStg : ^IStorage, ulLength : ULONG, ulHeight : ULONG, pulOutputLength : ^ULONG, pulOutputHeight : ^ULONG, phOutputBitmap : ^HBITMAP) -> HRESULT), | |
| OnFileUpdated : (proc "stdcall" (This : ^IThumbnailExtractor, pStg : ^IStorage) -> HRESULT), | |
| }; | |
| IThumbnailExtractor :: struct { | |
| lpVtbl : ^IThumbnailExtractorVtbl, | |
| }; | |
| IDummyHICONIncluderVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IDummyHICONIncluder, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IDummyHICONIncluder) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IDummyHICONIncluder) -> ULONG), | |
| Dummy : (proc "stdcall" (This : ^IDummyHICONIncluder, h1 : HICON, h2 : HDC) -> HRESULT), | |
| }; | |
| IDummyHICONIncluder :: struct { | |
| lpVtbl : ^IDummyHICONIncluderVtbl, | |
| }; | |
| /* ApplicationType :: enum { */ | |
| ApplicationType :: _c.int; | |
| ServerApplication :: 0; | |
| LibraryApplication :: (ServerApplication + 1); | |
| /* } */ | |
| ; | |
| /* ShutdownType :: enum { */ | |
| ShutdownType :: _c.int; | |
| IdleShutdown :: 0; | |
| ForcedShutdown :: (IdleShutdown + 1); | |
| /* } */ | |
| ; | |
| IProcessLockVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IProcessLock, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IProcessLock) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IProcessLock) -> ULONG), | |
| AddRefOnProcess : (proc "stdcall" (This : ^IProcessLock) -> ULONG), | |
| ReleaseRefOnProcess : (proc "stdcall" (This : ^IProcessLock) -> ULONG), | |
| }; | |
| IProcessLock :: struct { | |
| lpVtbl : ^IProcessLockVtbl, | |
| }; | |
| ISurrogateServiceVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ISurrogateService, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ISurrogateService) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ISurrogateService) -> ULONG), | |
| Init : (proc "stdcall" (This : ^ISurrogateService, rguidProcessID : ^GUID, pProcessLock : ^IProcessLock, pfApplicationAware : ^BOOL) -> HRESULT), | |
| ApplicationLaunch : (proc "stdcall" (This : ^ISurrogateService, rguidApplID : ^GUID, appType : ApplicationType) -> HRESULT), | |
| ApplicationFree : (proc "stdcall" (This : ^ISurrogateService, rguidApplID : ^GUID) -> HRESULT), | |
| CatalogRefresh : (proc "stdcall" (This : ^ISurrogateService, ulReserved : ULONG) -> HRESULT), | |
| ProcessShutdown : (proc "stdcall" (This : ^ISurrogateService, shutdownType : ShutdownType) -> HRESULT), | |
| }; | |
| ISurrogateService :: struct { | |
| lpVtbl : ^ISurrogateServiceVtbl, | |
| }; | |
| LPINITIALIZESPY :: ^IInitializeSpy; | |
| IInitializeSpyVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IInitializeSpy, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IInitializeSpy) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IInitializeSpy) -> ULONG), | |
| PreInitialize : (proc "stdcall" (This : ^IInitializeSpy, dwCoInit : DWORD, dwCurThreadAptRefs : DWORD) -> HRESULT), | |
| PostInitialize : (proc "stdcall" (This : ^IInitializeSpy, hrCoInit : HRESULT, dwCoInit : DWORD, dwNewThreadAptRefs : DWORD) -> HRESULT), | |
| PreUninitialize : (proc "stdcall" (This : ^IInitializeSpy, dwCurThreadAptRefs : DWORD) -> HRESULT), | |
| PostUninitialize : (proc "stdcall" (This : ^IInitializeSpy, dwNewThreadAptRefs : DWORD) -> HRESULT), | |
| }; | |
| IInitializeSpy :: struct { | |
| lpVtbl : ^IInitializeSpyVtbl, | |
| }; | |
| IApartmentShutdownVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IApartmentShutdown, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IApartmentShutdown) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IApartmentShutdown) -> ULONG), | |
| OnUninitialize : proc "stdcall" (This : ^IApartmentShutdown, ui64ApartmentIdentifier : UINT64), | |
| }; | |
| IApartmentShutdown :: struct { | |
| lpVtbl : ^IApartmentShutdownVtbl, | |
| }; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| ; | |
| CURRENCY :: CY; | |
| SAFEARRAYBOUND :: struct { | |
| cElements : ULONG, | |
| lLbound : LONG, | |
| }; | |
| LPSAFEARRAYBOUND :: ^SAFEARRAYBOUND; | |
| wireVARIANT :: ^_wireVARIANT; | |
| wireBRECORD :: ^_wireBRECORD; | |
| SAFEARR_BSTR :: struct { | |
| Size : ULONG, | |
| aBstr : ^wireBSTR, | |
| }; | |
| SAFEARR_UNKNOWN :: struct { | |
| Size : ULONG, | |
| apUnknown : ^^IUnknown, | |
| }; | |
| SAFEARR_DISPATCH :: struct { | |
| Size : ULONG, | |
| apDispatch : ^^IDispatch, | |
| }; | |
| SAFEARR_VARIANT :: struct { | |
| Size : ULONG, | |
| aVariant : ^wireVARIANT, | |
| }; | |
| SAFEARR_BRECORD :: struct { | |
| Size : ULONG, | |
| aRecord : ^wireBRECORD, | |
| }; | |
| SAFEARR_HAVEIID :: struct { | |
| Size : ULONG, | |
| apUnknown : ^^IUnknown, | |
| iid : IID, | |
| }; | |
| /* SF_TYPE :: enum { */ | |
| SF_TYPE :: _c.int; | |
| SF_ERROR :: VT_ERROR; | |
| SF_I1 :: VT_I1; | |
| SF_I2 :: VT_I2; | |
| SF_I4 :: VT_I4; | |
| SF_I8 :: VT_I8; | |
| SF_BSTR :: VT_BSTR; | |
| SF_UNKNOWN :: VT_UNKNOWN; | |
| SF_DISPATCH :: VT_DISPATCH; | |
| SF_VARIANT :: VT_VARIANT; | |
| SF_RECORD :: VT_RECORD; | |
| SF_HAVEIID :: (VT_UNKNOWN | VT_RESERVED); | |
| /* } */ | |
| ; | |
| SAFEARRAYUNION :: struct { | |
| sfType : ULONG, | |
| u : struct #raw_union { | |
| BstrStr : SAFEARR_BSTR, | |
| UnknownStr : SAFEARR_UNKNOWN, | |
| DispatchStr : SAFEARR_DISPATCH, | |
| VariantStr : SAFEARR_VARIANT, | |
| RecordStr : SAFEARR_BRECORD, | |
| HaveIidStr : SAFEARR_HAVEIID, | |
| ByteStr : BYTE_SIZEDARR, | |
| WordStr : WORD_SIZEDARR, | |
| LongStr : DWORD_SIZEDARR, | |
| HyperStr : HYPER_SIZEDARR, | |
| }, | |
| }; | |
| wireSAFEARRAY :: ^struct { | |
| cDims : USHORT, | |
| fFeatures : USHORT, | |
| cbElements : ULONG, | |
| cLocks : ULONG, | |
| uArrayStructs : SAFEARRAYUNION, | |
| rgsabound : [1]SAFEARRAYBOUND, | |
| }; | |
| wirePSAFEARRAY :: ^wireSAFEARRAY; | |
| SAFEARRAY :: struct { | |
| cDims : USHORT, | |
| fFeatures : USHORT, | |
| cbElements : ULONG, | |
| cLocks : ULONG, | |
| pvData : PVOID, | |
| rgsabound : [1]SAFEARRAYBOUND, | |
| }; | |
| LPSAFEARRAY :: ^SAFEARRAY; | |
| ; | |
| VARIANT :: struct { | |
| n1 : struct #raw_union { | |
| n2 : struct { | |
| vt : VARTYPE, | |
| wReserved1 : WORD, | |
| wReserved2 : WORD, | |
| wReserved3 : WORD, | |
| n3 : struct #raw_union { | |
| llVal : LONGLONG, | |
| lVal : LONG, | |
| bVal : BYTE, | |
| iVal : SHORT, | |
| fltVal : FLOAT, | |
| dblVal : DOUBLE, | |
| boolVal : VARIANT_BOOL, | |
| __OBSOLETE__VARIANT_BOOL : VARIANT_BOOL, | |
| scode : SCODE, | |
| cyVal : CY, | |
| date : DATE, | |
| bstrVal : BSTR, | |
| punkVal : ^IUnknown, | |
| pdispVal : ^IDispatch, | |
| parray : ^SAFEARRAY, | |
| pbVal : ^BYTE, | |
| piVal : ^SHORT, | |
| plVal : ^LONG, | |
| pllVal : ^LONGLONG, | |
| pfltVal : ^FLOAT, | |
| pdblVal : ^DOUBLE, | |
| pboolVal : ^VARIANT_BOOL, | |
| __OBSOLETE__VARIANT_PBOOL : ^VARIANT_BOOL, | |
| pscode : ^SCODE, | |
| pcyVal : ^CY, | |
| pdate : ^DATE, | |
| pbstrVal : ^BSTR, | |
| ppunkVal : ^^IUnknown, | |
| ppdispVal : ^^IDispatch, | |
| pparray : ^^SAFEARRAY, | |
| pvarVal : ^VARIANT, | |
| byref : PVOID, | |
| cVal : CHAR, | |
| uiVal : USHORT, | |
| ulVal : ULONG, | |
| ullVal : ULONGLONG, | |
| intVal : INT, | |
| uintVal : UINT, | |
| pdecVal : ^DECIMAL, | |
| pcVal : ^CHAR, | |
| puiVal : ^USHORT, | |
| pulVal : ^ULONG, | |
| pullVal : ^ULONGLONG, | |
| pintVal : ^INT, | |
| puintVal : ^UINT, | |
| brecVal : struct { | |
| pvRecord : PVOID, | |
| pRecInfo : ^IRecordInfo, | |
| }, | |
| }, | |
| }, | |
| decVal : DECIMAL, | |
| }, | |
| }; | |
| LPVARIANT :: ^VARIANT; | |
| VARIANTARG :: VARIANT; | |
| LPVARIANTARG :: ^VARIANT; | |
| _wireBRECORD :: struct { | |
| fFlags : ULONG, | |
| clSize : ULONG, | |
| pRecInfo : ^IRecordInfo, | |
| pRecord : ^byte, | |
| }; | |
| _wireVARIANT :: struct { | |
| clSize : DWORD, | |
| rpcReserved : DWORD, | |
| vt : USHORT, | |
| wReserved1 : USHORT, | |
| wReserved2 : USHORT, | |
| wReserved3 : USHORT, | |
| u : struct #raw_union { | |
| llVal : LONGLONG, | |
| lVal : LONG, | |
| bVal : BYTE, | |
| iVal : SHORT, | |
| fltVal : FLOAT, | |
| dblVal : DOUBLE, | |
| boolVal : VARIANT_BOOL, | |
| scode : SCODE, | |
| cyVal : CY, | |
| date : DATE, | |
| bstrVal : wireBSTR, | |
| punkVal : ^IUnknown, | |
| pdispVal : ^IDispatch, | |
| parray : wirePSAFEARRAY, | |
| brecVal : wireBRECORD, | |
| pbVal : ^BYTE, | |
| piVal : ^SHORT, | |
| plVal : ^LONG, | |
| pllVal : ^LONGLONG, | |
| pfltVal : ^FLOAT, | |
| pdblVal : ^DOUBLE, | |
| pboolVal : ^VARIANT_BOOL, | |
| pscode : ^SCODE, | |
| pcyVal : ^CY, | |
| pdate : ^DATE, | |
| pbstrVal : ^wireBSTR, | |
| ppunkVal : ^^IUnknown, | |
| ppdispVal : ^^IDispatch, | |
| pparray : ^wirePSAFEARRAY, | |
| pvarVal : ^wireVARIANT, | |
| cVal : CHAR, | |
| uiVal : USHORT, | |
| ulVal : ULONG, | |
| ullVal : ULONGLONG, | |
| intVal : INT, | |
| uintVal : UINT, | |
| decVal : DECIMAL, | |
| pdecVal : ^DECIMAL, | |
| pcVal : ^CHAR, | |
| puiVal : ^USHORT, | |
| pulVal : ^ULONG, | |
| pullVal : ^ULONGLONG, | |
| pintVal : ^INT, | |
| puintVal : ^UINT, | |
| }, | |
| }; | |
| DISPID :: LONG; | |
| MEMBERID :: DISPID; | |
| HREFTYPE :: DWORD; | |
| /* TYPEKIND :: enum { */ | |
| TYPEKIND :: _c.int; | |
| TKIND_ENUM :: 0; | |
| TKIND_RECORD :: (TKIND_ENUM + 1); | |
| TKIND_MODULE :: (TKIND_RECORD + 1); | |
| TKIND_INTERFACE :: (TKIND_MODULE + 1); | |
| TKIND_DISPATCH :: (TKIND_INTERFACE + 1); | |
| TKIND_COCLASS :: (TKIND_DISPATCH + 1); | |
| TKIND_ALIAS :: (TKIND_COCLASS + 1); | |
| TKIND_UNION :: (TKIND_ALIAS + 1); | |
| TKIND_MAX :: (TKIND_UNION + 1); | |
| /* } */ | |
| ; | |
| TYPEDESC :: struct { | |
| u : struct #raw_union { | |
| lptdesc : ^TYPEDESC, | |
| lpadesc : ^ARRAYDESC, | |
| hreftype : HREFTYPE, | |
| }, | |
| vt : VARTYPE, | |
| }; | |
| ARRAYDESC :: struct { | |
| tdescElem : TYPEDESC, | |
| cDims : USHORT, | |
| rgbounds : [1]SAFEARRAYBOUND, | |
| }; | |
| PARAMDESCEX :: struct { | |
| cBytes : ULONG, | |
| varDefaultValue : VARIANTARG, | |
| }; | |
| LPPARAMDESCEX :: ^PARAMDESCEX; | |
| PARAMDESC :: struct { | |
| pparamdescex : LPPARAMDESCEX, | |
| wParamFlags : USHORT, | |
| }; | |
| LPPARAMDESC :: ^PARAMDESC; | |
| IDLDESC :: struct { | |
| dwReserved : ULONG_PTR, | |
| wIDLFlags : USHORT, | |
| }; | |
| LPIDLDESC :: ^IDLDESC; | |
| ELEMDESC :: struct { | |
| tdesc : TYPEDESC, | |
| u : struct #raw_union { | |
| idldesc : IDLDESC, | |
| paramdesc : PARAMDESC, | |
| }, | |
| }; | |
| LPELEMDESC :: ^ELEMDESC; | |
| TYPEATTR :: struct { | |
| guid : GUID, | |
| lcid : LCID, | |
| dwReserved : DWORD, | |
| memidConstructor : MEMBERID, | |
| memidDestructor : MEMBERID, | |
| lpstrSchema : LPOLESTR, | |
| cbSizeInstance : ULONG, | |
| typekind : TYPEKIND, | |
| cFuncs : WORD, | |
| cVars : WORD, | |
| cImplTypes : WORD, | |
| cbSizeVft : WORD, | |
| cbAlignment : WORD, | |
| wTypeFlags : WORD, | |
| wMajorVerNum : WORD, | |
| wMinorVerNum : WORD, | |
| tdescAlias : TYPEDESC, | |
| idldescType : IDLDESC, | |
| }; | |
| LPTYPEATTR :: ^TYPEATTR; | |
| DISPPARAMS :: struct { | |
| rgvarg : ^VARIANTARG, | |
| rgdispidNamedArgs : ^DISPID, | |
| cArgs : UINT, | |
| cNamedArgs : UINT, | |
| }; | |
| EXCEPINFO :: struct { | |
| wCode : WORD, | |
| wReserved : WORD, | |
| bstrSource : BSTR, | |
| bstrDescription : BSTR, | |
| bstrHelpFile : BSTR, | |
| dwHelpContext : DWORD, | |
| pvReserved : PVOID, | |
| pfnDeferredFillIn : (proc "stdcall" (^EXCEPINFO) -> HRESULT), | |
| scode : SCODE, | |
| }; | |
| LPEXCEPINFO :: ^EXCEPINFO; | |
| /* CALLCONV :: enum { */ | |
| CALLCONV :: _c.int; | |
| CC_FASTCALL :: 0; | |
| CC_CDECL :: 1; | |
| CC_MSCPASCAL :: (CC_CDECL + 1); | |
| CC_PASCAL :: CC_MSCPASCAL; | |
| CC_MACPASCAL :: (CC_PASCAL + 1); | |
| CC_STDCALL :: (CC_MACPASCAL + 1); | |
| CC_FPFASTCALL :: (CC_STDCALL + 1); | |
| CC_SYSCALL :: (CC_FPFASTCALL + 1); | |
| CC_MPWCDECL :: (CC_SYSCALL + 1); | |
| CC_MPWPASCAL :: (CC_MPWCDECL + 1); | |
| CC_MAX :: (CC_MPWPASCAL + 1); | |
| /* } */ | |
| ; | |
| /* FUNCKIND :: enum { */ | |
| FUNCKIND :: _c.int; | |
| FUNC_VIRTUAL :: 0; | |
| FUNC_PUREVIRTUAL :: (FUNC_VIRTUAL + 1); | |
| FUNC_NONVIRTUAL :: (FUNC_PUREVIRTUAL + 1); | |
| FUNC_STATIC :: (FUNC_NONVIRTUAL + 1); | |
| FUNC_DISPATCH :: (FUNC_STATIC + 1); | |
| /* } */ | |
| ; | |
| /* INVOKEKIND :: enum { */ | |
| INVOKEKIND :: _c.int; | |
| INVOKE_FUNC :: 1; | |
| INVOKE_PROPERTYGET :: 2; | |
| INVOKE_PROPERTYPUT :: 4; | |
| INVOKE_PROPERTYPUTREF :: 8; | |
| /* } */ | |
| ; | |
| FUNCDESC :: struct { | |
| memid : MEMBERID, | |
| lprgscode : ^SCODE, | |
| lprgelemdescParam : ^ELEMDESC, | |
| funckind : FUNCKIND, | |
| invkind : INVOKEKIND, | |
| callconv : CALLCONV, | |
| cParams : SHORT, | |
| cParamsOpt : SHORT, | |
| oVft : SHORT, | |
| cScodes : SHORT, | |
| elemdescFunc : ELEMDESC, | |
| wFuncFlags : WORD, | |
| }; | |
| LPFUNCDESC :: ^FUNCDESC; | |
| /* VARKIND :: enum { */ | |
| VARKIND :: _c.int; | |
| VAR_PERINSTANCE :: 0; | |
| VAR_STATIC :: (VAR_PERINSTANCE + 1); | |
| VAR_CONST :: (VAR_STATIC + 1); | |
| VAR_DISPATCH :: (VAR_CONST + 1); | |
| /* } */ | |
| ; | |
| VARDESC :: struct { | |
| memid : MEMBERID, | |
| lpstrSchema : LPOLESTR, | |
| u : struct #raw_union { | |
| oInst : ULONG, | |
| lpvarValue : ^VARIANT, | |
| }, | |
| elemdescVar : ELEMDESC, | |
| wVarFlags : WORD, | |
| varkind : VARKIND, | |
| }; | |
| LPVARDESC :: ^VARDESC; | |
| /* TYPEFLAGS :: enum { */ | |
| TYPEFLAGS :: _c.int; | |
| TYPEFLAG_FAPPOBJECT :: 0x1; | |
| TYPEFLAG_FCANCREATE :: 0x2; | |
| TYPEFLAG_FLICENSED :: 0x4; | |
| TYPEFLAG_FPREDECLID :: 0x8; | |
| TYPEFLAG_FHIDDEN :: 0x10; | |
| TYPEFLAG_FCONTROL :: 0x20; | |
| TYPEFLAG_FDUAL :: 0x40; | |
| TYPEFLAG_FNONEXTENSIBLE :: 0x80; | |
| TYPEFLAG_FOLEAUTOMATION :: 0x100; | |
| TYPEFLAG_FRESTRICTED :: 0x200; | |
| TYPEFLAG_FAGGREGATABLE :: 0x400; | |
| TYPEFLAG_FREPLACEABLE :: 0x800; | |
| TYPEFLAG_FDISPATCHABLE :: 0x1000; | |
| TYPEFLAG_FREVERSEBIND :: 0x2000; | |
| TYPEFLAG_FPROXY :: 0x4000; | |
| /* } */ | |
| ; | |
| /* FUNCFLAGS :: enum { */ | |
| FUNCFLAGS :: _c.int; | |
| FUNCFLAG_FRESTRICTED :: 0x1; | |
| FUNCFLAG_FSOURCE :: 0x2; | |
| FUNCFLAG_FBINDABLE :: 0x4; | |
| FUNCFLAG_FREQUESTEDIT :: 0x8; | |
| FUNCFLAG_FDISPLAYBIND :: 0x10; | |
| FUNCFLAG_FDEFAULTBIND :: 0x20; | |
| FUNCFLAG_FHIDDEN :: 0x40; | |
| FUNCFLAG_FUSESGETLASTERROR :: 0x80; | |
| FUNCFLAG_FDEFAULTCOLLELEM :: 0x100; | |
| FUNCFLAG_FUIDEFAULT :: 0x200; | |
| FUNCFLAG_FNONBROWSABLE :: 0x400; | |
| FUNCFLAG_FREPLACEABLE :: 0x800; | |
| FUNCFLAG_FIMMEDIATEBIND :: 0x1000; | |
| /* } */ | |
| ; | |
| /* VARFLAGS :: enum { */ | |
| VARFLAGS :: _c.int; | |
| VARFLAG_FREADONLY :: 0x1; | |
| VARFLAG_FSOURCE :: 0x2; | |
| VARFLAG_FBINDABLE :: 0x4; | |
| VARFLAG_FREQUESTEDIT :: 0x8; | |
| VARFLAG_FDISPLAYBIND :: 0x10; | |
| VARFLAG_FDEFAULTBIND :: 0x20; | |
| VARFLAG_FHIDDEN :: 0x40; | |
| VARFLAG_FRESTRICTED :: 0x80; | |
| VARFLAG_FDEFAULTCOLLELEM :: 0x100; | |
| VARFLAG_FUIDEFAULT :: 0x200; | |
| VARFLAG_FNONBROWSABLE :: 0x400; | |
| VARFLAG_FREPLACEABLE :: 0x800; | |
| VARFLAG_FIMMEDIATEBIND :: 0x1000; | |
| /* } */ | |
| ; | |
| CLEANLOCALSTORAGE :: struct { | |
| pInterface : ^IUnknown, | |
| pStorage : PVOID, | |
| flags : DWORD, | |
| }; | |
| CUSTDATAITEM :: struct { | |
| guid : GUID, | |
| varValue : VARIANTARG, | |
| }; | |
| LPCUSTDATAITEM :: ^CUSTDATAITEM; | |
| CUSTDATA :: struct { | |
| cCustData : DWORD, | |
| prgCustData : LPCUSTDATAITEM, | |
| }; | |
| LPCUSTDATA :: ^CUSTDATA; | |
| LPCREATETYPEINFO :: ^ICreateTypeInfo; | |
| ICreateTypeInfoVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ICreateTypeInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ICreateTypeInfo) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ICreateTypeInfo) -> ULONG), | |
| SetGuid : (proc "stdcall" (This : ^ICreateTypeInfo, guid : ^GUID) -> HRESULT), | |
| SetTypeFlags : (proc "stdcall" (This : ^ICreateTypeInfo, uTypeFlags : UINT) -> HRESULT), | |
| SetDocString : (proc "stdcall" (This : ^ICreateTypeInfo, pStrDoc : LPOLESTR) -> HRESULT), | |
| SetHelpContext : (proc "stdcall" (This : ^ICreateTypeInfo, dwHelpContext : DWORD) -> HRESULT), | |
| SetVersion : (proc "stdcall" (This : ^ICreateTypeInfo, wMajorVerNum : WORD, wMinorVerNum : WORD) -> HRESULT), | |
| AddRefTypeInfo : (proc "stdcall" (This : ^ICreateTypeInfo, pTInfo : ^ITypeInfo, phRefType : ^HREFTYPE) -> HRESULT), | |
| AddFuncDesc : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, pFuncDesc : ^FUNCDESC) -> HRESULT), | |
| AddImplType : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, hRefType : HREFTYPE) -> HRESULT), | |
| SetImplTypeFlags : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, implTypeFlags : INT) -> HRESULT), | |
| SetAlignment : (proc "stdcall" (This : ^ICreateTypeInfo, cbAlignment : WORD) -> HRESULT), | |
| SetSchema : (proc "stdcall" (This : ^ICreateTypeInfo, pStrSchema : LPOLESTR) -> HRESULT), | |
| AddVarDesc : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, pVarDesc : ^VARDESC) -> HRESULT), | |
| SetFuncAndParamNames : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, rgszNames : ^LPOLESTR, cNames : UINT) -> HRESULT), | |
| SetVarName : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, szName : LPOLESTR) -> HRESULT), | |
| SetTypeDescAlias : (proc "stdcall" (This : ^ICreateTypeInfo, pTDescAlias : ^TYPEDESC) -> HRESULT), | |
| DefineFuncAsDllEntry : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, szDllName : LPOLESTR, szProcName : LPOLESTR) -> HRESULT), | |
| SetFuncDocString : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, szDocString : LPOLESTR) -> HRESULT), | |
| SetVarDocString : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, szDocString : LPOLESTR) -> HRESULT), | |
| SetFuncHelpContext : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, dwHelpContext : DWORD) -> HRESULT), | |
| SetVarHelpContext : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, dwHelpContext : DWORD) -> HRESULT), | |
| SetMops : (proc "stdcall" (This : ^ICreateTypeInfo, index : UINT, bstrMops : BSTR) -> HRESULT), | |
| SetTypeIdldesc : (proc "stdcall" (This : ^ICreateTypeInfo, pIdlDesc : ^IDLDESC) -> HRESULT), | |
| LayOut : (proc "stdcall" (This : ^ICreateTypeInfo) -> HRESULT), | |
| }; | |
| ICreateTypeInfo :: struct { | |
| lpVtbl : ^ICreateTypeInfoVtbl, | |
| }; | |
| LPCREATETYPEINFO2 :: ^ICreateTypeInfo2; | |
| ICreateTypeInfo2Vtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ICreateTypeInfo2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ICreateTypeInfo2) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ICreateTypeInfo2) -> ULONG), | |
| SetGuid : (proc "stdcall" (This : ^ICreateTypeInfo2, guid : ^GUID) -> HRESULT), | |
| SetTypeFlags : (proc "stdcall" (This : ^ICreateTypeInfo2, uTypeFlags : UINT) -> HRESULT), | |
| SetDocString : (proc "stdcall" (This : ^ICreateTypeInfo2, pStrDoc : LPOLESTR) -> HRESULT), | |
| SetHelpContext : (proc "stdcall" (This : ^ICreateTypeInfo2, dwHelpContext : DWORD) -> HRESULT), | |
| SetVersion : (proc "stdcall" (This : ^ICreateTypeInfo2, wMajorVerNum : WORD, wMinorVerNum : WORD) -> HRESULT), | |
| AddRefTypeInfo : (proc "stdcall" (This : ^ICreateTypeInfo2, pTInfo : ^ITypeInfo, phRefType : ^HREFTYPE) -> HRESULT), | |
| AddFuncDesc : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, pFuncDesc : ^FUNCDESC) -> HRESULT), | |
| AddImplType : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, hRefType : HREFTYPE) -> HRESULT), | |
| SetImplTypeFlags : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, implTypeFlags : INT) -> HRESULT), | |
| SetAlignment : (proc "stdcall" (This : ^ICreateTypeInfo2, cbAlignment : WORD) -> HRESULT), | |
| SetSchema : (proc "stdcall" (This : ^ICreateTypeInfo2, pStrSchema : LPOLESTR) -> HRESULT), | |
| AddVarDesc : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, pVarDesc : ^VARDESC) -> HRESULT), | |
| SetFuncAndParamNames : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, rgszNames : ^LPOLESTR, cNames : UINT) -> HRESULT), | |
| SetVarName : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, szName : LPOLESTR) -> HRESULT), | |
| SetTypeDescAlias : (proc "stdcall" (This : ^ICreateTypeInfo2, pTDescAlias : ^TYPEDESC) -> HRESULT), | |
| DefineFuncAsDllEntry : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, szDllName : LPOLESTR, szProcName : LPOLESTR) -> HRESULT), | |
| SetFuncDocString : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, szDocString : LPOLESTR) -> HRESULT), | |
| SetVarDocString : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, szDocString : LPOLESTR) -> HRESULT), | |
| SetFuncHelpContext : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, dwHelpContext : DWORD) -> HRESULT), | |
| SetVarHelpContext : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, dwHelpContext : DWORD) -> HRESULT), | |
| SetMops : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, bstrMops : BSTR) -> HRESULT), | |
| SetTypeIdldesc : (proc "stdcall" (This : ^ICreateTypeInfo2, pIdlDesc : ^IDLDESC) -> HRESULT), | |
| LayOut : (proc "stdcall" (This : ^ICreateTypeInfo2) -> HRESULT), | |
| DeleteFuncDesc : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT) -> HRESULT), | |
| DeleteFuncDescByMemId : (proc "stdcall" (This : ^ICreateTypeInfo2, memid : MEMBERID, invKind : INVOKEKIND) -> HRESULT), | |
| DeleteVarDesc : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT) -> HRESULT), | |
| DeleteVarDescByMemId : (proc "stdcall" (This : ^ICreateTypeInfo2, memid : MEMBERID) -> HRESULT), | |
| DeleteImplType : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT) -> HRESULT), | |
| SetCustData : (proc "stdcall" (This : ^ICreateTypeInfo2, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| SetFuncCustData : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| SetParamCustData : (proc "stdcall" (This : ^ICreateTypeInfo2, indexFunc : UINT, indexParam : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| SetVarCustData : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| SetImplTypeCustData : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| SetHelpStringContext : (proc "stdcall" (This : ^ICreateTypeInfo2, dwHelpStringContext : ULONG) -> HRESULT), | |
| SetFuncHelpStringContext : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, dwHelpStringContext : ULONG) -> HRESULT), | |
| SetVarHelpStringContext : (proc "stdcall" (This : ^ICreateTypeInfo2, index : UINT, dwHelpStringContext : ULONG) -> HRESULT), | |
| Invalidate : (proc "stdcall" (This : ^ICreateTypeInfo2) -> HRESULT), | |
| SetName : (proc "stdcall" (This : ^ICreateTypeInfo2, szName : LPOLESTR) -> HRESULT), | |
| }; | |
| ICreateTypeInfo2 :: struct { | |
| lpVtbl : ^ICreateTypeInfo2Vtbl, | |
| }; | |
| LPCREATETYPELIB :: ^ICreateTypeLib; | |
| ICreateTypeLibVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ICreateTypeLib, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ICreateTypeLib) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ICreateTypeLib) -> ULONG), | |
| CreateTypeInfo : (proc "stdcall" (This : ^ICreateTypeLib, szName : LPOLESTR, tkind : TYPEKIND, ppCTInfo : ^^ICreateTypeInfo) -> HRESULT), | |
| SetName : (proc "stdcall" (This : ^ICreateTypeLib, szName : LPOLESTR) -> HRESULT), | |
| SetVersion : (proc "stdcall" (This : ^ICreateTypeLib, wMajorVerNum : WORD, wMinorVerNum : WORD) -> HRESULT), | |
| SetGuid : (proc "stdcall" (This : ^ICreateTypeLib, guid : ^GUID) -> HRESULT), | |
| SetDocString : (proc "stdcall" (This : ^ICreateTypeLib, szDoc : LPOLESTR) -> HRESULT), | |
| SetHelpFileName : (proc "stdcall" (This : ^ICreateTypeLib, szHelpFileName : LPOLESTR) -> HRESULT), | |
| SetHelpContext : (proc "stdcall" (This : ^ICreateTypeLib, dwHelpContext : DWORD) -> HRESULT), | |
| SetLcid : (proc "stdcall" (This : ^ICreateTypeLib, lcid : LCID) -> HRESULT), | |
| SetLibFlags : (proc "stdcall" (This : ^ICreateTypeLib, uLibFlags : UINT) -> HRESULT), | |
| SaveAllChanges : (proc "stdcall" (This : ^ICreateTypeLib) -> HRESULT), | |
| }; | |
| ICreateTypeLib :: struct { | |
| lpVtbl : ^ICreateTypeLibVtbl, | |
| }; | |
| LPCREATETYPELIB2 :: ^ICreateTypeLib2; | |
| ICreateTypeLib2Vtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ICreateTypeLib2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ICreateTypeLib2) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ICreateTypeLib2) -> ULONG), | |
| CreateTypeInfo : (proc "stdcall" (This : ^ICreateTypeLib2, szName : LPOLESTR, tkind : TYPEKIND, ppCTInfo : ^^ICreateTypeInfo) -> HRESULT), | |
| SetName : (proc "stdcall" (This : ^ICreateTypeLib2, szName : LPOLESTR) -> HRESULT), | |
| SetVersion : (proc "stdcall" (This : ^ICreateTypeLib2, wMajorVerNum : WORD, wMinorVerNum : WORD) -> HRESULT), | |
| SetGuid : (proc "stdcall" (This : ^ICreateTypeLib2, guid : ^GUID) -> HRESULT), | |
| SetDocString : (proc "stdcall" (This : ^ICreateTypeLib2, szDoc : LPOLESTR) -> HRESULT), | |
| SetHelpFileName : (proc "stdcall" (This : ^ICreateTypeLib2, szHelpFileName : LPOLESTR) -> HRESULT), | |
| SetHelpContext : (proc "stdcall" (This : ^ICreateTypeLib2, dwHelpContext : DWORD) -> HRESULT), | |
| SetLcid : (proc "stdcall" (This : ^ICreateTypeLib2, lcid : LCID) -> HRESULT), | |
| SetLibFlags : (proc "stdcall" (This : ^ICreateTypeLib2, uLibFlags : UINT) -> HRESULT), | |
| SaveAllChanges : (proc "stdcall" (This : ^ICreateTypeLib2) -> HRESULT), | |
| DeleteTypeInfo : (proc "stdcall" (This : ^ICreateTypeLib2, szName : LPOLESTR) -> HRESULT), | |
| SetCustData : (proc "stdcall" (This : ^ICreateTypeLib2, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| SetHelpStringContext : (proc "stdcall" (This : ^ICreateTypeLib2, dwHelpStringContext : ULONG) -> HRESULT), | |
| SetHelpStringDll : (proc "stdcall" (This : ^ICreateTypeLib2, szFileName : LPOLESTR) -> HRESULT), | |
| }; | |
| ICreateTypeLib2 :: struct { | |
| lpVtbl : ^ICreateTypeLib2Vtbl, | |
| }; | |
| LPDISPATCH :: ^IDispatch; | |
| IDispatchVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IDispatch, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IDispatch) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IDispatch) -> ULONG), | |
| GetTypeInfoCount : (proc "stdcall" (This : ^IDispatch, pctinfo : ^UINT) -> HRESULT), | |
| GetTypeInfo : (proc "stdcall" (This : ^IDispatch, iTInfo : UINT, lcid : LCID, ppTInfo : ^^ITypeInfo) -> HRESULT), | |
| GetIDsOfNames : (proc "stdcall" (This : ^IDispatch, riid : ^IID, rgszNames : ^LPOLESTR, cNames : UINT, lcid : LCID, rgDispId : ^DISPID) -> HRESULT), | |
| Invoke : (proc "stdcall" (This : ^IDispatch, dispIdMember : DISPID, riid : ^IID, lcid : LCID, wFlags : WORD, pDispParams : ^DISPPARAMS, pVarResult : ^VARIANT, pExcepInfo : ^EXCEPINFO, puArgErr : ^UINT) -> HRESULT), | |
| }; | |
| IDispatch :: struct { | |
| lpVtbl : ^IDispatchVtbl, | |
| }; | |
| LPENUMVARIANT :: ^IEnumVARIANT; | |
| IEnumVARIANTVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IEnumVARIANT, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IEnumVARIANT) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IEnumVARIANT) -> ULONG), | |
| Next : (proc "stdcall" (This : ^IEnumVARIANT, celt : ULONG, rgVar : ^VARIANT, pCeltFetched : ^ULONG) -> HRESULT), | |
| Skip : (proc "stdcall" (This : ^IEnumVARIANT, celt : ULONG) -> HRESULT), | |
| Reset : (proc "stdcall" (This : ^IEnumVARIANT) -> HRESULT), | |
| Clone : (proc "stdcall" (This : ^IEnumVARIANT, ppEnum : ^^IEnumVARIANT) -> HRESULT), | |
| }; | |
| IEnumVARIANT :: struct { | |
| lpVtbl : ^IEnumVARIANTVtbl, | |
| }; | |
| LPTYPECOMP :: ^ITypeComp; | |
| /* DESCKIND :: enum { */ | |
| DESCKIND :: _c.int; | |
| DESCKIND_NONE :: 0; | |
| DESCKIND_FUNCDESC :: (DESCKIND_NONE + 1); | |
| DESCKIND_VARDESC :: (DESCKIND_FUNCDESC + 1); | |
| DESCKIND_TYPECOMP :: (DESCKIND_VARDESC + 1); | |
| DESCKIND_IMPLICITAPPOBJ :: (DESCKIND_TYPECOMP + 1); | |
| DESCKIND_MAX :: (DESCKIND_IMPLICITAPPOBJ + 1); | |
| /* } */ | |
| ; | |
| BINDPTR :: struct #raw_union { | |
| lpfuncdesc : ^FUNCDESC, | |
| lpvardesc : ^VARDESC, | |
| lptcomp : ^ITypeComp, | |
| }; | |
| LPBINDPTR :: ^BINDPTR; | |
| ITypeCompVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITypeComp, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITypeComp) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITypeComp) -> ULONG), | |
| Bind : (proc "stdcall" (This : ^ITypeComp, szName : LPOLESTR, lHashVal : ULONG, wFlags : WORD, ppTInfo : ^^ITypeInfo, pDescKind : ^DESCKIND, pBindPtr : ^BINDPTR) -> HRESULT), | |
| BindType : (proc "stdcall" (This : ^ITypeComp, szName : LPOLESTR, lHashVal : ULONG, ppTInfo : ^^ITypeInfo, ppTComp : ^^ITypeComp) -> HRESULT), | |
| }; | |
| ITypeComp :: struct { | |
| lpVtbl : ^ITypeCompVtbl, | |
| }; | |
| LPTYPEINFO :: ^ITypeInfo; | |
| ITypeInfoVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITypeInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITypeInfo) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITypeInfo) -> ULONG), | |
| GetTypeAttr : (proc "stdcall" (This : ^ITypeInfo, ppTypeAttr : ^^TYPEATTR) -> HRESULT), | |
| GetTypeComp : (proc "stdcall" (This : ^ITypeInfo, ppTComp : ^^ITypeComp) -> HRESULT), | |
| GetFuncDesc : (proc "stdcall" (This : ^ITypeInfo, index : UINT, ppFuncDesc : ^^FUNCDESC) -> HRESULT), | |
| GetVarDesc : (proc "stdcall" (This : ^ITypeInfo, index : UINT, ppVarDesc : ^^VARDESC) -> HRESULT), | |
| GetNames : (proc "stdcall" (This : ^ITypeInfo, memid : MEMBERID, rgBstrNames : ^BSTR, cMaxNames : UINT, pcNames : ^UINT) -> HRESULT), | |
| GetRefTypeOfImplType : (proc "stdcall" (This : ^ITypeInfo, index : UINT, pRefType : ^HREFTYPE) -> HRESULT), | |
| GetImplTypeFlags : (proc "stdcall" (This : ^ITypeInfo, index : UINT, pImplTypeFlags : ^INT) -> HRESULT), | |
| GetIDsOfNames : (proc "stdcall" (This : ^ITypeInfo, rgszNames : ^LPOLESTR, cNames : UINT, pMemId : ^MEMBERID) -> HRESULT), | |
| Invoke : (proc "stdcall" (This : ^ITypeInfo, pvInstance : PVOID, memid : MEMBERID, wFlags : WORD, pDispParams : ^DISPPARAMS, pVarResult : ^VARIANT, pExcepInfo : ^EXCEPINFO, puArgErr : ^UINT) -> HRESULT), | |
| GetDocumentation : (proc "stdcall" (This : ^ITypeInfo, memid : MEMBERID, pBstrName : ^BSTR, pBstrDocString : ^BSTR, pdwHelpContext : ^DWORD, pBstrHelpFile : ^BSTR) -> HRESULT), | |
| GetDllEntry : (proc "stdcall" (This : ^ITypeInfo, memid : MEMBERID, invKind : INVOKEKIND, pBstrDllName : ^BSTR, pBstrName : ^BSTR, pwOrdinal : ^WORD) -> HRESULT), | |
| GetRefTypeInfo : (proc "stdcall" (This : ^ITypeInfo, hRefType : HREFTYPE, ppTInfo : ^^ITypeInfo) -> HRESULT), | |
| AddressOfMember : (proc "stdcall" (This : ^ITypeInfo, memid : MEMBERID, invKind : INVOKEKIND, ppv : ^PVOID) -> HRESULT), | |
| CreateInstance : (proc "stdcall" (This : ^ITypeInfo, pUnkOuter : ^IUnknown, riid : ^IID, ppvObj : ^PVOID) -> HRESULT), | |
| GetMops : (proc "stdcall" (This : ^ITypeInfo, memid : MEMBERID, pBstrMops : ^BSTR) -> HRESULT), | |
| GetContainingTypeLib : (proc "stdcall" (This : ^ITypeInfo, ppTLib : ^^ITypeLib, pIndex : ^UINT) -> HRESULT), | |
| ReleaseTypeAttr : proc "stdcall" (This : ^ITypeInfo, pTypeAttr : ^TYPEATTR), | |
| ReleaseFuncDesc : proc "stdcall" (This : ^ITypeInfo, pFuncDesc : ^FUNCDESC), | |
| ReleaseVarDesc : proc "stdcall" (This : ^ITypeInfo, pVarDesc : ^VARDESC), | |
| }; | |
| ITypeInfo :: struct { | |
| lpVtbl : ^ITypeInfoVtbl, | |
| }; | |
| LPTYPEINFO2 :: ^ITypeInfo2; | |
| ITypeInfo2Vtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITypeInfo2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITypeInfo2) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITypeInfo2) -> ULONG), | |
| GetTypeAttr : (proc "stdcall" (This : ^ITypeInfo2, ppTypeAttr : ^^TYPEATTR) -> HRESULT), | |
| GetTypeComp : (proc "stdcall" (This : ^ITypeInfo2, ppTComp : ^^ITypeComp) -> HRESULT), | |
| GetFuncDesc : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, ppFuncDesc : ^^FUNCDESC) -> HRESULT), | |
| GetVarDesc : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, ppVarDesc : ^^VARDESC) -> HRESULT), | |
| GetNames : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, rgBstrNames : ^BSTR, cMaxNames : UINT, pcNames : ^UINT) -> HRESULT), | |
| GetRefTypeOfImplType : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, pRefType : ^HREFTYPE) -> HRESULT), | |
| GetImplTypeFlags : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, pImplTypeFlags : ^INT) -> HRESULT), | |
| GetIDsOfNames : (proc "stdcall" (This : ^ITypeInfo2, rgszNames : ^LPOLESTR, cNames : UINT, pMemId : ^MEMBERID) -> HRESULT), | |
| Invoke : (proc "stdcall" (This : ^ITypeInfo2, pvInstance : PVOID, memid : MEMBERID, wFlags : WORD, pDispParams : ^DISPPARAMS, pVarResult : ^VARIANT, pExcepInfo : ^EXCEPINFO, puArgErr : ^UINT) -> HRESULT), | |
| GetDocumentation : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, pBstrName : ^BSTR, pBstrDocString : ^BSTR, pdwHelpContext : ^DWORD, pBstrHelpFile : ^BSTR) -> HRESULT), | |
| GetDllEntry : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, invKind : INVOKEKIND, pBstrDllName : ^BSTR, pBstrName : ^BSTR, pwOrdinal : ^WORD) -> HRESULT), | |
| GetRefTypeInfo : (proc "stdcall" (This : ^ITypeInfo2, hRefType : HREFTYPE, ppTInfo : ^^ITypeInfo) -> HRESULT), | |
| AddressOfMember : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, invKind : INVOKEKIND, ppv : ^PVOID) -> HRESULT), | |
| CreateInstance : (proc "stdcall" (This : ^ITypeInfo2, pUnkOuter : ^IUnknown, riid : ^IID, ppvObj : ^PVOID) -> HRESULT), | |
| GetMops : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, pBstrMops : ^BSTR) -> HRESULT), | |
| GetContainingTypeLib : (proc "stdcall" (This : ^ITypeInfo2, ppTLib : ^^ITypeLib, pIndex : ^UINT) -> HRESULT), | |
| ReleaseTypeAttr : proc "stdcall" (This : ^ITypeInfo2, pTypeAttr : ^TYPEATTR), | |
| ReleaseFuncDesc : proc "stdcall" (This : ^ITypeInfo2, pFuncDesc : ^FUNCDESC), | |
| ReleaseVarDesc : proc "stdcall" (This : ^ITypeInfo2, pVarDesc : ^VARDESC), | |
| GetTypeKind : (proc "stdcall" (This : ^ITypeInfo2, pTypeKind : ^TYPEKIND) -> HRESULT), | |
| GetTypeFlags : (proc "stdcall" (This : ^ITypeInfo2, pTypeFlags : ^ULONG) -> HRESULT), | |
| GetFuncIndexOfMemId : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, invKind : INVOKEKIND, pFuncIndex : ^UINT) -> HRESULT), | |
| GetVarIndexOfMemId : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, pVarIndex : ^UINT) -> HRESULT), | |
| GetCustData : (proc "stdcall" (This : ^ITypeInfo2, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| GetFuncCustData : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| GetParamCustData : (proc "stdcall" (This : ^ITypeInfo2, indexFunc : UINT, indexParam : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| GetVarCustData : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| GetImplTypeCustData : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| GetDocumentation2 : (proc "stdcall" (This : ^ITypeInfo2, memid : MEMBERID, lcid : LCID, pbstrHelpString : ^BSTR, pdwHelpStringContext : ^DWORD, pbstrHelpStringDll : ^BSTR) -> HRESULT), | |
| GetAllCustData : (proc "stdcall" (This : ^ITypeInfo2, pCustData : ^CUSTDATA) -> HRESULT), | |
| GetAllFuncCustData : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, pCustData : ^CUSTDATA) -> HRESULT), | |
| GetAllParamCustData : (proc "stdcall" (This : ^ITypeInfo2, indexFunc : UINT, indexParam : UINT, pCustData : ^CUSTDATA) -> HRESULT), | |
| GetAllVarCustData : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, pCustData : ^CUSTDATA) -> HRESULT), | |
| GetAllImplTypeCustData : (proc "stdcall" (This : ^ITypeInfo2, index : UINT, pCustData : ^CUSTDATA) -> HRESULT), | |
| }; | |
| ITypeInfo2 :: struct { | |
| lpVtbl : ^ITypeInfo2Vtbl, | |
| }; | |
| /* SYSKIND :: enum { */ | |
| SYSKIND :: _c.int; | |
| SYS_WIN16 :: 0; | |
| SYS_WIN32 :: (SYS_WIN16 + 1); | |
| SYS_MAC :: (SYS_WIN32 + 1); | |
| SYS_WIN64 :: (SYS_MAC + 1); | |
| /* } */ | |
| ; | |
| /* LIBFLAGS :: enum { */ | |
| LIBFLAGS :: _c.int; | |
| LIBFLAG_FRESTRICTED :: 0x1; | |
| LIBFLAG_FCONTROL :: 0x2; | |
| LIBFLAG_FHIDDEN :: 0x4; | |
| LIBFLAG_FHASDISKIMAGE :: 0x8; | |
| /* } */ | |
| ; | |
| LPTYPELIB :: ^ITypeLib; | |
| TLIBATTR :: struct { | |
| guid : GUID, | |
| lcid : LCID, | |
| syskind : SYSKIND, | |
| wMajorVerNum : WORD, | |
| wMinorVerNum : WORD, | |
| wLibFlags : WORD, | |
| }; | |
| LPTLIBATTR :: ^TLIBATTR; | |
| ITypeLibVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITypeLib, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITypeLib) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITypeLib) -> ULONG), | |
| GetTypeInfoCount : (proc "stdcall" (This : ^ITypeLib) -> UINT), | |
| GetTypeInfo : (proc "stdcall" (This : ^ITypeLib, index : UINT, ppTInfo : ^^ITypeInfo) -> HRESULT), | |
| GetTypeInfoType : (proc "stdcall" (This : ^ITypeLib, index : UINT, pTKind : ^TYPEKIND) -> HRESULT), | |
| GetTypeInfoOfGuid : (proc "stdcall" (This : ^ITypeLib, guid : ^GUID, ppTinfo : ^^ITypeInfo) -> HRESULT), | |
| GetLibAttr : (proc "stdcall" (This : ^ITypeLib, ppTLibAttr : ^^TLIBATTR) -> HRESULT), | |
| GetTypeComp : (proc "stdcall" (This : ^ITypeLib, ppTComp : ^^ITypeComp) -> HRESULT), | |
| GetDocumentation : (proc "stdcall" (This : ^ITypeLib, index : INT, pBstrName : ^BSTR, pBstrDocString : ^BSTR, pdwHelpContext : ^DWORD, pBstrHelpFile : ^BSTR) -> HRESULT), | |
| IsName : (proc "stdcall" (This : ^ITypeLib, szNameBuf : LPOLESTR, lHashVal : ULONG, pfName : ^BOOL) -> HRESULT), | |
| FindName : (proc "stdcall" (This : ^ITypeLib, szNameBuf : LPOLESTR, lHashVal : ULONG, ppTInfo : ^^ITypeInfo, rgMemId : ^MEMBERID, pcFound : ^USHORT) -> HRESULT), | |
| ReleaseTLibAttr : proc "stdcall" (This : ^ITypeLib, pTLibAttr : ^TLIBATTR), | |
| }; | |
| ITypeLib :: struct { | |
| lpVtbl : ^ITypeLibVtbl, | |
| }; | |
| LPTYPELIB2 :: ^ITypeLib2; | |
| ITypeLib2Vtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITypeLib2, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITypeLib2) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITypeLib2) -> ULONG), | |
| GetTypeInfoCount : (proc "stdcall" (This : ^ITypeLib2) -> UINT), | |
| GetTypeInfo : (proc "stdcall" (This : ^ITypeLib2, index : UINT, ppTInfo : ^^ITypeInfo) -> HRESULT), | |
| GetTypeInfoType : (proc "stdcall" (This : ^ITypeLib2, index : UINT, pTKind : ^TYPEKIND) -> HRESULT), | |
| GetTypeInfoOfGuid : (proc "stdcall" (This : ^ITypeLib2, guid : ^GUID, ppTinfo : ^^ITypeInfo) -> HRESULT), | |
| GetLibAttr : (proc "stdcall" (This : ^ITypeLib2, ppTLibAttr : ^^TLIBATTR) -> HRESULT), | |
| GetTypeComp : (proc "stdcall" (This : ^ITypeLib2, ppTComp : ^^ITypeComp) -> HRESULT), | |
| GetDocumentation : (proc "stdcall" (This : ^ITypeLib2, index : INT, pBstrName : ^BSTR, pBstrDocString : ^BSTR, pdwHelpContext : ^DWORD, pBstrHelpFile : ^BSTR) -> HRESULT), | |
| IsName : (proc "stdcall" (This : ^ITypeLib2, szNameBuf : LPOLESTR, lHashVal : ULONG, pfName : ^BOOL) -> HRESULT), | |
| FindName : (proc "stdcall" (This : ^ITypeLib2, szNameBuf : LPOLESTR, lHashVal : ULONG, ppTInfo : ^^ITypeInfo, rgMemId : ^MEMBERID, pcFound : ^USHORT) -> HRESULT), | |
| ReleaseTLibAttr : proc "stdcall" (This : ^ITypeLib2, pTLibAttr : ^TLIBATTR), | |
| GetCustData : (proc "stdcall" (This : ^ITypeLib2, guid : ^GUID, pVarVal : ^VARIANT) -> HRESULT), | |
| GetLibStatistics : (proc "stdcall" (This : ^ITypeLib2, pcUniqueNames : ^ULONG, pcchUniqueNames : ^ULONG) -> HRESULT), | |
| GetDocumentation2 : (proc "stdcall" (This : ^ITypeLib2, index : INT, lcid : LCID, pbstrHelpString : ^BSTR, pdwHelpStringContext : ^DWORD, pbstrHelpStringDll : ^BSTR) -> HRESULT), | |
| GetAllCustData : (proc "stdcall" (This : ^ITypeLib2, pCustData : ^CUSTDATA) -> HRESULT), | |
| }; | |
| ITypeLib2 :: struct { | |
| lpVtbl : ^ITypeLib2Vtbl, | |
| }; | |
| LPTYPECHANGEEVENTS :: ^ITypeChangeEvents; | |
| /* CHANGEKIND :: enum { */ | |
| CHANGEKIND :: _c.int; | |
| CHANGEKIND_ADDMEMBER :: 0; | |
| CHANGEKIND_DELETEMEMBER :: (CHANGEKIND_ADDMEMBER + 1); | |
| CHANGEKIND_SETNAMES :: (CHANGEKIND_DELETEMEMBER + 1); | |
| CHANGEKIND_SETDOCUMENTATION :: (CHANGEKIND_SETNAMES + 1); | |
| CHANGEKIND_GENERAL :: (CHANGEKIND_SETDOCUMENTATION + 1); | |
| CHANGEKIND_INVALIDATE :: (CHANGEKIND_GENERAL + 1); | |
| CHANGEKIND_CHANGEFAILED :: (CHANGEKIND_INVALIDATE + 1); | |
| CHANGEKIND_MAX :: (CHANGEKIND_CHANGEFAILED + 1); | |
| /* } */ | |
| ; | |
| ITypeChangeEventsVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITypeChangeEvents, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITypeChangeEvents) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITypeChangeEvents) -> ULONG), | |
| RequestTypeChange : (proc "stdcall" (This : ^ITypeChangeEvents, changeKind : CHANGEKIND, pTInfoBefore : ^ITypeInfo, pStrName : LPOLESTR, pfCancel : ^INT) -> HRESULT), | |
| AfterTypeChange : (proc "stdcall" (This : ^ITypeChangeEvents, changeKind : CHANGEKIND, pTInfoAfter : ^ITypeInfo, pStrName : LPOLESTR) -> HRESULT), | |
| }; | |
| ITypeChangeEvents :: struct { | |
| lpVtbl : ^ITypeChangeEventsVtbl, | |
| }; | |
| LPERRORINFO :: ^IErrorInfo; | |
| IErrorInfoVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IErrorInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IErrorInfo) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IErrorInfo) -> ULONG), | |
| GetGUID : (proc "stdcall" (This : ^IErrorInfo, pGUID : ^GUID) -> HRESULT), | |
| GetSource : (proc "stdcall" (This : ^IErrorInfo, pBstrSource : ^BSTR) -> HRESULT), | |
| GetDescription : (proc "stdcall" (This : ^IErrorInfo, pBstrDescription : ^BSTR) -> HRESULT), | |
| GetHelpFile : (proc "stdcall" (This : ^IErrorInfo, pBstrHelpFile : ^BSTR) -> HRESULT), | |
| GetHelpContext : (proc "stdcall" (This : ^IErrorInfo, pdwHelpContext : ^DWORD) -> HRESULT), | |
| }; | |
| IErrorInfo :: struct { | |
| lpVtbl : ^IErrorInfoVtbl, | |
| }; | |
| LPCREATEERRORINFO :: ^ICreateErrorInfo; | |
| ICreateErrorInfoVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ICreateErrorInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ICreateErrorInfo) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ICreateErrorInfo) -> ULONG), | |
| SetGUID : (proc "stdcall" (This : ^ICreateErrorInfo, rguid : ^GUID) -> HRESULT), | |
| SetSource : (proc "stdcall" (This : ^ICreateErrorInfo, szSource : LPOLESTR) -> HRESULT), | |
| SetDescription : (proc "stdcall" (This : ^ICreateErrorInfo, szDescription : LPOLESTR) -> HRESULT), | |
| SetHelpFile : (proc "stdcall" (This : ^ICreateErrorInfo, szHelpFile : LPOLESTR) -> HRESULT), | |
| SetHelpContext : (proc "stdcall" (This : ^ICreateErrorInfo, dwHelpContext : DWORD) -> HRESULT), | |
| }; | |
| ICreateErrorInfo :: struct { | |
| lpVtbl : ^ICreateErrorInfoVtbl, | |
| }; | |
| LPSUPPORTERRORINFO :: ^ISupportErrorInfo; | |
| ISupportErrorInfoVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ISupportErrorInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ISupportErrorInfo) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ISupportErrorInfo) -> ULONG), | |
| InterfaceSupportsErrorInfo : (proc "stdcall" (This : ^ISupportErrorInfo, riid : ^IID) -> HRESULT), | |
| }; | |
| ISupportErrorInfo :: struct { | |
| lpVtbl : ^ISupportErrorInfoVtbl, | |
| }; | |
| ITypeFactoryVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITypeFactory, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITypeFactory) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITypeFactory) -> ULONG), | |
| CreateFromTypeInfo : (proc "stdcall" (This : ^ITypeFactory, pTypeInfo : ^ITypeInfo, riid : ^IID, ppv : ^^IUnknown) -> HRESULT), | |
| }; | |
| ITypeFactory :: struct { | |
| lpVtbl : ^ITypeFactoryVtbl, | |
| }; | |
| ITypeMarshalVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITypeMarshal, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITypeMarshal) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITypeMarshal) -> ULONG), | |
| Size : (proc "stdcall" (This : ^ITypeMarshal, pvType : PVOID, dwDestContext : DWORD, pvDestContext : PVOID, pSize : ^ULONG) -> HRESULT), | |
| Marshal : (proc "stdcall" (This : ^ITypeMarshal, pvType : PVOID, dwDestContext : DWORD, pvDestContext : PVOID, cbBufferLength : ULONG, pBuffer : ^BYTE, pcbWritten : ^ULONG) -> HRESULT), | |
| Unmarshal : (proc "stdcall" (This : ^ITypeMarshal, pvType : PVOID, dwFlags : DWORD, cbBufferLength : ULONG, pBuffer : ^BYTE, pcbRead : ^ULONG) -> HRESULT), | |
| Free : (proc "stdcall" (This : ^ITypeMarshal, pvType : PVOID) -> HRESULT), | |
| }; | |
| ITypeMarshal :: struct { | |
| lpVtbl : ^ITypeMarshalVtbl, | |
| }; | |
| LPRECORDINFO :: ^IRecordInfo; | |
| IRecordInfoVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IRecordInfo, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IRecordInfo) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IRecordInfo) -> ULONG), | |
| RecordInit : (proc "stdcall" (This : ^IRecordInfo, pvNew : PVOID) -> HRESULT), | |
| RecordClear : (proc "stdcall" (This : ^IRecordInfo, pvExisting : PVOID) -> HRESULT), | |
| RecordCopy : (proc "stdcall" (This : ^IRecordInfo, pvExisting : PVOID, pvNew : PVOID) -> HRESULT), | |
| GetGuid : (proc "stdcall" (This : ^IRecordInfo, pguid : ^GUID) -> HRESULT), | |
| GetName : (proc "stdcall" (This : ^IRecordInfo, pbstrName : ^BSTR) -> HRESULT), | |
| GetSize : (proc "stdcall" (This : ^IRecordInfo, pcbSize : ^ULONG) -> HRESULT), | |
| GetTypeInfo : (proc "stdcall" (This : ^IRecordInfo, ppTypeInfo : ^^ITypeInfo) -> HRESULT), | |
| GetField : (proc "stdcall" (This : ^IRecordInfo, pvData : PVOID, szFieldName : LPCOLESTR, pvarField : ^VARIANT) -> HRESULT), | |
| GetFieldNoCopy : (proc "stdcall" (This : ^IRecordInfo, pvData : PVOID, szFieldName : LPCOLESTR, pvarField : ^VARIANT, ppvDataCArray : ^PVOID) -> HRESULT), | |
| PutField : (proc "stdcall" (This : ^IRecordInfo, wFlags : ULONG, pvData : PVOID, szFieldName : LPCOLESTR, pvarField : ^VARIANT) -> HRESULT), | |
| PutFieldNoCopy : (proc "stdcall" (This : ^IRecordInfo, wFlags : ULONG, pvData : PVOID, szFieldName : LPCOLESTR, pvarField : ^VARIANT) -> HRESULT), | |
| GetFieldNames : (proc "stdcall" (This : ^IRecordInfo, pcNames : ^ULONG, rgBstrNames : ^BSTR) -> HRESULT), | |
| IsMatchingType : (proc "stdcall" (This : ^IRecordInfo, pRecordInfo : ^IRecordInfo) -> BOOL), | |
| RecordCreate : (proc "stdcall" (This : ^IRecordInfo) -> PVOID), | |
| RecordCreateCopy : (proc "stdcall" (This : ^IRecordInfo, pvSource : PVOID, ppvDest : ^PVOID) -> HRESULT), | |
| RecordDestroy : (proc "stdcall" (This : ^IRecordInfo, pvRecord : PVOID) -> HRESULT), | |
| }; | |
| IRecordInfo :: struct { | |
| lpVtbl : ^IRecordInfoVtbl, | |
| }; | |
| LPERRORLOG :: ^IErrorLog; | |
| IErrorLogVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IErrorLog, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IErrorLog) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IErrorLog) -> ULONG), | |
| AddError : (proc "stdcall" (This : ^IErrorLog, pszPropName : LPCOLESTR, pExcepInfo : ^EXCEPINFO) -> HRESULT), | |
| }; | |
| IErrorLog :: struct { | |
| lpVtbl : ^IErrorLogVtbl, | |
| }; | |
| LPPROPERTYBAG :: ^IPropertyBag; | |
| IPropertyBagVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IPropertyBag, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IPropertyBag) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IPropertyBag) -> ULONG), | |
| Read : (proc "stdcall" (This : ^IPropertyBag, pszPropName : LPCOLESTR, pVar : ^VARIANT, pErrorLog : ^IErrorLog) -> HRESULT), | |
| Write : (proc "stdcall" (This : ^IPropertyBag, pszPropName : LPCOLESTR, pVar : ^VARIANT) -> HRESULT), | |
| }; | |
| IPropertyBag :: struct { | |
| lpVtbl : ^IPropertyBagVtbl, | |
| }; | |
| ITypeLibRegistrationReaderVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITypeLibRegistrationReader, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITypeLibRegistrationReader) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITypeLibRegistrationReader) -> ULONG), | |
| EnumTypeLibRegistrations : (proc "stdcall" (This : ^ITypeLibRegistrationReader, ppEnumUnknown : ^^IEnumUnknown) -> HRESULT), | |
| }; | |
| ITypeLibRegistrationReader :: struct { | |
| lpVtbl : ^ITypeLibRegistrationReaderVtbl, | |
| }; | |
| ITypeLibRegistrationVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^ITypeLibRegistration, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^ITypeLibRegistration) -> ULONG), | |
| Release : (proc "stdcall" (This : ^ITypeLibRegistration) -> ULONG), | |
| GetGuid : (proc "stdcall" (This : ^ITypeLibRegistration, pGuid : ^GUID) -> HRESULT), | |
| GetVersion : (proc "stdcall" (This : ^ITypeLibRegistration, pVersion : ^BSTR) -> HRESULT), | |
| GetLcid : (proc "stdcall" (This : ^ITypeLibRegistration, pLcid : ^LCID) -> HRESULT), | |
| GetWin32Path : (proc "stdcall" (This : ^ITypeLibRegistration, pWin32Path : ^BSTR) -> HRESULT), | |
| GetWin64Path : (proc "stdcall" (This : ^ITypeLibRegistration, pWin64Path : ^BSTR) -> HRESULT), | |
| GetDisplayName : (proc "stdcall" (This : ^ITypeLibRegistration, pDisplayName : ^BSTR) -> HRESULT), | |
| GetFlags : (proc "stdcall" (This : ^ITypeLibRegistration, pFlags : ^DWORD) -> HRESULT), | |
| GetHelpDir : (proc "stdcall" (This : ^ITypeLibRegistration, pHelpDir : ^BSTR) -> HRESULT), | |
| }; | |
| ITypeLibRegistration :: struct { | |
| lpVtbl : ^ITypeLibRegistrationVtbl, | |
| }; | |
| VERSIONEDSTREAM :: struct { | |
| guidVersion : GUID, | |
| pStream : ^IStream, | |
| }; | |
| LPVERSIONEDSTREAM :: ^VERSIONEDSTREAM; | |
| ; | |
| CAC :: struct { | |
| cElems : ULONG, | |
| pElems : ^CHAR, | |
| }; | |
| CAUB :: struct { | |
| cElems : ULONG, | |
| pElems : ^UCHAR, | |
| }; | |
| CAI :: struct { | |
| cElems : ULONG, | |
| pElems : ^SHORT, | |
| }; | |
| CAUI :: struct { | |
| cElems : ULONG, | |
| pElems : ^USHORT, | |
| }; | |
| CAL :: struct { | |
| cElems : ULONG, | |
| pElems : ^LONG, | |
| }; | |
| CAUL :: struct { | |
| cElems : ULONG, | |
| pElems : ^ULONG, | |
| }; | |
| CAFLT :: struct { | |
| cElems : ULONG, | |
| pElems : ^FLOAT, | |
| }; | |
| CADBL :: struct { | |
| cElems : ULONG, | |
| pElems : ^DOUBLE, | |
| }; | |
| CACY :: struct { | |
| cElems : ULONG, | |
| pElems : ^CY, | |
| }; | |
| CADATE :: struct { | |
| cElems : ULONG, | |
| pElems : ^DATE, | |
| }; | |
| CABSTR :: struct { | |
| cElems : ULONG, | |
| pElems : ^BSTR, | |
| }; | |
| CABSTRBLOB :: struct { | |
| cElems : ULONG, | |
| pElems : ^BSTRBLOB, | |
| }; | |
| CABOOL :: struct { | |
| cElems : ULONG, | |
| pElems : ^VARIANT_BOOL, | |
| }; | |
| CASCODE :: struct { | |
| cElems : ULONG, | |
| pElems : ^SCODE, | |
| }; | |
| CAPROPVARIANT :: struct { | |
| cElems : ULONG, | |
| pElems : ^PROPVARIANT, | |
| }; | |
| CAH :: struct { | |
| cElems : ULONG, | |
| pElems : ^LARGE_INTEGER, | |
| }; | |
| CAUH :: struct { | |
| cElems : ULONG, | |
| pElems : ^ULARGE_INTEGER, | |
| }; | |
| CALPSTR :: struct { | |
| cElems : ULONG, | |
| pElems : ^LPSTR, | |
| }; | |
| CALPWSTR :: struct { | |
| cElems : ULONG, | |
| pElems : ^LPWSTR, | |
| }; | |
| CAFILETIME :: struct { | |
| cElems : ULONG, | |
| pElems : ^FILETIME, | |
| }; | |
| CACLIPDATA :: struct { | |
| cElems : ULONG, | |
| pElems : ^CLIPDATA, | |
| }; | |
| CACLSID :: struct { | |
| cElems : ULONG, | |
| pElems : ^CLSID, | |
| }; | |
| PROPVAR_PAD1 :: WORD; | |
| PROPVAR_PAD2 :: WORD; | |
| PROPVAR_PAD3 :: WORD; | |
| LPPROPVARIANT :: ^PROPVARIANT; | |
| PROPSPEC :: struct { | |
| ulKind : ULONG, | |
| u : struct #raw_union { | |
| propid : PROPID, | |
| lpwstr : LPOLESTR, | |
| }, | |
| }; | |
| STATPROPSTG :: struct { | |
| lpwstrName : LPOLESTR, | |
| propid : PROPID, | |
| vt : VARTYPE, | |
| }; | |
| STATPROPSETSTG :: struct { | |
| fmtid : FMTID, | |
| clsid : CLSID, | |
| grfFlags : DWORD, | |
| mtime : FILETIME, | |
| ctime : FILETIME, | |
| atime : FILETIME, | |
| dwOSVersion : DWORD, | |
| }; | |
| IPropertyStorageVtbl :: struct { | |
| QueryInterface : (proc "stdcall" (This : ^IPropertyStorage, riid : ^IID, ppvObject : ^rawptr) -> HRESULT), | |
| AddRef : (proc "stdcall" (This : ^IPropertyStorage) -> ULONG), | |
| Release : (proc "stdcall" (This : ^IPropertyStorage) -> ULONG), | |
| ReadMultiple : (proc "stdcall" (This : ^IPropertyStorage, cpspec : ULONG, rgpspec : []PROPSPEC, rgpropvar : []PROPVARIANT) -> HRESULT), | |
| WriteMultiple : (proc "stdcall" (This : ^IPropertyStorage, cpspec : ULONG, rgpspec : []PROPSPEC, rgpropvar : []PROPVARIANT, propidNameFirst : PROPID) -> HRESULT), | |
| DeleteMultiple : (proc "stdcall" (This : ^IPropertyStorage, cpspec : ULONG, rgpspec : []PROPSPEC) -> HRESULT), | |
| ReadPropertyNames : (proc "stdcall" (This : ^IPropertyStorage, cpropid : ULONG, rgpropid : []PROPID, rglpwstrName : []LPOLESTR) -> HRESULT), | |
| WritePropertyNames : (proc "stdcall" (This : ^IPropertyStorage, cpropid : ULONG, rgpropid : []PROPID, rglpwstrName : []LPOLESTR |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment